Merge tag 'mac80211-next-for-davem-2016-04-13' of git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next into master

To synchronize with Kalle, here's just a big change that affects
all drivers - removing the duplicated enum ieee80211_band and
replacing it by enum nl80211_band. On top of that, just a small
documentation update.

469 files changed, 20538 insertions, 9075 deletions

diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c
index 95944d5e3e22..780f22876538 100644
--- a/drivers/net/dsa/bcm_sf2.c
+++ b/drivers/net/dsa/bcm_sf2.c
@@ -545,12 +545,11 @@ static void bcm_sf2_sw_br_leave(struct dsa_switch *ds, int port)
         priv->port_sts[port].bridge_dev = NULL;
 }
 
-static int bcm_sf2_sw_br_set_stp_state(struct dsa_switch *ds, int port,
-                                       u8 state)
+static void bcm_sf2_sw_br_set_stp_state(struct dsa_switch *ds, int port,
+                                        u8 state)
 {
         struct bcm_sf2_priv *priv = ds_to_priv(ds);
         u8 hw_state, cur_hw_state;
-        int ret = 0;
         u32 reg;
 
         reg = core_readl(priv, CORE_G_PCTL_PORT(port));
@@ -574,7 +573,7 @@ static int bcm_sf2_sw_br_set_stp_state(struct dsa_switch *ds, int port,
                 break;
         default:
                 pr_err("%s: invalid STP state: %d\n", __func__, state);
-                return -EINVAL;
+                return;
         }
 
         /* Fast-age ARL entries if we are moving a port from Learning or
@@ -584,10 +583,9 @@ static int bcm_sf2_sw_br_set_stp_state(struct dsa_switch *ds, int port,
         if (cur_hw_state != hw_state) {
                 if (cur_hw_state >= G_MISTP_LEARN_STATE &&
                     hw_state <= G_MISTP_LISTEN_STATE) {
-                        ret = bcm_sf2_sw_fast_age_port(ds, port);
-                        if (ret) {
+                        if (bcm_sf2_sw_fast_age_port(ds, port)) {
                                 pr_err("%s: fast-ageing failed\n", __func__);
-                                return ret;
+                                return;
                         }
                 }
         }
@@ -596,8 +594,6 @@ static int bcm_sf2_sw_br_set_stp_state(struct dsa_switch *ds, int port,
         reg &= ~(G_MISTP_STATE_MASK << G_MISTP_STATE_SHIFT);
         reg |= hw_state;
         core_writel(priv, reg, CORE_G_PCTL_PORT(port));
-
-        return 0;
 }
 
 /* Address Resolution Logic routines */
@@ -728,13 +724,14 @@ static int bcm_sf2_sw_fdb_prepare(struct dsa_switch *ds, int port,
         return 0;
 }
 
-static int bcm_sf2_sw_fdb_add(struct dsa_switch *ds, int port,
-                              const struct switchdev_obj_port_fdb *fdb,
-                              struct switchdev_trans *trans)
+static void bcm_sf2_sw_fdb_add(struct dsa_switch *ds, int port,
+                               const struct switchdev_obj_port_fdb *fdb,
+                               struct switchdev_trans *trans)
 {
         struct bcm_sf2_priv *priv = ds_to_priv(ds);
 
-        return bcm_sf2_arl_op(priv, 0, port, fdb->addr, fdb->vid, true);
+        if (bcm_sf2_arl_op(priv, 0, port, fdb->addr, fdb->vid, true))
+                pr_err("%s: failed to add MAC address\n", __func__);
 }
 
 static int bcm_sf2_sw_fdb_del(struct dsa_switch *ds, int port,
@@ -1387,7 +1384,7 @@ static struct dsa_switch_driver bcm_sf2_switch_driver = {
         .set_eee                = bcm_sf2_sw_set_eee,
         .port_bridge_join       = bcm_sf2_sw_br_join,
         .port_bridge_leave      = bcm_sf2_sw_br_leave,
-        .port_stp_update        = bcm_sf2_sw_br_set_stp_state,
+        .port_stp_state_set     = bcm_sf2_sw_br_set_stp_state,
         .port_fdb_prepare       = bcm_sf2_sw_fdb_prepare,
         .port_fdb_add           = bcm_sf2_sw_fdb_add,
         .port_fdb_del           = bcm_sf2_sw_fdb_del,
diff --git a/drivers/net/dsa/mv88e6131.c b/drivers/net/dsa/mv88e6131.c
index a92ca651c399..24070287c2bc 100644
--- a/drivers/net/dsa/mv88e6131.c
+++ b/drivers/net/dsa/mv88e6131.c
@@ -169,6 +169,17 @@ struct dsa_switch_driver mv88e6131_switch_driver = {
         .get_ethtool_stats      = mv88e6xxx_get_ethtool_stats,
         .get_sset_count         = mv88e6xxx_get_sset_count,
         .adjust_link            = mv88e6xxx_adjust_link,
+        .port_bridge_join       = mv88e6xxx_port_bridge_join,
+        .port_bridge_leave      = mv88e6xxx_port_bridge_leave,
+        .port_vlan_filtering    = mv88e6xxx_port_vlan_filtering,
+        .port_vlan_prepare      = mv88e6xxx_port_vlan_prepare,
+        .port_vlan_add          = mv88e6xxx_port_vlan_add,
+        .port_vlan_del          = mv88e6xxx_port_vlan_del,
+        .port_vlan_dump         = mv88e6xxx_port_vlan_dump,
+        .port_fdb_prepare       = mv88e6xxx_port_fdb_prepare,
+        .port_fdb_add           = mv88e6xxx_port_fdb_add,
+        .port_fdb_del           = mv88e6xxx_port_fdb_del,
+        .port_fdb_dump          = mv88e6xxx_port_fdb_dump,
 };
 
 MODULE_ALIAS("platform:mv88e6085");
diff --git a/drivers/net/dsa/mv88e6171.c b/drivers/net/dsa/mv88e6171.c
index c0164b98fc08..0e62f3b5bc81 100644
--- a/drivers/net/dsa/mv88e6171.c
+++ b/drivers/net/dsa/mv88e6171.c
@@ -105,7 +105,7 @@ struct dsa_switch_driver mv88e6171_switch_driver = {
         .get_regs               = mv88e6xxx_get_regs,
         .port_bridge_join       = mv88e6xxx_port_bridge_join,
         .port_bridge_leave      = mv88e6xxx_port_bridge_leave,
-        .port_stp_update        = mv88e6xxx_port_stp_update,
+        .port_stp_state_set     = mv88e6xxx_port_stp_state_set,
         .port_vlan_filtering    = mv88e6xxx_port_vlan_filtering,
         .port_vlan_prepare      = mv88e6xxx_port_vlan_prepare,
         .port_vlan_add          = mv88e6xxx_port_vlan_add,
diff --git a/drivers/net/dsa/mv88e6352.c b/drivers/net/dsa/mv88e6352.c
index 5f528abc8af1..7f452e4a04a5 100644
--- a/drivers/net/dsa/mv88e6352.c
+++ b/drivers/net/dsa/mv88e6352.c
@@ -326,7 +326,7 @@ struct dsa_switch_driver mv88e6352_switch_driver = {
         .get_regs               = mv88e6xxx_get_regs,
         .port_bridge_join       = mv88e6xxx_port_bridge_join,
         .port_bridge_leave      = mv88e6xxx_port_bridge_leave,
-        .port_stp_update        = mv88e6xxx_port_stp_update,
+        .port_stp_state_set     = mv88e6xxx_port_stp_state_set,
         .port_vlan_filtering    = mv88e6xxx_port_vlan_filtering,
         .port_vlan_prepare      = mv88e6xxx_port_vlan_prepare,
         .port_vlan_add          = mv88e6xxx_port_vlan_add,
diff --git a/drivers/net/dsa/mv88e6xxx.c b/drivers/net/dsa/mv88e6xxx.c
index fa086e09d6b7..62320fca6712 100644
--- a/drivers/net/dsa/mv88e6xxx.c
+++ b/drivers/net/dsa/mv88e6xxx.c
@@ -482,6 +482,50 @@ static bool mv88e6xxx_6352_family(struct dsa_switch *ds)
         return false;
 }
 
+static unsigned int mv88e6xxx_num_databases(struct dsa_switch *ds)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+
+        /* The following devices have 4-bit identifiers for 16 databases */
+        if (ps->id == PORT_SWITCH_ID_6061)
+                return 16;
+
+        /* The following devices have 6-bit identifiers for 64 databases */
+        if (ps->id == PORT_SWITCH_ID_6065)
+                return 64;
+
+        /* The following devices have 8-bit identifiers for 256 databases */
+        if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds))
+                return 256;
+
+        /* The following devices have 12-bit identifiers for 4096 databases */
+        if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
+            mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds))
+                return 4096;
+
+        return 0;
+}
+
+static bool mv88e6xxx_has_fid_reg(struct dsa_switch *ds)
+{
+        /* Does the device have dedicated FID registers for ATU and VTU ops? */
+        if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
+            mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds))
+                return true;
+
+        return false;
+}
+
+static bool mv88e6xxx_has_stu(struct dsa_switch *ds)
+{
+        /* Does the device have STU and dedicated SID registers for VTU ops? */
+        if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
+            mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds))
+                return true;
+
+        return false;
+}
+
 /* We expect the switch to perform auto negotiation if there is a real
  * phy. However, in the case of a fixed link phy, we force the port
  * settings from the fixed link settings.
@@ -951,10 +995,30 @@ out:
         return ret;
 }
 
-static int _mv88e6xxx_atu_cmd(struct dsa_switch *ds, u16 cmd)
+static int _mv88e6xxx_atu_cmd(struct dsa_switch *ds, u16 fid, u16 cmd)
 {
         int ret;
 
+        if (mv88e6xxx_has_fid_reg(ds)) {
+                ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, fid);
+                if (ret < 0)
+                        return ret;
+        } else if (mv88e6xxx_num_databases(ds) == 256) {
+                /* ATU DBNum[7:4] are located in ATU Control 15:12 */
+                ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_ATU_CONTROL);
+                if (ret < 0)
+                        return ret;
+
+                ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_CONTROL,
+                                           (ret & 0xfff) |
+                                           ((fid << 8) & 0xf000));
+                if (ret < 0)
+                        return ret;
+
+                /* ATU DBNum[3:0] are located in ATU Operation 3:0 */
+                cmd |= fid & 0xf;
+        }
+
         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_OP, cmd);
         if (ret < 0)
                 return ret;
@@ -1001,11 +1065,6 @@ static int _mv88e6xxx_atu_flush_move(struct dsa_switch *ds,
                 return err;
 
         if (entry->fid) {
-                err = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID,
-                                           entry->fid);
-                if (err)
-                        return err;
-
                 op = static_too ? GLOBAL_ATU_OP_FLUSH_MOVE_ALL_DB :
                         GLOBAL_ATU_OP_FLUSH_MOVE_NON_STATIC_DB;
         } else {
@@ -1013,7 +1072,7 @@ static int _mv88e6xxx_atu_flush_move(struct dsa_switch *ds,
                         GLOBAL_ATU_OP_FLUSH_MOVE_NON_STATIC;
         }
 
-        return _mv88e6xxx_atu_cmd(ds, op);
+        return _mv88e6xxx_atu_cmd(ds, entry->fid, op);
 }
 
 static int _mv88e6xxx_atu_flush(struct dsa_switch *ds, u16 fid, bool static_too)
@@ -1134,7 +1193,7 @@ static int _mv88e6xxx_port_based_vlan_map(struct dsa_switch *ds, int port)
         return _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_BASE_VLAN, reg);
 }
 
-int mv88e6xxx_port_stp_update(struct dsa_switch *ds, int port, u8 state)
+void mv88e6xxx_port_stp_state_set(struct dsa_switch *ds, int port, u8 state)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
         int stp_state;
@@ -1156,14 +1215,12 @@ int mv88e6xxx_port_stp_update(struct dsa_switch *ds, int port, u8 state)
                 break;
         }
 
-        /* mv88e6xxx_port_stp_update may be called with softirqs disabled,
+        /* mv88e6xxx_port_stp_state_set may be called with softirqs disabled,
          * so we can not update the port state directly but need to schedule it.
          */
         ps->ports[port].state = stp_state;
         set_bit(port, ps->port_state_update_mask);
         schedule_work(&ps->bridge_work);
-
-        return 0;
 }
 
 static int _mv88e6xxx_port_pvid(struct dsa_switch *ds, int port, u16 *new,
@@ -1321,15 +1378,27 @@ static int _mv88e6xxx_vtu_getnext(struct dsa_switch *ds,
                 if (ret < 0)
                         return ret;
 
-                if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
-                    mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds)) {
+                if (mv88e6xxx_has_fid_reg(ds)) {
                         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
                                                   GLOBAL_VTU_FID);
                         if (ret < 0)
                                 return ret;
 
                         next.fid = ret & GLOBAL_VTU_FID_MASK;
+                } else if (mv88e6xxx_num_databases(ds) == 256) {
+                        /* VTU DBNum[7:4] are located in VTU Operation 11:8, and
+                         * VTU DBNum[3:0] are located in VTU Operation 3:0
+                         */
+                        ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
+                                                  GLOBAL_VTU_OP);
+                        if (ret < 0)
+                                return ret;
+
+                        next.fid = (ret & 0xf00) >> 4;
+                        next.fid |= ret & 0xf;
+                }
 
+                if (mv88e6xxx_has_stu(ds)) {
                         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
                                                   GLOBAL_VTU_SID);
                         if (ret < 0)
@@ -1397,6 +1466,7 @@ unlock:
 static int _mv88e6xxx_vtu_loadpurge(struct dsa_switch *ds,
                                     struct mv88e6xxx_vtu_stu_entry *entry)
 {
+        u16 op = GLOBAL_VTU_OP_VTU_LOAD_PURGE;
         u16 reg = 0;
         int ret;
 
@@ -1412,17 +1482,24 @@ static int _mv88e6xxx_vtu_loadpurge(struct dsa_switch *ds,
         if (ret < 0)
                 return ret;
 
-        if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
-            mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds)) {
+        if (mv88e6xxx_has_stu(ds)) {
                 reg = entry->sid & GLOBAL_VTU_SID_MASK;
                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_SID, reg);
                 if (ret < 0)
                         return ret;
+        }
 
+        if (mv88e6xxx_has_fid_reg(ds)) {
                 reg = entry->fid & GLOBAL_VTU_FID_MASK;
                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_FID, reg);
                 if (ret < 0)
                         return ret;
+        } else if (mv88e6xxx_num_databases(ds) == 256) {
+                /* VTU DBNum[7:4] are located in VTU Operation 11:8, and
+                 * VTU DBNum[3:0] are located in VTU Operation 3:0
+                 */
+                op |= (entry->fid & 0xf0) << 8;
+                op |= entry->fid & 0xf;
         }
 
         reg = GLOBAL_VTU_VID_VALID;
@@ -1432,7 +1509,7 @@ loadpurge:
         if (ret < 0)
                 return ret;
 
-        return _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_VTU_LOAD_PURGE);
+        return _mv88e6xxx_vtu_cmd(ds, op);
 }
 
 static int _mv88e6xxx_stu_getnext(struct dsa_switch *ds, u8 sid,
@@ -1511,9 +1588,17 @@ loadpurge:
 static int _mv88e6xxx_port_fid(struct dsa_switch *ds, int port, u16 *new,
                                u16 *old)
 {
+        u16 upper_mask;
         u16 fid;
         int ret;
 
+        if (mv88e6xxx_num_databases(ds) == 4096)
+                upper_mask = 0xff;
+        else if (mv88e6xxx_num_databases(ds) == 256)
+                upper_mask = 0xf;
+        else
+                return -EOPNOTSUPP;
+
         /* Port's default FID bits 3:0 are located in reg 0x06, offset 12 */
         ret = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_BASE_VLAN);
         if (ret < 0)
@@ -1536,11 +1621,11 @@ static int _mv88e6xxx_port_fid(struct dsa_switch *ds, int port, u16 *new,
         if (ret < 0)
                 return ret;
 
-        fid |= (ret & PORT_CONTROL_1_FID_11_4_MASK) << 4;
+        fid |= (ret & upper_mask) << 4;
 
         if (new) {
-                ret &= ~PORT_CONTROL_1_FID_11_4_MASK;
-                ret |= (*new >> 4) & PORT_CONTROL_1_FID_11_4_MASK;
+                ret &= ~upper_mask;
+                ret |= (*new >> 4) & upper_mask;
 
                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_CONTROL_1,
                                            ret);
@@ -1604,7 +1689,7 @@ static int _mv88e6xxx_fid_new(struct dsa_switch *ds, u16 *fid)
          * databases are not needed. Return the next positive available.
          */
         *fid = find_next_zero_bit(fid_bitmap, MV88E6XXX_N_FID, 1);
-        if (unlikely(*fid == MV88E6XXX_N_FID))
+        if (unlikely(*fid >= mv88e6xxx_num_databases(ds)))
                 return -ENOSPC;
 
         /* Clear the database */
@@ -1823,31 +1908,27 @@ static int _mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port, u16 vid,
         return _mv88e6xxx_vtu_loadpurge(ds, &vlan);
 }
 
-int mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port,
-                            const struct switchdev_obj_port_vlan *vlan,
-                            struct switchdev_trans *trans)
+void mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port,
+                             const struct switchdev_obj_port_vlan *vlan,
+                             struct switchdev_trans *trans)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
         bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
         bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
         u16 vid;
-        int err = 0;
 
         mutex_lock(&ps->smi_mutex);
 
-        for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
-                err = _mv88e6xxx_port_vlan_add(ds, port, vid, untagged);
-                if (err)
-                        goto unlock;
-        }
+        for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid)
+                if (_mv88e6xxx_port_vlan_add(ds, port, vid, untagged))
+                        netdev_err(ds->ports[port], "failed to add VLAN %d%c\n",
+                                   vid, untagged ? 'u' : 't');
 
-        /* no PVID with ranges, otherwise it's a bug */
-        if (pvid)
-                err = _mv88e6xxx_port_pvid_set(ds, port, vlan->vid_end);
-unlock:
-        mutex_unlock(&ps->smi_mutex);
+        if (pvid && _mv88e6xxx_port_pvid_set(ds, port, vlan->vid_end))
+                netdev_err(ds->ports[port], "failed to set PVID %d\n",
+                           vlan->vid_end);
 
-        return err;
+        mutex_unlock(&ps->smi_mutex);
 }
 
 static int _mv88e6xxx_port_vlan_del(struct dsa_switch *ds, int port, u16 vid)
@@ -1965,11 +2046,7 @@ static int _mv88e6xxx_atu_load(struct dsa_switch *ds,
         if (ret < 0)
                 return ret;
 
-        ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, entry->fid);
-        if (ret < 0)
-                return ret;
-
-        return _mv88e6xxx_atu_cmd(ds, GLOBAL_ATU_OP_LOAD_DB);
+        return _mv88e6xxx_atu_cmd(ds, entry->fid, GLOBAL_ATU_OP_LOAD_DB);
 }
 
 static int _mv88e6xxx_port_fdb_load(struct dsa_switch *ds, int port,
@@ -2009,21 +2086,19 @@ int mv88e6xxx_port_fdb_prepare(struct dsa_switch *ds, int port,
         return 0;
 }
 
-int mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
-                           const struct switchdev_obj_port_fdb *fdb,
-                           struct switchdev_trans *trans)
+void mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
+                            const struct switchdev_obj_port_fdb *fdb,
+                            struct switchdev_trans *trans)
 {
         int state = is_multicast_ether_addr(fdb->addr) ?
                 GLOBAL_ATU_DATA_STATE_MC_STATIC :
                 GLOBAL_ATU_DATA_STATE_UC_STATIC;
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
-        int ret;
 
         mutex_lock(&ps->smi_mutex);
-        ret = _mv88e6xxx_port_fdb_load(ds, port, fdb->addr, fdb->vid, state);
+        if (_mv88e6xxx_port_fdb_load(ds, port, fdb->addr, fdb->vid, state))
+                netdev_err(ds->ports[port], "failed to load MAC address\n");
         mutex_unlock(&ps->smi_mutex);
-
-        return ret;
 }
 
 int mv88e6xxx_port_fdb_del(struct dsa_switch *ds, int port,
@@ -2052,11 +2127,7 @@ static int _mv88e6xxx_atu_getnext(struct dsa_switch *ds, u16 fid,
         if (ret < 0)
                 return ret;
 
-        ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, fid);
-        if (ret < 0)
-                return ret;
-
-        ret = _mv88e6xxx_atu_cmd(ds, GLOBAL_ATU_OP_GET_NEXT_DB);
+        ret = _mv88e6xxx_atu_cmd(ds, fid, GLOBAL_ATU_OP_GET_NEXT_DB);
         if (ret < 0)
                 return ret;
 
@@ -2264,6 +2335,57 @@ static void mv88e6xxx_bridge_work(struct work_struct *work)
         mutex_unlock(&ps->smi_mutex);
 }
 
+static int _mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
+                                     int reg, int val)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
+        if (ret < 0)
+                goto restore_page_0;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
+restore_page_0:
+        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+
+        return ret;
+}
+
+static int _mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page,
+                                    int reg)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
+        if (ret < 0)
+                goto restore_page_0;
+
+        ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
+restore_page_0:
+        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+
+        return ret;
+}
+
+static int mv88e6xxx_power_on_serdes(struct dsa_switch *ds)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_page_read(ds, REG_FIBER_SERDES, PAGE_FIBER_SERDES,
+                                       MII_BMCR);
+        if (ret < 0)
+                return ret;
+
+        if (ret & BMCR_PDOWN) {
+                ret &= ~BMCR_PDOWN;
+                ret = _mv88e6xxx_phy_page_write(ds, REG_FIBER_SERDES,
+                                                PAGE_FIBER_SERDES, MII_BMCR,
+                                                ret);
+        }
+
+        return ret;
+}
+
 static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
@@ -2367,6 +2489,23 @@ static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
                         goto abort;
         }
 
+        /* If this port is connected to a SerDes, make sure the SerDes is not
+         * powered down.
+         */
+        if (mv88e6xxx_6352_family(ds)) {
+                ret = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_STATUS);
+                if (ret < 0)
+                        goto abort;
+                ret &= PORT_STATUS_CMODE_MASK;
+                if ((ret == PORT_STATUS_CMODE_100BASE_X) ||
+                    (ret == PORT_STATUS_CMODE_1000BASE_X) ||
+                    (ret == PORT_STATUS_CMODE_SGMII)) {
+                        ret = mv88e6xxx_power_on_serdes(ds);
+                        if (ret < 0)
+                                goto abort;
+                }
+        }
+
         /* Port Control 2: don't force a good FCS, set the maximum frame size to
          * 10240 bytes, disable 802.1q tags checking, don't discard tagged or
          * untagged frames on this port, do a destination address lookup on all
@@ -2376,7 +2515,8 @@ static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
         reg = 0;
         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
-            mv88e6xxx_6095_family(ds) || mv88e6xxx_6320_family(ds))
+            mv88e6xxx_6095_family(ds) || mv88e6xxx_6320_family(ds) ||
+            mv88e6xxx_6185_family(ds))
                 reg = PORT_CONTROL_2_MAP_DA;
 
         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
@@ -2714,13 +2854,9 @@ int mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page, int reg)
         int ret;
 
         mutex_lock(&ps->smi_mutex);
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
-        if (ret < 0)
-                goto error;
-        ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
-error:
-        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+        ret = _mv88e6xxx_phy_page_read(ds, port, page, reg);
         mutex_unlock(&ps->smi_mutex);
+
         return ret;
 }
 
@@ -2731,14 +2867,9 @@ int mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
         int ret;
 
         mutex_lock(&ps->smi_mutex);
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
-        if (ret < 0)
-                goto error;
-
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
-error:
-        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+        ret = _mv88e6xxx_phy_page_write(ds, port, page, reg, val);
         mutex_unlock(&ps->smi_mutex);
+
         return ret;
 }
 
diff --git a/drivers/net/dsa/mv88e6xxx.h b/drivers/net/dsa/mv88e6xxx.h
index 9a038aba48fb..236bcaa606e7 100644
--- a/drivers/net/dsa/mv88e6xxx.h
+++ b/drivers/net/dsa/mv88e6xxx.h
@@ -28,6 +28,10 @@
 #define SMI_CMD_OP_45_READ_DATA_INC     ((3 << 10) | SMI_CMD_BUSY)
 #define SMI_DATA                0x01
 
+/* Fiber/SERDES Registers are located at SMI address F, page 1 */
+#define REG_FIBER_SERDES        0x0f
+#define PAGE_FIBER_SERDES       0x01
+
 #define REG_PORT(p)             (0x10 + (p))
 #define PORT_STATUS             0x00
 #define PORT_STATUS_PAUSE_EN    BIT(15)
@@ -45,6 +49,10 @@
 #define PORT_STATUS_MGMII       BIT(6) /* 6185 */
 #define PORT_STATUS_TX_PAUSED   BIT(5)
 #define PORT_STATUS_FLOW_CTRL   BIT(4)
+#define PORT_STATUS_CMODE_MASK  0x0f
+#define PORT_STATUS_CMODE_100BASE_X     0x8
+#define PORT_STATUS_CMODE_1000BASE_X    0x9
+#define PORT_STATUS_CMODE_SGMII         0xa
 #define PORT_PCS_CTRL           0x01
 #define PORT_PCS_CTRL_RGMII_DELAY_RXCLK BIT(15)
 #define PORT_PCS_CTRL_RGMII_DELAY_TXCLK BIT(14)
@@ -489,15 +497,15 @@ int mv88e6xxx_set_eee(struct dsa_switch *ds, int port,
 int mv88e6xxx_port_bridge_join(struct dsa_switch *ds, int port,
                                struct net_device *bridge);
 void mv88e6xxx_port_bridge_leave(struct dsa_switch *ds, int port);
-int mv88e6xxx_port_stp_update(struct dsa_switch *ds, int port, u8 state);
+void mv88e6xxx_port_stp_state_set(struct dsa_switch *ds, int port, u8 state);
 int mv88e6xxx_port_vlan_filtering(struct dsa_switch *ds, int port,
                                   bool vlan_filtering);
 int mv88e6xxx_port_vlan_prepare(struct dsa_switch *ds, int port,
                                 const struct switchdev_obj_port_vlan *vlan,
                                 struct switchdev_trans *trans);
-int mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port,
-                            const struct switchdev_obj_port_vlan *vlan,
-                            struct switchdev_trans *trans);
+void mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port,
+                             const struct switchdev_obj_port_vlan *vlan,
+                             struct switchdev_trans *trans);
 int mv88e6xxx_port_vlan_del(struct dsa_switch *ds, int port,
                             const struct switchdev_obj_port_vlan *vlan);
 int mv88e6xxx_port_vlan_dump(struct dsa_switch *ds, int port,
@@ -506,9 +514,9 @@ int mv88e6xxx_port_vlan_dump(struct dsa_switch *ds, int port,
 int mv88e6xxx_port_fdb_prepare(struct dsa_switch *ds, int port,
                                const struct switchdev_obj_port_fdb *fdb,
                                struct switchdev_trans *trans);
-int mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
-                           const struct switchdev_obj_port_fdb *fdb,
-                           struct switchdev_trans *trans);
+void mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
+                            const struct switchdev_obj_port_fdb *fdb,
+                            struct switchdev_trans *trans);
 int mv88e6xxx_port_fdb_del(struct dsa_switch *ds, int port,
                            const struct switchdev_obj_port_fdb *fdb);
 int mv88e6xxx_port_fdb_dump(struct dsa_switch *ds, int port,
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index aabbd51db981..597e4724a474 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -118,6 +118,12 @@ static const u16 bnxt_vf_req_snif[] = {
         HWRM_CFA_L2_FILTER_ALLOC,
 };
 
+static const u16 bnxt_async_events_arr[] = {
+        HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE,
+        HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD,
+        HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED,
+};
+
 static bool bnxt_vf_pciid(enum board_idx idx)
 {
         return (idx == BCM57304_VF || idx == BCM57404_VF);
@@ -1231,6 +1237,19 @@ next_rx_no_prod:
         return rc;
 }
 
+#define BNXT_GET_EVENT_PORT(data)       \
+        ((data) &                               \
+         HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_PORT_ID_MASK)
+
+#define BNXT_EVENT_POLICY_MASK  \
+        HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_MASK
+
+#define BNXT_EVENT_POLICY_SFT   \
+        HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_SFT
+
+#define BNXT_GET_EVENT_POLICY(data)     \
+        (((data) & BNXT_EVENT_POLICY_MASK) >> BNXT_EVENT_POLICY_SFT)
+
 static int bnxt_async_event_process(struct bnxt *bp,
                                     struct hwrm_async_event_cmpl *cmpl)
 {
@@ -1244,6 +1263,22 @@ static int bnxt_async_event_process(struct bnxt *bp,
         case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD:
                 set_bit(BNXT_HWRM_PF_UNLOAD_SP_EVENT, &bp->sp_event);
                 break;
+        case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED: {
+                u32 data1 = le32_to_cpu(cmpl->event_data1);
+                u16 port_id = BNXT_GET_EVENT_PORT(data1);
+
+                if (BNXT_VF(bp))
+                        break;
+
+                if (bp->pf.port_id != port_id)
+                        break;
+
+                bp->link_info.last_port_module_event =
+                        BNXT_GET_EVENT_POLICY(data1);
+
+                set_bit(BNXT_HWRM_PORT_MODULE_SP_EVENT, &bp->sp_event);
+                break;
+        }
         default:
                 netdev_err(bp->dev, "unhandled ASYNC event (id 0x%x)\n",
                            event_id);
@@ -2653,7 +2688,7 @@ static int bnxt_hwrm_do_send_msg(struct bnxt *bp, void *msg, u32 msg_len,
         /* Write request msg to hwrm channel */
         __iowrite32_copy(bp->bar0, data, msg_len / 4);
 
-        for (i = msg_len; i < HWRM_MAX_REQ_LEN; i += 4)
+        for (i = msg_len; i < BNXT_HWRM_MAX_REQ_LEN; i += 4)
                 writel(0, bp->bar0 + i);
 
         /* currently supports only one outstanding message */
@@ -2751,6 +2786,8 @@ static int bnxt_hwrm_func_drv_rgtr(struct bnxt *bp)
 {
         struct hwrm_func_drv_rgtr_input req = {0};
         int i;
+        DECLARE_BITMAP(async_events_bmap, 256);
+        u32 *events = (u32 *)async_events_bmap;
 
         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_FUNC_DRV_RGTR, -1, -1);
 
@@ -2759,11 +2796,14 @@ static int bnxt_hwrm_func_drv_rgtr(struct bnxt *bp)
                             FUNC_DRV_RGTR_REQ_ENABLES_VER |
                             FUNC_DRV_RGTR_REQ_ENABLES_ASYNC_EVENT_FWD);
 
-        /* TODO: current async event fwd bits are not defined and the firmware
-         * only checks if it is non-zero to enable async event forwarding
-         */
-        req.async_event_fwd[0] |= cpu_to_le32(1);
-        req.os_type = cpu_to_le16(1);
+        memset(async_events_bmap, 0, sizeof(async_events_bmap));
+        for (i = 0; i < ARRAY_SIZE(bnxt_async_events_arr); i++)
+                __set_bit(bnxt_async_events_arr[i], async_events_bmap);
+
+        for (i = 0; i < 8; i++)
+                req.async_event_fwd[i] |= cpu_to_le32(events[i]);
+
+        req.os_type = cpu_to_le16(FUNC_DRV_RGTR_REQ_OS_TYPE_LINUX);
         req.ver_maj = DRV_VER_MAJ;
         req.ver_min = DRV_VER_MIN;
         req.ver_upd = DRV_VER_UPD;
@@ -3391,11 +3431,11 @@ static int bnxt_hwrm_ring_alloc(struct bnxt *bp)
                 struct bnxt_cp_ring_info *cpr = &bnapi->cp_ring;
                 struct bnxt_ring_struct *ring = &cpr->cp_ring_struct;
 
+                cpr->cp_doorbell = bp->bar1 + i * 0x80;
                 rc = hwrm_ring_alloc_send_msg(bp, ring, HWRM_RING_ALLOC_CMPL, i,
                                               INVALID_STATS_CTX_ID);
                 if (rc)
                         goto err_out;
-                cpr->cp_doorbell = bp->bar1 + i * 0x80;
                 BNXT_CP_DB(cpr->cp_doorbell, cpr->cp_raw_cons);
                 bp->grp_info[i].cp_fw_ring_id = ring->fw_ring_id;
         }
@@ -3726,7 +3766,7 @@ int bnxt_hwrm_func_qcaps(struct bnxt *bp)
 
                 pf->fw_fid = le16_to_cpu(resp->fid);
                 pf->port_id = le16_to_cpu(resp->port_id);
-                memcpy(pf->mac_addr, resp->perm_mac_address, ETH_ALEN);
+                memcpy(pf->mac_addr, resp->mac_address, ETH_ALEN);
                 memcpy(bp->dev->dev_addr, pf->mac_addr, ETH_ALEN);
                 pf->max_rsscos_ctxs = le16_to_cpu(resp->max_rsscos_ctx);
                 pf->max_cp_rings = le16_to_cpu(resp->max_cmpl_rings);
@@ -3751,7 +3791,7 @@ int bnxt_hwrm_func_qcaps(struct bnxt *bp)
                 struct bnxt_vf_info *vf = &bp->vf;
 
                 vf->fw_fid = le16_to_cpu(resp->fid);
-                memcpy(vf->mac_addr, resp->perm_mac_address, ETH_ALEN);
+                memcpy(vf->mac_addr, resp->mac_address, ETH_ALEN);
                 if (is_valid_ether_addr(vf->mac_addr))
                         /* overwrite netdev dev_adr with admin VF MAC */
                         memcpy(bp->dev->dev_addr, vf->mac_addr, ETH_ALEN);
@@ -3830,6 +3870,7 @@ static int bnxt_hwrm_ver_get(struct bnxt *bp)
         struct hwrm_ver_get_input req = {0};
         struct hwrm_ver_get_output *resp = bp->hwrm_cmd_resp_addr;
 
+        bp->hwrm_max_req_len = HWRM_MAX_REQ_LEN;
         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_VER_GET, -1, -1);
         req.hwrm_intf_maj = HWRM_VERSION_MAJOR;
         req.hwrm_intf_min = HWRM_VERSION_MINOR;
@@ -3841,6 +3882,8 @@ static int bnxt_hwrm_ver_get(struct bnxt *bp)
 
         memcpy(&bp->ver_resp, resp, sizeof(struct hwrm_ver_get_output));
 
+        bp->hwrm_spec_code = resp->hwrm_intf_maj << 16 |
+                             resp->hwrm_intf_min << 8 | resp->hwrm_intf_upd;
         if (resp->hwrm_intf_maj < 1) {
                 netdev_warn(bp->dev, "HWRM interface %d.%d.%d is older than 1.0.0.\n",
                             resp->hwrm_intf_maj, resp->hwrm_intf_min,
@@ -3855,6 +3898,9 @@ static int bnxt_hwrm_ver_get(struct bnxt *bp)
         if (!bp->hwrm_cmd_timeout)
                 bp->hwrm_cmd_timeout = DFLT_HWRM_CMD_TIMEOUT;
 
+        if (resp->hwrm_intf_maj >= 1)
+                bp->hwrm_max_req_len = le16_to_cpu(resp->max_req_win_len);
+
 hwrm_ver_get_exit:
         mutex_unlock(&bp->hwrm_cmd_lock);
         return rc;
@@ -4482,12 +4528,49 @@ static void bnxt_report_link(struct bnxt *bp)
                 speed = bnxt_fw_to_ethtool_speed(bp->link_info.link_speed);
                 netdev_info(bp->dev, "NIC Link is Up, %d Mbps %s duplex, Flow control: %s\n",
                             speed, duplex, flow_ctrl);
+                if (bp->flags & BNXT_FLAG_EEE_CAP)
+                        netdev_info(bp->dev, "EEE is %s\n",
+                                    bp->eee.eee_active ? "active" :
+                                                         "not active");
         } else {
                 netif_carrier_off(bp->dev);
                 netdev_err(bp->dev, "NIC Link is Down\n");
         }
 }
 
+static int bnxt_hwrm_phy_qcaps(struct bnxt *bp)
+{
+        int rc = 0;
+        struct hwrm_port_phy_qcaps_input req = {0};
+        struct hwrm_port_phy_qcaps_output *resp = bp->hwrm_cmd_resp_addr;
+
+        if (bp->hwrm_spec_code < 0x10201)
+                return 0;
+
+        bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_PORT_PHY_QCAPS, -1, -1);
+
+        mutex_lock(&bp->hwrm_cmd_lock);
+        rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
+        if (rc)
+                goto hwrm_phy_qcaps_exit;
+
+        if (resp->eee_supported & PORT_PHY_QCAPS_RESP_EEE_SUPPORTED) {
+                struct ethtool_eee *eee = &bp->eee;
+                u16 fw_speeds = le16_to_cpu(resp->supported_speeds_eee_mode);
+
+                bp->flags |= BNXT_FLAG_EEE_CAP;
+                eee->supported = _bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
+                bp->lpi_tmr_lo = le32_to_cpu(resp->tx_lpi_timer_low) &
+                                 PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_LOW_MASK;
+                bp->lpi_tmr_hi = le32_to_cpu(resp->valid_tx_lpi_timer_high) &
+                                 PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_HIGH_MASK;
+        }
+
+hwrm_phy_qcaps_exit:
+        mutex_unlock(&bp->hwrm_cmd_lock);
+        return rc;
+}
+
 static int bnxt_update_link(struct bnxt *bp, bool chng_link_state)
 {
         int rc = 0;
@@ -4519,7 +4602,6 @@ static int bnxt_update_link(struct bnxt *bp, bool chng_link_state)
         else
                 link_info->link_speed = 0;
         link_info->force_link_speed = le16_to_cpu(resp->force_link_speed);
-        link_info->auto_link_speed = le16_to_cpu(resp->auto_link_speed);
         link_info->support_speeds = le16_to_cpu(resp->support_speeds);
         link_info->auto_link_speeds = le16_to_cpu(resp->auto_link_speed_mask);
         link_info->lp_auto_link_speeds =
@@ -4529,9 +4611,45 @@ static int bnxt_update_link(struct bnxt *bp, bool chng_link_state)
         link_info->phy_ver[1] = resp->phy_min;
         link_info->phy_ver[2] = resp->phy_bld;
         link_info->media_type = resp->media_type;
-        link_info->transceiver = resp->transceiver_type;
-        link_info->phy_addr = resp->phy_addr;
+        link_info->transceiver = resp->xcvr_pkg_type;
+        link_info->phy_addr = resp->eee_config_phy_addr &
+                              PORT_PHY_QCFG_RESP_PHY_ADDR_MASK;
+
+        if (bp->flags & BNXT_FLAG_EEE_CAP) {
+                struct ethtool_eee *eee = &bp->eee;
+                u16 fw_speeds;
+
+                eee->eee_active = 0;
+                if (resp->eee_config_phy_addr &
+                    PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_ACTIVE) {
+                        eee->eee_active = 1;
+                        fw_speeds = le16_to_cpu(
+                                resp->link_partner_adv_eee_link_speed_mask);
+                        eee->lp_advertised =
+                                _bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
+                }
+
+                /* Pull initial EEE config */
+                if (!chng_link_state) {
+                        if (resp->eee_config_phy_addr &
+                            PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_ENABLED)
+                                eee->eee_enabled = 1;
+
+                        fw_speeds = le16_to_cpu(resp->adv_eee_link_speed_mask);
+                        eee->advertised =
+                                _bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
+
+                        if (resp->eee_config_phy_addr &
+                            PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_TX_LPI) {
+                                __le32 tmr;
 
+                                eee->tx_lpi_enabled = 1;
+                                tmr = resp->xcvr_identifier_type_tx_lpi_timer;
+                                eee->tx_lpi_timer = le32_to_cpu(tmr) &
+                                        PORT_PHY_QCFG_RESP_TX_LPI_TIMER_MASK;
+                        }
+                }
+        }
         /* TODO: need to add more logic to report VF link */
         if (chng_link_state) {
                 if (link_info->phy_link_status == BNXT_LINK_LINK)
@@ -4552,10 +4670,13 @@ static void
 bnxt_hwrm_set_pause_common(struct bnxt *bp, struct hwrm_port_phy_cfg_input *req)
 {
         if (bp->link_info.autoneg & BNXT_AUTONEG_FLOW_CTRL) {
+                if (bp->hwrm_spec_code >= 0x10201)
+                        req->auto_pause =
+                                PORT_PHY_CFG_REQ_AUTO_PAUSE_AUTONEG_PAUSE;
                 if (bp->link_info.req_flow_ctrl & BNXT_LINK_PAUSE_RX)
                         req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_RX;
                 if (bp->link_info.req_flow_ctrl & BNXT_LINK_PAUSE_TX)
-                        req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_RX;
+                        req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_TX;
                 req->enables |=
                         cpu_to_le32(PORT_PHY_CFG_REQ_ENABLES_AUTO_PAUSE);
         } else {
@@ -4565,6 +4686,11 @@ bnxt_hwrm_set_pause_common(struct bnxt *bp, struct hwrm_port_phy_cfg_input *req)
                         req->force_pause |= PORT_PHY_CFG_REQ_FORCE_PAUSE_TX;
                 req->enables |=
                         cpu_to_le32(PORT_PHY_CFG_REQ_ENABLES_FORCE_PAUSE);
+                if (bp->hwrm_spec_code >= 0x10201) {
+                        req->auto_pause = req->force_pause;
+                        req->enables |= cpu_to_le32(
+                                PORT_PHY_CFG_REQ_ENABLES_AUTO_PAUSE);
+                }
         }
 }
 
@@ -4577,7 +4703,7 @@ static void bnxt_hwrm_set_link_common(struct bnxt *bp,
 
         if (autoneg & BNXT_AUTONEG_SPEED) {
                 req->auto_mode |=
-                        PORT_PHY_CFG_REQ_AUTO_MODE_MASK;
+                        PORT_PHY_CFG_REQ_AUTO_MODE_SPEED_MASK;
 
                 req->enables |= cpu_to_le32(
                         PORT_PHY_CFG_REQ_ENABLES_AUTO_LINK_SPEED_MASK);
@@ -4591,9 +4717,6 @@ static void bnxt_hwrm_set_link_common(struct bnxt *bp,
                 req->flags |= cpu_to_le32(PORT_PHY_CFG_REQ_FLAGS_FORCE);
         }
 
-        /* currently don't support half duplex */
-        req->auto_duplex = PORT_PHY_CFG_REQ_AUTO_DUPLEX_FULL;
-        req->enables |= cpu_to_le32(PORT_PHY_CFG_REQ_ENABLES_AUTO_DUPLEX);
         /* tell chimp that the setting takes effect immediately */
         req->flags |= cpu_to_le32(PORT_PHY_CFG_REQ_FLAGS_RESET_PHY);
 }
@@ -4628,7 +4751,30 @@ int bnxt_hwrm_set_pause(struct bnxt *bp)
         return rc;
 }
 
-int bnxt_hwrm_set_link_setting(struct bnxt *bp, bool set_pause)
+static void bnxt_hwrm_set_eee(struct bnxt *bp,
+                              struct hwrm_port_phy_cfg_input *req)
+{
+        struct ethtool_eee *eee = &bp->eee;
+
+        if (eee->eee_enabled) {
+                u16 eee_speeds;
+                u32 flags = PORT_PHY_CFG_REQ_FLAGS_EEE_ENABLE;
+
+                if (eee->tx_lpi_enabled)
+                        flags |= PORT_PHY_CFG_REQ_FLAGS_EEE_TX_LPI_ENABLE;
+                else
+                        flags |= PORT_PHY_CFG_REQ_FLAGS_EEE_TX_LPI_DISABLE;
+
+                req->flags |= cpu_to_le32(flags);
+                eee_speeds = bnxt_get_fw_auto_link_speeds(eee->advertised);
+                req->eee_link_speed_mask = cpu_to_le16(eee_speeds);
+                req->tx_lpi_timer = cpu_to_le32(eee->tx_lpi_timer);
+        } else {
+                req->flags |= cpu_to_le32(PORT_PHY_CFG_REQ_FLAGS_EEE_DISABLE);
+        }
+}
+
+int bnxt_hwrm_set_link_setting(struct bnxt *bp, bool set_pause, bool set_eee)
 {
         struct hwrm_port_phy_cfg_input req = {0};
 
@@ -4637,14 +4783,42 @@ int bnxt_hwrm_set_link_setting(struct bnxt *bp, bool set_pause)
                 bnxt_hwrm_set_pause_common(bp, &req);
 
         bnxt_hwrm_set_link_common(bp, &req);
+
+        if (set_eee)
+                bnxt_hwrm_set_eee(bp, &req);
         return hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
 }
 
+static bool bnxt_eee_config_ok(struct bnxt *bp)
+{
+        struct ethtool_eee *eee = &bp->eee;
+        struct bnxt_link_info *link_info = &bp->link_info;
+
+        if (!(bp->flags & BNXT_FLAG_EEE_CAP))
+                return true;
+
+        if (eee->eee_enabled) {
+                u32 advertising =
+                        _bnxt_fw_to_ethtool_adv_spds(link_info->advertising, 0);
+
+                if (!(link_info->autoneg & BNXT_AUTONEG_SPEED)) {
+                        eee->eee_enabled = 0;
+                        return false;
+                }
+                if (eee->advertised & ~advertising) {
+                        eee->advertised = advertising & eee->supported;
+                        return false;
+                }
+        }
+        return true;
+}
+
 static int bnxt_update_phy_setting(struct bnxt *bp)
 {
         int rc;
         bool update_link = false;
         bool update_pause = false;
+        bool update_eee = false;
         struct bnxt_link_info *link_info = &bp->link_info;
 
         rc = bnxt_update_link(bp, true);
@@ -4654,7 +4828,8 @@ static int bnxt_update_phy_setting(struct bnxt *bp)
                 return rc;
         }
         if ((link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL) &&
-            link_info->auto_pause_setting != link_info->req_flow_ctrl)
+            (link_info->auto_pause_setting & BNXT_LINK_PAUSE_BOTH) !=
+            link_info->req_flow_ctrl)
                 update_pause = true;
         if (!(link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL) &&
             link_info->force_pause_setting != link_info->req_flow_ctrl)
@@ -4673,8 +4848,11 @@ static int bnxt_update_phy_setting(struct bnxt *bp)
                         update_link = true;
         }
 
+        if (!bnxt_eee_config_ok(bp))
+                update_eee = true;
+
         if (update_link)
-                rc = bnxt_hwrm_set_link_setting(bp, update_pause);
+                rc = bnxt_hwrm_set_link_setting(bp, update_pause, update_eee);
         else if (update_pause)
                 rc = bnxt_hwrm_set_pause(bp);
         if (rc) {
@@ -5299,6 +5477,28 @@ bnxt_restart_timer:
         mod_timer(&bp->timer, jiffies + bp->current_interval);
 }
 
+static void bnxt_port_module_event(struct bnxt *bp)
+{
+        struct bnxt_link_info *link_info = &bp->link_info;
+        struct hwrm_port_phy_qcfg_output *resp = &link_info->phy_qcfg_resp;
+
+        if (bnxt_update_link(bp, true))
+                return;
+
+        if (link_info->last_port_module_event != 0) {
+                netdev_warn(bp->dev, "Unqualified SFP+ module detected on port %d\n",
+                            bp->pf.port_id);
+                if (bp->hwrm_spec_code >= 0x10201) {
+                        netdev_warn(bp->dev, "Module part number %s\n",
+                                    resp->phy_vendor_partnumber);
+                }
+        }
+        if (link_info->last_port_module_event == 1)
+                netdev_warn(bp->dev, "TX is disabled\n");
+        if (link_info->last_port_module_event == 3)
+                netdev_warn(bp->dev, "Shutdown SFP+ module\n");
+}
+
 static void bnxt_cfg_ntp_filters(struct bnxt *);
 
 static void bnxt_sp_task(struct work_struct *work)
@@ -5346,6 +5546,9 @@ static void bnxt_sp_task(struct work_struct *work)
                 rtnl_unlock();
         }
 
+        if (test_and_clear_bit(BNXT_HWRM_PORT_MODULE_SP_EVENT, &bp->sp_event))
+                bnxt_port_module_event(bp);
+
         if (test_and_clear_bit(BNXT_PERIODIC_STATS_SP_EVENT, &bp->sp_event))
                 bnxt_hwrm_port_qstats(bp);
 
@@ -5814,6 +6017,13 @@ static int bnxt_probe_phy(struct bnxt *bp)
         int rc = 0;
         struct bnxt_link_info *link_info = &bp->link_info;
 
+        rc = bnxt_hwrm_phy_qcaps(bp);
+        if (rc) {
+                netdev_err(bp->dev, "Probe phy can't get phy capabilities (rc: %x)\n",
+                           rc);
+                return rc;
+        }
+
         rc = bnxt_update_link(bp, false);
         if (rc) {
                 netdev_err(bp->dev, "Probe phy can't update link (rc: %x)\n",
@@ -5823,15 +6033,24 @@ static int bnxt_probe_phy(struct bnxt *bp)
 
         /*initialize the ethool setting copy with NVM settings */
         if (BNXT_AUTO_MODE(link_info->auto_mode)) {
-                link_info->autoneg = BNXT_AUTONEG_SPEED |
-                                     BNXT_AUTONEG_FLOW_CTRL;
+                link_info->autoneg = BNXT_AUTONEG_SPEED;
+                if (bp->hwrm_spec_code >= 0x10201) {
+                        if (link_info->auto_pause_setting &
+                            PORT_PHY_CFG_REQ_AUTO_PAUSE_AUTONEG_PAUSE)
+                                link_info->autoneg |= BNXT_AUTONEG_FLOW_CTRL;
+                } else {
+                        link_info->autoneg |= BNXT_AUTONEG_FLOW_CTRL;
+                }
                 link_info->advertising = link_info->auto_link_speeds;
-                link_info->req_flow_ctrl = link_info->auto_pause_setting;
         } else {
                 link_info->req_link_speed = link_info->force_link_speed;
                 link_info->req_duplex = link_info->duplex_setting;
-                link_info->req_flow_ctrl = link_info->force_pause_setting;
         }
+        if (link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL)
+                link_info->req_flow_ctrl =
+                        link_info->auto_pause_setting & BNXT_LINK_PAUSE_BOTH;
+        else
+                link_info->req_flow_ctrl = link_info->force_pause_setting;
         return rc;
 }
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
index ec04c47172b7..cc8e38a9f684 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -11,7 +11,7 @@
 #define BNXT_H
 
 #define DRV_MODULE_NAME         "bnxt_en"
-#define DRV_MODULE_VERSION      "1.0.0"
+#define DRV_MODULE_VERSION      "1.2.0"
 
 #define DRV_VER_MAJ     1
 #define DRV_VER_MIN     0
@@ -477,6 +477,7 @@ struct rx_tpa_end_cmp_ext {
 #define RING_CMP(idx)           ((idx) & bp->cp_ring_mask)
 #define NEXT_CMP(idx)           RING_CMP(ADV_RAW_CMP(idx, 1))
 
+#define BNXT_HWRM_MAX_REQ_LEN           (bp->hwrm_max_req_len)
 #define DFLT_HWRM_CMD_TIMEOUT           500
 #define HWRM_CMD_TIMEOUT                (bp->hwrm_cmd_timeout)
 #define HWRM_RESET_TIMEOUT              ((HWRM_CMD_TIMEOUT) * 4)
@@ -787,7 +788,7 @@ struct bnxt_link_info {
 #define BNXT_LINK_AUTO_ALLSPDS  PORT_PHY_QCFG_RESP_AUTO_MODE_ALL_SPEEDS
 #define BNXT_LINK_AUTO_ONESPD   PORT_PHY_QCFG_RESP_AUTO_MODE_ONE_SPEED
 #define BNXT_LINK_AUTO_ONEORBELOW PORT_PHY_QCFG_RESP_AUTO_MODE_ONE_OR_BELOW
-#define BNXT_LINK_AUTO_MSK      PORT_PHY_QCFG_RESP_AUTO_MODE_MASK
+#define BNXT_LINK_AUTO_MSK      PORT_PHY_QCFG_RESP_AUTO_MODE_SPEED_MASK
 #define PHY_VER_LEN             3
         u8                      phy_ver[PHY_VER_LEN];
         u16                     link_speed;
@@ -812,7 +813,6 @@ struct bnxt_link_info {
 #define BNXT_LINK_SPEED_MSK_40GB PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_40GB
 #define BNXT_LINK_SPEED_MSK_50GB PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_50GB
         u16                     lp_auto_link_speeds;
-        u16                     auto_link_speed;
         u16                     force_link_speed;
         u32                     preemphasis;
 
@@ -825,6 +825,8 @@ struct bnxt_link_info {
         u16                     req_link_speed;
         u32                     advertising;
         bool                    force_link_chng;
+
+        u8                      last_port_module_event;
         /* a copy of phy_qcfg output used to report link
          * info to VF
          */
@@ -874,6 +876,7 @@ struct bnxt {
         #define BNXT_FLAG_RFS           0x100
         #define BNXT_FLAG_SHARED_RINGS  0x200
         #define BNXT_FLAG_PORT_STATS    0x400
+        #define BNXT_FLAG_EEE_CAP       0x1000
 
         #define BNXT_FLAG_ALL_CONFIG_FEATS (BNXT_FLAG_TPA |             \
                                             BNXT_FLAG_RFS |             \
@@ -939,6 +942,7 @@ struct bnxt {
 
         u32                     msg_enable;
 
+        u32                     hwrm_spec_code;
         u16                     hwrm_cmd_seq;
         u32                     hwrm_intr_seq_id;
         void                    *hwrm_cmd_resp_addr;
@@ -953,6 +957,7 @@ struct bnxt {
         dma_addr_t              hw_tx_port_stats_map;
         int                     hw_port_stats_size;
 
+        u16                     hwrm_max_req_len;
         int                     hwrm_cmd_timeout;
         struct mutex            hwrm_cmd_lock;  /* serialize hwrm messages */
         struct hwrm_ver_get_output      ver_resp;
@@ -989,6 +994,7 @@ struct bnxt {
 #define BNXT_RST_RING_SP_EVENT          7
 #define BNXT_HWRM_PF_UNLOAD_SP_EVENT    8
 #define BNXT_PERIODIC_STATS_SP_EVENT    9
+#define BNXT_HWRM_PORT_MODULE_SP_EVENT  10
 
         struct bnxt_pf_info     pf;
 #ifdef CONFIG_BNXT_SRIOV
@@ -1009,6 +1015,9 @@ struct bnxt {
         int                     ntp_fltr_count;
 
         struct bnxt_link_info   link_info;
+        struct ethtool_eee      eee;
+        u32                     lpi_tmr_lo;
+        u32                     lpi_tmr_hi;
 };
 
 #ifdef CONFIG_NET_RX_BUSY_POLL
@@ -1106,7 +1115,7 @@ int hwrm_send_message_silent(struct bnxt *, void *, u32, int);
 int bnxt_hwrm_set_coal(struct bnxt *);
 int bnxt_hwrm_func_qcaps(struct bnxt *);
 int bnxt_hwrm_set_pause(struct bnxt *);
-int bnxt_hwrm_set_link_setting(struct bnxt *, bool);
+int bnxt_hwrm_set_link_setting(struct bnxt *, bool, bool);
 int bnxt_open_nic(struct bnxt *, bool, bool);
 int bnxt_close_nic(struct bnxt *, bool, bool);
 int bnxt_get_max_rings(struct bnxt *, int *, int *, bool);
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
index 9ada1662b651..a2e93241b06b 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -597,7 +597,7 @@ static void bnxt_get_drvinfo(struct net_device *dev,
         kfree(pkglog);
 }
 
-static u32 _bnxt_fw_to_ethtool_adv_spds(u16 fw_speeds, u8 fw_pause)
+u32 _bnxt_fw_to_ethtool_adv_spds(u16 fw_speeds, u8 fw_pause)
 {
         u32 speed_mask = 0;
 
@@ -698,10 +698,23 @@ static int bnxt_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 if (link_info->phy_link_status == BNXT_LINK_LINK)
                         cmd->lp_advertising =
                                 bnxt_fw_to_ethtool_lp_adv(link_info);
+                ethtool_speed = bnxt_fw_to_ethtool_speed(link_info->link_speed);
+                if (!netif_carrier_ok(dev))
+                        cmd->duplex = DUPLEX_UNKNOWN;
+                else if (link_info->duplex & BNXT_LINK_DUPLEX_FULL)
+                        cmd->duplex = DUPLEX_FULL;
+                else
+                        cmd->duplex = DUPLEX_HALF;
         } else {
                 cmd->autoneg = AUTONEG_DISABLE;
                 cmd->advertising = 0;
+                ethtool_speed =
+                        bnxt_fw_to_ethtool_speed(link_info->req_link_speed);
+                cmd->duplex = DUPLEX_HALF;
+                if (link_info->req_duplex == BNXT_LINK_DUPLEX_FULL)
+                        cmd->duplex = DUPLEX_FULL;
         }
+        ethtool_cmd_speed_set(cmd, ethtool_speed);
 
         cmd->port = PORT_NONE;
         if (link_info->media_type == PORT_PHY_QCFG_RESP_MEDIA_TYPE_TP) {
@@ -719,16 +732,8 @@ static int bnxt_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                         cmd->port = PORT_FIBRE;
         }
 
-        if (link_info->phy_link_status == BNXT_LINK_LINK) {
-                if (link_info->duplex & BNXT_LINK_DUPLEX_FULL)
-                        cmd->duplex = DUPLEX_FULL;
-        } else {
-                cmd->duplex = DUPLEX_UNKNOWN;
-        }
-        ethtool_speed = bnxt_fw_to_ethtool_speed(link_info->link_speed);
-        ethtool_cmd_speed_set(cmd, ethtool_speed);
         if (link_info->transceiver ==
-                PORT_PHY_QCFG_RESP_TRANSCEIVER_TYPE_XCVR_INTERNAL)
+            PORT_PHY_QCFG_RESP_XCVR_PKG_TYPE_XCVR_INTERNAL)
                 cmd->transceiver = XCVR_INTERNAL;
         else
                 cmd->transceiver = XCVR_EXTERNAL;
@@ -739,31 +744,52 @@ static int bnxt_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
 static u32 bnxt_get_fw_speed(struct net_device *dev, u16 ethtool_speed)
 {
+        struct bnxt *bp = netdev_priv(dev);
+        struct bnxt_link_info *link_info = &bp->link_info;
+        u16 support_spds = link_info->support_speeds;
+        u32 fw_speed = 0;
+
         switch (ethtool_speed) {
         case SPEED_100:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_100MB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_100MB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_100MB;
+                break;
         case SPEED_1000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_1GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_1GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_1GB;
+                break;
         case SPEED_2500:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_2_5GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_2_5GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_2_5GB;
+                break;
         case SPEED_10000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_10GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_10GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_10GB;
+                break;
         case SPEED_20000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_20GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_20GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_20GB;
+                break;
         case SPEED_25000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_25GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_25GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_25GB;
+                break;
         case SPEED_40000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_40GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_40GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_40GB;
+                break;
         case SPEED_50000:
-                return PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_50GB;
+                if (support_spds & BNXT_LINK_SPEED_MSK_50GB)
+                        fw_speed = PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_50GB;
+                break;
         default:
                 netdev_err(dev, "unsupported speed!\n");
                 break;
         }
-        return 0;
+        return fw_speed;
 }
 
-static u16 bnxt_get_fw_auto_link_speeds(u32 advertising)
+u16 bnxt_get_fw_auto_link_speeds(u32 advertising)
 {
         u16 fw_speed_mask = 0;
 
@@ -823,6 +849,8 @@ static int bnxt_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                  */
                 set_pause = true;
         } else {
+                u16 fw_speed;
+
                 /* TODO: currently don't support half duplex */
                 if (cmd->duplex == DUPLEX_HALF) {
                         netdev_err(dev, "HALF DUPLEX is not supported!\n");
@@ -833,14 +861,19 @@ static int bnxt_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                 if (cmd->duplex == DUPLEX_UNKNOWN)
                         cmd->duplex = DUPLEX_FULL;
                 speed = ethtool_cmd_speed(cmd);
-                link_info->req_link_speed = bnxt_get_fw_speed(dev, speed);
+                fw_speed = bnxt_get_fw_speed(dev, speed);
+                if (!fw_speed) {
+                        rc = -EINVAL;
+                        goto set_setting_exit;
+                }
+                link_info->req_link_speed = fw_speed;
                 link_info->req_duplex = BNXT_LINK_DUPLEX_FULL;
                 link_info->autoneg = 0;
                 link_info->advertising = 0;
         }
 
         if (netif_running(dev))
-                rc = bnxt_hwrm_set_link_setting(bp, set_pause);
+                rc = bnxt_hwrm_set_link_setting(bp, set_pause, false);
 
 set_setting_exit:
         return rc;
@@ -855,10 +888,8 @@ static void bnxt_get_pauseparam(struct net_device *dev,
         if (BNXT_VF(bp))
                 return;
         epause->autoneg = !!(link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL);
-        epause->rx_pause =
-                ((link_info->auto_pause_setting & BNXT_LINK_PAUSE_RX) != 0);
-        epause->tx_pause =
-                ((link_info->auto_pause_setting & BNXT_LINK_PAUSE_TX) != 0);
+        epause->rx_pause = !!(link_info->req_flow_ctrl & BNXT_LINK_PAUSE_RX);
+        epause->tx_pause = !!(link_info->req_flow_ctrl & BNXT_LINK_PAUSE_TX);
 }
 
 static int bnxt_set_pauseparam(struct net_device *dev,
@@ -876,7 +907,9 @@ static int bnxt_set_pauseparam(struct net_device *dev,
                         return -EINVAL;
 
                 link_info->autoneg |= BNXT_AUTONEG_FLOW_CTRL;
-                link_info->req_flow_ctrl |= BNXT_LINK_PAUSE_BOTH;
+                if (bp->hwrm_spec_code >= 0x10201)
+                        link_info->req_flow_ctrl =
+                                PORT_PHY_CFG_REQ_AUTO_PAUSE_AUTONEG_PAUSE;
         } else {
                 /* when transition from auto pause to force pause,
                  * force a link change
@@ -884,17 +917,13 @@ static int bnxt_set_pauseparam(struct net_device *dev,
                 if (link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL)
                         link_info->force_link_chng = true;
                 link_info->autoneg &= ~BNXT_AUTONEG_FLOW_CTRL;
-                link_info->req_flow_ctrl &= ~BNXT_LINK_PAUSE_BOTH;
+                link_info->req_flow_ctrl = 0;
         }
         if (epause->rx_pause)
                 link_info->req_flow_ctrl |= BNXT_LINK_PAUSE_RX;
-        else
-                link_info->req_flow_ctrl &= ~BNXT_LINK_PAUSE_RX;
 
         if (epause->tx_pause)
                 link_info->req_flow_ctrl |= BNXT_LINK_PAUSE_TX;
-        else
-                link_info->req_flow_ctrl &= ~BNXT_LINK_PAUSE_TX;
 
         if (netif_running(dev))
                 rc = bnxt_hwrm_set_pause(bp);
@@ -1383,6 +1412,80 @@ static int bnxt_set_eeprom(struct net_device *dev,
                                 eeprom->len);
 }
 
+static int bnxt_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+{
+        struct bnxt *bp = netdev_priv(dev);
+        struct ethtool_eee *eee = &bp->eee;
+        struct bnxt_link_info *link_info = &bp->link_info;
+        u32 advertising =
+                 _bnxt_fw_to_ethtool_adv_spds(link_info->advertising, 0);
+        int rc = 0;
+
+        if (BNXT_VF(bp))
+                return 0;
+
+        if (!(bp->flags & BNXT_FLAG_EEE_CAP))
+                return -EOPNOTSUPP;
+
+        if (!edata->eee_enabled)
+                goto eee_ok;
+
+        if (!(link_info->autoneg & BNXT_AUTONEG_SPEED)) {
+                netdev_warn(dev, "EEE requires autoneg\n");
+                return -EINVAL;
+        }
+        if (edata->tx_lpi_enabled) {
+                if (bp->lpi_tmr_hi && (edata->tx_lpi_timer > bp->lpi_tmr_hi ||
+                                       edata->tx_lpi_timer < bp->lpi_tmr_lo)) {
+                        netdev_warn(dev, "Valid LPI timer range is %d and %d microsecs\n",
+                                    bp->lpi_tmr_lo, bp->lpi_tmr_hi);
+                        return -EINVAL;
+                } else if (!bp->lpi_tmr_hi) {
+                        edata->tx_lpi_timer = eee->tx_lpi_timer;
+                }
+        }
+        if (!edata->advertised) {
+                edata->advertised = advertising & eee->supported;
+        } else if (edata->advertised & ~advertising) {
+                netdev_warn(dev, "EEE advertised %x must be a subset of autoneg advertised speeds %x\n",
+                            edata->advertised, advertising);
+                return -EINVAL;
+        }
+
+        eee->advertised = edata->advertised;
+        eee->tx_lpi_enabled = edata->tx_lpi_enabled;
+        eee->tx_lpi_timer = edata->tx_lpi_timer;
+eee_ok:
+        eee->eee_enabled = edata->eee_enabled;
+
+        if (netif_running(dev))
+                rc = bnxt_hwrm_set_link_setting(bp, false, true);
+
+        return rc;
+}
+
+static int bnxt_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+{
+        struct bnxt *bp = netdev_priv(dev);
+
+        if (!(bp->flags & BNXT_FLAG_EEE_CAP))
+                return -EOPNOTSUPP;
+
+        *edata = bp->eee;
+        if (!bp->eee.eee_enabled) {
+                /* Preserve tx_lpi_timer so that the last value will be used
+                 * by default when it is re-enabled.
+                 */
+                edata->advertised = 0;
+                edata->tx_lpi_enabled = 0;
+        }
+
+        if (!bp->eee.eee_active)
+                edata->lp_advertised = 0;
+
+        return 0;
+}
+
 const struct ethtool_ops bnxt_ethtool_ops = {
         .get_settings           = bnxt_get_settings,
         .set_settings           = bnxt_set_settings,
@@ -1411,4 +1514,6 @@ const struct ethtool_ops bnxt_ethtool_ops = {
         .get_eeprom             = bnxt_get_eeprom,
         .set_eeprom             = bnxt_set_eeprom,
         .get_link               = bnxt_get_link,
+        .get_eee                = bnxt_get_eee,
+        .set_eee                = bnxt_set_eee,
 };
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.h
index 98fa81e08b58..3abc03b60dbc 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -12,6 +12,8 @@
 
 extern const struct ethtool_ops bnxt_ethtool_ops;
 
+u32 _bnxt_fw_to_ethtool_adv_spds(u16, u8);
 u32 bnxt_fw_to_ethtool_speed(u16);
+u16 bnxt_get_fw_auto_link_speeds(u32);
 
 #endif
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_fw_hdr.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_fw_hdr.h
index e0aac65c6d82..461675caaacd 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_fw_hdr.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_fw_hdr.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
index 4badbedcb421..80f95560086d 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -104,6 +104,7 @@ struct hwrm_async_event_cmpl {
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_DCB_CONFIG_CHANGE  (0x3UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED (0x4UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_NOT_ALLOWED (0x5UL << 0)
+        #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE (0x6UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_FUNC_DRVR_UNLOAD   (0x10UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_FUNC_DRVR_LOAD     (0x11UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD     (0x20UL << 0)
@@ -111,6 +112,7 @@ struct hwrm_async_event_cmpl {
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_FLR              (0x30UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_MAC_ADDR_CHANGE (0x31UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_VF_COMM_STATUS_CHANGE (0x32UL << 0)
+        #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_CFG_CHANGE      (0x33UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_EVENT_ID_HWRM_ERROR          (0xffUL << 0)
         __le32 event_data2;
         u8 opaque_v;
@@ -141,6 +143,7 @@ struct hwrm_async_event_cmpl_link_status_change {
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_LINK_CHANGE 0x1UL
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_LINK_CHANGE_DOWN (0x0UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_LINK_CHANGE_UP (0x1UL << 0)
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_LINK_CHANGE_LAST    HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_LINK_CHANGE_UP
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_PORT_MASK 0xeUL
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_PORT_SFT 1
         #define HWRM_ASYNC_EVENT_CMPL_LINK_STATUS_CHANGE_EVENT_DATA1_PORT_ID_MASK 0xffff0UL
@@ -195,6 +198,9 @@ struct hwrm_async_event_cmpl_link_speed_change {
         #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_25GB (0xfaUL << 1)
         #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_40GB (0x190UL << 1)
         #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_50GB (0x1f4UL << 1)
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_100GB (0x3e8UL << 1)
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_10MB (0xffffUL << 1)
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_LAST    HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_NEW_LINK_SPEED_100MBPS_10MB
         #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_PORT_ID_MASK 0xffff0000UL
         #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CHANGE_EVENT_DATA1_PORT_ID_SFT 16
 };
@@ -237,6 +243,55 @@ struct hwrm_async_event_cmpl_port_conn_not_allowed {
         __le32 event_data1;
         #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_PORT_ID_MASK 0xffffUL
         #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_PORT_ID_SFT 0
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_MASK 0xff0000UL
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_SFT 16
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_NONE (0x0UL << 16)
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_DISABLETX (0x1UL << 16)
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_WARNINGMSG (0x2UL << 16)
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_PWRDOWN (0x3UL << 16)
+        #define HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_LAST    HWRM_ASYNC_EVENT_CMPL_PORT_CONN_NOT_ALLOWED_EVENT_DATA1_ENFORCEMENT_POLICY_PWRDOWN
+};
+
+/* HWRM Asynchronous Event Completion Record for link speed config not allowed (16 bytes) */
+struct hwrm_async_event_cmpl_link_speed_cfg_not_allowed {
+        __le16 type;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_TYPE_MASK 0x3fUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_TYPE_SFT 0
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_TYPE_HWRM_ASYNC_EVENT (0x2eUL << 0)
+        __le16 event_id;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_EVENT_ID_LINK_SPEED_CFG_NOT_ALLOWED (0x5UL << 0)
+        __le32 event_data2;
+        u8 opaque_v;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_V 0x1UL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_OPAQUE_MASK 0xfeUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_OPAQUE_SFT 1
+        u8 timestamp_lo;
+        __le16 timestamp_hi;
+        __le32 event_data1;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_EVENT_DATA1_PORT_ID_MASK 0xffffUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_NOT_ALLOWED_EVENT_DATA1_PORT_ID_SFT 0
+};
+
+/* HWRM Asynchronous Event Completion Record for link speed configuration change (16 bytes) */
+struct hwrm_async_event_cmpl_link_speed_cfg_change {
+        __le16 type;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_TYPE_MASK 0x3fUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_TYPE_SFT 0
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_TYPE_HWRM_ASYNC_EVENT (0x2eUL << 0)
+        __le16 event_id;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_EVENT_ID_LINK_SPEED_CFG_CHANGE (0x6UL << 0)
+        __le32 event_data2;
+        u8 opaque_v;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_V      0x1UL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_OPAQUE_MASK 0xfeUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_OPAQUE_SFT 1
+        u8 timestamp_lo;
+        __le16 timestamp_hi;
+        __le32 event_data1;
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_EVENT_DATA1_PORT_ID_MASK 0xffffUL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_EVENT_DATA1_PORT_ID_SFT 0
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_EVENT_DATA1_SUPPORTED_LINK_SPEEDS_CHANGE 0x10000UL
+        #define HWRM_ASYNC_EVENT_CMPL_LINK_SPEED_CFG_CHANGE_EVENT_DATA1_ILLEGAL_LINK_SPEED_CFG 0x20000UL
 };
 
 /* HWRM Asynchronous Event Completion Record for Function Driver Unload (16 bytes) */
@@ -363,6 +418,47 @@ struct hwrm_async_event_cmpl_vf_mac_addr_change {
         #define HWRM_ASYNC_EVENT_CMPL_VF_MAC_ADDR_CHANGE_EVENT_DATA1_VF_ID_SFT 0
 };
 
+/* HWRM Asynchronous Event Completion Record for PF-VF communication status change (16 bytes) */
+struct hwrm_async_event_cmpl_pf_vf_comm_status_change {
+        __le16 type;
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_TYPE_MASK 0x3fUL
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_TYPE_SFT 0
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_TYPE_HWRM_ASYNC_EVENT (0x2eUL << 0)
+        __le16 event_id;
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_EVENT_ID_PF_VF_COMM_STATUS_CHANGE (0x32UL << 0)
+        __le32 event_data2;
+        u8 opaque_v;
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_V   0x1UL
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_OPAQUE_MASK 0xfeUL
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_OPAQUE_SFT 1
+        u8 timestamp_lo;
+        __le16 timestamp_hi;
+        __le32 event_data1;
+        #define HWRM_ASYNC_EVENT_CMPL_PF_VF_COMM_STATUS_CHANGE_EVENT_DATA1_COMM_ESTABLISHED 0x1UL
+};
+
+/* HWRM Asynchronous Event Completion Record for VF configuration change (16 bytes) */
+struct hwrm_async_event_cmpl_vf_cfg_change {
+        __le16 type;
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_TYPE_MASK      0x3fUL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_TYPE_SFT       0
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_TYPE_HWRM_ASYNC_EVENT (0x2eUL << 0)
+        __le16 event_id;
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_EVENT_ID_VF_CFG_CHANGE (0x33UL << 0)
+        __le32 event_data2;
+        u8 opaque_v;
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_V               0x1UL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_OPAQUE_MASK    0xfeUL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_OPAQUE_SFT     1
+        u8 timestamp_lo;
+        __le16 timestamp_hi;
+        __le32 event_data1;
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_EVENT_DATA1_MTU_CHANGE 0x1UL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_EVENT_DATA1_MRU_CHANGE 0x2UL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_EVENT_DATA1_DFLT_MAC_ADDR_CHANGE 0x4UL
+        #define HWRM_ASYNC_EVENT_CMPL_VF_CFG_CHANGE_EVENT_DATA1_DFLT_VLAN_CHANGE 0x8UL
+};
+
 /* HWRM Asynchronous Event Completion Record for HWRM Error (16 bytes) */
 struct hwrm_async_event_cmpl_hwrm_error {
         __le16 type;
@@ -377,6 +473,7 @@ struct hwrm_async_event_cmpl_hwrm_error {
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA2_SEVERITY_WARNING (0x0UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA2_SEVERITY_NONFATAL (0x1UL << 0)
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA2_SEVERITY_FATAL (0x2UL << 0)
+        #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA2_SEVERITY_LAST    HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA2_SEVERITY_FATAL
         u8 opaque_v;
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_V                  0x1UL
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_OPAQUE_MASK       0xfeUL
@@ -387,12 +484,12 @@ struct hwrm_async_event_cmpl_hwrm_error {
         #define HWRM_ASYNC_EVENT_CMPL_HWRM_ERROR_EVENT_DATA1_TIMESTAMP 0x1UL
 };
 
-/* HW Resource Manager Specification 1.0.0 */
+/* HW Resource Manager Specification 1.2.2 */
 #define HWRM_VERSION_MAJOR      1
-#define HWRM_VERSION_MINOR      0
-#define HWRM_VERSION_UPDATE     0
+#define HWRM_VERSION_MINOR      2
+#define HWRM_VERSION_UPDATE     2
 
-#define HWRM_VERSION_STR        "1.0.0"
+#define HWRM_VERSION_STR        "1.2.2"
 /*
  * Following is the signature for HWRM message field that indicates not
  * applicable (All F's). Need to cast it the size of the field if needed.
@@ -444,7 +541,7 @@ struct cmd_nums {
         #define HWRM_FUNC_BUF_RGTR                                 (0x1fUL)
         #define HWRM_PORT_PHY_CFG                                  (0x20UL)
         #define HWRM_PORT_MAC_CFG                                  (0x21UL)
-        #define RESERVED2                                          (0x22UL)
+        #define HWRM_PORT_TS_QUERY                                 (0x22UL)
         #define HWRM_PORT_QSTATS                                   (0x23UL)
         #define HWRM_PORT_LPBK_QSTATS                              (0x24UL)
         #define HWRM_PORT_CLR_STATS                                (0x25UL)
@@ -452,6 +549,9 @@ struct cmd_nums {
         #define HWRM_PORT_PHY_QCFG                                 (0x27UL)
         #define HWRM_PORT_MAC_QCFG                                 (0x28UL)
         #define HWRM_PORT_BLINK_LED                                (0x29UL)
+        #define HWRM_PORT_PHY_QCAPS                                (0x2aUL)
+        #define HWRM_PORT_PHY_I2C_WRITE                    (0x2bUL)
+        #define HWRM_PORT_PHY_I2C_READ                             (0x2cUL)
         #define HWRM_QUEUE_QPORTCFG                                (0x30UL)
         #define HWRM_QUEUE_QCFG                            (0x31UL)
         #define HWRM_QUEUE_CFG                                     (0x32UL)
@@ -531,6 +631,7 @@ struct cmd_nums {
         __le16 unused_0[3];
 };
 
+/* Return Codes (8 bytes) */
 struct ret_codes {
         __le16 error_code;
         #define HWRM_ERR_CODE_SUCCESS                              (0x0UL)
@@ -875,10 +976,11 @@ struct hwrm_func_vf_cfg_input {
         #define FUNC_VF_CFG_REQ_ENABLES_MTU                         0x1UL
         #define FUNC_VF_CFG_REQ_ENABLES_GUEST_VLAN                  0x2UL
         #define FUNC_VF_CFG_REQ_ENABLES_ASYNC_EVENT_CR              0x4UL
+        #define FUNC_VF_CFG_REQ_ENABLES_DFLT_MAC_ADDR               0x8UL
         __le16 mtu;
         __le16 guest_vlan;
         __le16 async_event_cr;
-        __le16 unused_0[3];
+        u8 dflt_mac_addr[6];
 };
 
 /* Output (16 bytes) */
@@ -917,7 +1019,8 @@ struct hwrm_func_qcaps_output {
         __le32 flags;
         #define FUNC_QCAPS_RESP_FLAGS_PUSH_MODE_SUPPORTED           0x1UL
         #define FUNC_QCAPS_RESP_FLAGS_GLOBAL_MSIX_AUTOMASKING      0x2UL
-        u8 perm_mac_address[6];
+        #define FUNC_QCAPS_RESP_FLAGS_PTP_SUPPORTED                 0x4UL
+        u8 mac_address[6];
         __le16 max_rsscos_ctx;
         __le16 max_cmpl_rings;
         __le16 max_tx_rings;
@@ -942,6 +1045,67 @@ struct hwrm_func_qcaps_output {
         u8 valid;
 };
 
+/* hwrm_func_qcfg */
+/* Input (24 bytes) */
+struct hwrm_func_qcfg_input {
+        __le16 req_type;
+        __le16 cmpl_ring;
+        __le16 seq_id;
+        __le16 target_id;
+        __le64 resp_addr;
+        __le16 fid;
+        __le16 unused_0[3];
+};
+
+/* Output (72 bytes) */
+struct hwrm_func_qcfg_output {
+        __le16 error_code;
+        __le16 req_type;
+        __le16 seq_id;
+        __le16 resp_len;
+        __le16 fid;
+        __le16 port_id;
+        __le16 vlan;
+        u8 unused_0;
+        u8 unused_1;
+        u8 mac_address[6];
+        __le16 pci_id;
+        __le16 alloc_rsscos_ctx;
+        __le16 alloc_cmpl_rings;
+        __le16 alloc_tx_rings;
+        __le16 alloc_rx_rings;
+        __le16 alloc_l2_ctx;
+        __le16 alloc_vnics;
+        __le16 mtu;
+        __le16 mru;
+        __le16 stat_ctx_id;
+        u8 port_partition_type;
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_SPF             (0x0UL << 0)
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_MPFS    (0x1UL << 0)
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_NPAR1_0         (0x2UL << 0)
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_NPAR1_5         (0x3UL << 0)
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_NPAR2_0         (0x4UL << 0)
+        #define FUNC_QCFG_RESP_PORT_PARTITION_TYPE_UNKNOWN         (0xffUL << 0)
+        u8 unused_2;
+        __le16 dflt_vnic_id;
+        u8 unused_3;
+        u8 unused_4;
+        __le32 min_bw;
+        __le32 max_bw;
+        u8 evb_mode;
+        #define FUNC_QCFG_RESP_EVB_MODE_NO_EVB                     (0x0UL << 0)
+        #define FUNC_QCFG_RESP_EVB_MODE_VEB                        (0x1UL << 0)
+        #define FUNC_QCFG_RESP_EVB_MODE_VEPA                       (0x2UL << 0)
+        u8 unused_5;
+        __le16 unused_6;
+        __le32 alloc_mcast_filters;
+        __le32 alloc_hw_ring_grps;
+        u8 unused_7;
+        u8 unused_8;
+        u8 unused_9;
+        u8 valid;
+};
+
 /* hwrm_func_cfg */
 /* Input (88 bytes) */
 struct hwrm_func_cfg_input {
@@ -1171,6 +1335,7 @@ struct hwrm_func_drv_rgtr_input {
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_UNKNOWN                  (0x0UL << 0)
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_OTHER            (0x1UL << 0)
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_MSDOS            (0xeUL << 0)
+        #define FUNC_DRV_RGTR_REQ_OS_TYPE_WINDOWS                  (0x12UL << 0)
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_SOLARIS                  (0x1dUL << 0)
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_LINUX            (0x24UL << 0)
         #define FUNC_DRV_RGTR_REQ_OS_TYPE_FREEBSD                  (0x2aUL << 0)
@@ -1302,6 +1467,7 @@ struct hwrm_func_drv_qver_output {
         #define FUNC_DRV_QVER_RESP_OS_TYPE_UNKNOWN                 (0x0UL << 0)
         #define FUNC_DRV_QVER_RESP_OS_TYPE_OTHER                   (0x1UL << 0)
         #define FUNC_DRV_QVER_RESP_OS_TYPE_MSDOS                   (0xeUL << 0)
+        #define FUNC_DRV_QVER_RESP_OS_TYPE_WINDOWS                 (0x12UL << 0)
         #define FUNC_DRV_QVER_RESP_OS_TYPE_SOLARIS                 (0x1dUL << 0)
         #define FUNC_DRV_QVER_RESP_OS_TYPE_LINUX                   (0x24UL << 0)
         #define FUNC_DRV_QVER_RESP_OS_TYPE_FREEBSD                 (0x2aUL << 0)
@@ -1317,7 +1483,7 @@ struct hwrm_func_drv_qver_output {
 };
 
 /* hwrm_port_phy_cfg */
-/* Input (48 bytes) */
+/* Input (56 bytes) */
 struct hwrm_port_phy_cfg_input {
         __le16 req_type;
         __le16 cmpl_ring;
@@ -1329,6 +1495,10 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_FLAGS_FORCE_LINK_DOWN              0x2UL
         #define PORT_PHY_CFG_REQ_FLAGS_FORCE                        0x4UL
         #define PORT_PHY_CFG_REQ_FLAGS_RESTART_AUTONEG              0x8UL
+        #define PORT_PHY_CFG_REQ_FLAGS_EEE_ENABLE                   0x10UL
+        #define PORT_PHY_CFG_REQ_FLAGS_EEE_DISABLE                  0x20UL
+        #define PORT_PHY_CFG_REQ_FLAGS_EEE_TX_LPI_ENABLE            0x40UL
+        #define PORT_PHY_CFG_REQ_FLAGS_EEE_TX_LPI_DISABLE           0x80UL
         __le32 enables;
         #define PORT_PHY_CFG_REQ_ENABLES_AUTO_MODE                  0x1UL
         #define PORT_PHY_CFG_REQ_ENABLES_AUTO_DUPLEX                0x2UL
@@ -1339,6 +1509,8 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_ENABLES_LPBK                       0x40UL
         #define PORT_PHY_CFG_REQ_ENABLES_PREEMPHASIS                0x80UL
         #define PORT_PHY_CFG_REQ_ENABLES_FORCE_PAUSE                0x100UL
+        #define PORT_PHY_CFG_REQ_ENABLES_EEE_LINK_SPEED_MASK       0x200UL
+        #define PORT_PHY_CFG_REQ_ENABLES_TX_LPI_TIMER               0x400UL
         __le16 port_id;
         __le16 force_link_speed;
         #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_100MB    (0x1UL << 0)
@@ -1350,12 +1522,14 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_25GB             (0xfaUL << 0)
         #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_40GB             (0x190UL << 0)
         #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_50GB             (0x1f4UL << 0)
+        #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_100GB    (0x3e8UL << 0)
+        #define PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_10MB             (0xffffUL << 0)
         u8 auto_mode;
         #define PORT_PHY_CFG_REQ_AUTO_MODE_NONE            (0x0UL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_MODE_ALL_SPEEDS              (0x1UL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_MODE_ONE_SPEED               (0x2UL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_MODE_ONE_OR_BELOW    (0x3UL << 0)
-        #define PORT_PHY_CFG_REQ_AUTO_MODE_MASK            (0x4UL << 0)
+        #define PORT_PHY_CFG_REQ_AUTO_MODE_SPEED_MASK              (0x4UL << 0)
         u8 auto_duplex;
         #define PORT_PHY_CFG_REQ_AUTO_DUPLEX_HALF                  (0x0UL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_DUPLEX_FULL                  (0x1UL << 0)
@@ -1363,6 +1537,7 @@ struct hwrm_port_phy_cfg_input {
         u8 auto_pause;
         #define PORT_PHY_CFG_REQ_AUTO_PAUSE_TX                      0x1UL
         #define PORT_PHY_CFG_REQ_AUTO_PAUSE_RX                      0x2UL
+        #define PORT_PHY_CFG_REQ_AUTO_PAUSE_AUTONEG_PAUSE           0x4UL
         u8 unused_0;
         __le16 auto_link_speed;
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_100MB             (0x1UL << 0)
@@ -1374,6 +1549,8 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_25GB              (0xfaUL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_40GB              (0x190UL << 0)
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_50GB              (0x1f4UL << 0)
+        #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_100GB             (0x3e8UL << 0)
+        #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_10MB              (0xffffUL << 0)
         __le16 auto_link_speed_mask;
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_100MBHD      0x1UL
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_100MB         0x2UL
@@ -1386,6 +1563,9 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_25GB          0x100UL
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_40GB          0x200UL
         #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_50GB          0x400UL
+        #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_100GB         0x800UL
+        #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_10MBHD       0x1000UL
+        #define PORT_PHY_CFG_REQ_AUTO_LINK_SPEED_MASK_10MB          0x2000UL
         u8 wirespeed;
         #define PORT_PHY_CFG_REQ_WIRESPEED_OFF                     (0x0UL << 0)
         #define PORT_PHY_CFG_REQ_WIRESPEED_ON                      (0x1UL << 0)
@@ -1398,7 +1578,20 @@ struct hwrm_port_phy_cfg_input {
         #define PORT_PHY_CFG_REQ_FORCE_PAUSE_RX             0x2UL
         u8 unused_1;
         __le32 preemphasis;
-        __le32 unused_2;
+        __le16 eee_link_speed_mask;
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_RSVD1          0x1UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_100MB          0x2UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_RSVD2          0x4UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_1GB            0x8UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_RSVD3          0x10UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_RSVD4          0x20UL
+        #define PORT_PHY_CFG_REQ_EEE_LINK_SPEED_MASK_10GB           0x40UL
+        u8 unused_2;
+        u8 unused_3;
+        __le32 tx_lpi_timer;
+        __le32 unused_4;
+        #define PORT_PHY_CFG_REQ_TX_LPI_TIMER_MASK                  0xffffffUL
+        #define PORT_PHY_CFG_REQ_TX_LPI_TIMER_SFT                   0
 };
 
 /* Output (16 bytes) */
@@ -1426,7 +1619,7 @@ struct hwrm_port_phy_qcfg_input {
         __le16 unused_0[3];
 };
 
-/* Output (48 bytes) */
+/* Output (96 bytes) */
 struct hwrm_port_phy_qcfg_output {
         __le16 error_code;
         __le16 req_type;
@@ -1447,6 +1640,8 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_LINK_SPEED_25GB                 (0xfaUL << 0)
         #define PORT_PHY_QCFG_RESP_LINK_SPEED_40GB                 (0x190UL << 0)
         #define PORT_PHY_QCFG_RESP_LINK_SPEED_50GB                 (0x1f4UL << 0)
+        #define PORT_PHY_QCFG_RESP_LINK_SPEED_100GB                (0x3e8UL << 0)
+        #define PORT_PHY_QCFG_RESP_LINK_SPEED_10MB                 (0xffffUL << 0)
         u8 duplex;
         #define PORT_PHY_QCFG_RESP_DUPLEX_HALF                     (0x0UL << 0)
         #define PORT_PHY_QCFG_RESP_DUPLEX_FULL                     (0x1UL << 0)
@@ -1465,6 +1660,9 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_25GB              0x100UL
         #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_40GB              0x200UL
         #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_50GB              0x400UL
+        #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_100GB     0x800UL
+        #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_10MBHD            0x1000UL
+        #define PORT_PHY_QCFG_RESP_SUPPORT_SPEEDS_10MB              0x2000UL
         __le16 force_link_speed;
         #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_100MB          (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_1GB    (0xaUL << 0)
@@ -1475,15 +1673,18 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_25GB           (0xfaUL << 0)
         #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_40GB           (0x190UL << 0)
         #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_50GB           (0x1f4UL << 0)
+        #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_100GB          (0x3e8UL << 0)
+        #define PORT_PHY_QCFG_RESP_FORCE_LINK_SPEED_10MB           (0xffffUL << 0)
         u8 auto_mode;
         #define PORT_PHY_QCFG_RESP_AUTO_MODE_NONE                  (0x0UL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_MODE_ALL_SPEEDS    (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_MODE_ONE_SPEED             (0x2UL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_MODE_ONE_OR_BELOW          (0x3UL << 0)
-        #define PORT_PHY_QCFG_RESP_AUTO_MODE_MASK                  (0x4UL << 0)
+        #define PORT_PHY_QCFG_RESP_AUTO_MODE_SPEED_MASK    (0x4UL << 0)
         u8 auto_pause;
         #define PORT_PHY_QCFG_RESP_AUTO_PAUSE_TX                    0x1UL
         #define PORT_PHY_QCFG_RESP_AUTO_PAUSE_RX                    0x2UL
+        #define PORT_PHY_QCFG_RESP_AUTO_PAUSE_AUTONEG_PAUSE         0x4UL
         __le16 auto_link_speed;
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_100MB           (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_1GB             (0xaUL << 0)
@@ -1494,6 +1695,8 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_25GB    (0xfaUL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_40GB    (0x190UL << 0)
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_50GB    (0x1f4UL << 0)
+        #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_100GB           (0x3e8UL << 0)
+        #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_10MB    (0xffffUL << 0)
         __le16 auto_link_speed_mask;
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_100MBHD    0x1UL
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_100MB      0x2UL
@@ -1506,6 +1709,9 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_25GB       0x100UL
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_40GB       0x200UL
         #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_50GB       0x400UL
+        #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_100GB      0x800UL
+        #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_10MBHD     0x1000UL
+        #define PORT_PHY_QCFG_RESP_AUTO_LINK_SPEED_MASK_10MB       0x2000UL
         u8 wirespeed;
         #define PORT_PHY_QCFG_RESP_WIRESPEED_OFF                   (0x0UL << 0)
         #define PORT_PHY_QCFG_RESP_WIRESPEED_ON            (0x1UL << 0)
@@ -1516,31 +1722,49 @@ struct hwrm_port_phy_qcfg_output {
         u8 force_pause;
         #define PORT_PHY_QCFG_RESP_FORCE_PAUSE_TX                   0x1UL
         #define PORT_PHY_QCFG_RESP_FORCE_PAUSE_RX                   0x2UL
-        u8 reserved1;
+        u8 module_status;
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_NONE              (0x0UL << 0)
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_DISABLETX         (0x1UL << 0)
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_WARNINGMSG       (0x2UL << 0)
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_PWRDOWN           (0x3UL << 0)
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_NOTINSERTED      (0x4UL << 0)
+        #define PORT_PHY_QCFG_RESP_MODULE_STATUS_NOTAPPLICABLE    (0xffUL << 0)
         __le32 preemphasis;
         u8 phy_maj;
         u8 phy_min;
         u8 phy_bld;
         u8 phy_type;
-        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASECR4                (0x1UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_UNKNOWN                (0x0UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASECR                 (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASEKR4                (0x2UL << 0)
-        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASELR4                (0x3UL << 0)
-        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASESR4                (0x4UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASELR                 (0x3UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASESR                 (0x4UL << 0)
         #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASEKR2                (0x5UL << 0)
-        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASEKX4                (0x6UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASEKX                 (0x6UL << 0)
         #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASEKR                 (0x7UL << 0)
         #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASET                  (0x8UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_BASETE                 (0x9UL << 0)
+        #define PORT_PHY_QCFG_RESP_PHY_TYPE_SGMIIEXTPHY    (0xaUL << 0)
         u8 media_type;
+        #define PORT_PHY_QCFG_RESP_MEDIA_TYPE_UNKNOWN              (0x0UL << 0)
         #define PORT_PHY_QCFG_RESP_MEDIA_TYPE_TP                   (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_MEDIA_TYPE_DAC                  (0x2UL << 0)
         #define PORT_PHY_QCFG_RESP_MEDIA_TYPE_FIBRE                (0x3UL << 0)
-        u8 transceiver_type;
-        #define PORT_PHY_QCFG_RESP_TRANSCEIVER_TYPE_XCVR_INTERNAL (0x1UL << 0)
-        #define PORT_PHY_QCFG_RESP_TRANSCEIVER_TYPE_XCVR_EXTERNAL (0x2UL << 0)
-        u8 phy_addr;
+        u8 xcvr_pkg_type;
+        #define PORT_PHY_QCFG_RESP_XCVR_PKG_TYPE_XCVR_INTERNAL    (0x1UL << 0)
+        #define PORT_PHY_QCFG_RESP_XCVR_PKG_TYPE_XCVR_EXTERNAL    (0x2UL << 0)
+        u8 eee_config_phy_addr;
         #define PORT_PHY_QCFG_RESP_PHY_ADDR_MASK                    0x1fUL
         #define PORT_PHY_QCFG_RESP_PHY_ADDR_SFT             0
-        u8 unused_2;
+        #define PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_ENABLED           0x20UL
+        #define PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_ACTIVE            0x40UL
+        #define PORT_PHY_QCFG_RESP_EEE_CONFIG_EEE_TX_LPI            0x80UL
+        #define PORT_PHY_QCFG_RESP_EEE_CONFIG_MASK                  0xe0UL
+        #define PORT_PHY_QCFG_RESP_EEE_CONFIG_SFT                   5
+        u8 parallel_detect;
+        #define PORT_PHY_QCFG_RESP_PARALLEL_DETECT                  0x1UL
+        #define PORT_PHY_QCFG_RESP_RESERVED_MASK                    0xfeUL
+        #define PORT_PHY_QCFG_RESP_RESERVED_SFT             1
         __le16 link_partner_adv_speeds;
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_100MBHD 0x1UL
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_100MB   0x2UL
@@ -1553,15 +1777,48 @@ struct hwrm_port_phy_qcfg_output {
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_25GB    0x100UL
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_40GB    0x200UL
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_50GB    0x400UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_100GB   0x800UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_10MBHD  0x1000UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_SPEEDS_10MB    0x2000UL
         u8 link_partner_adv_auto_mode;
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_NONE (0x0UL << 0)
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_ALL_SPEEDS (0x1UL << 0)
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_ONE_SPEED (0x2UL << 0)
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_ONE_OR_BELOW (0x3UL << 0)
-        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_MASK (0x4UL << 0)
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_AUTO_MODE_SPEED_MASK (0x4UL << 0)
         u8 link_partner_adv_pause;
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_PAUSE_TX       0x1UL
         #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_PAUSE_RX       0x2UL
+        __le16 adv_eee_link_speed_mask;
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_RSVD1   0x1UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_100MB   0x2UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_RSVD2   0x4UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_1GB     0x8UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_RSVD3   0x10UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_RSVD4   0x20UL
+        #define PORT_PHY_QCFG_RESP_ADV_EEE_LINK_SPEED_MASK_10GB    0x40UL
+        __le16 link_partner_adv_eee_link_speed_mask;
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_RSVD1 0x1UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_100MB 0x2UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_RSVD2 0x4UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_1GB 0x8UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_RSVD3 0x10UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_RSVD4 0x20UL
+        #define PORT_PHY_QCFG_RESP_LINK_PARTNER_ADV_EEE_LINK_SPEED_MASK_10GB 0x40UL
+        __le32 xcvr_identifier_type_tx_lpi_timer;
+        #define PORT_PHY_QCFG_RESP_TX_LPI_TIMER_MASK                0xffffffUL
+        #define PORT_PHY_QCFG_RESP_TX_LPI_TIMER_SFT                 0
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_MASK       0xff000000UL
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_SFT         24
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_UNKNOWN   (0x0UL << 24)
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_SFP       (0x3UL << 24)
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_QSFP      (0xcUL << 24)
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_QSFPPLUS  (0xdUL << 24)
+        #define PORT_PHY_QCFG_RESP_XCVR_IDENTIFIER_TYPE_QSFP28    (0x11UL << 24)
+        __le32 unused_1;
+        char phy_vendor_name[16];
+        char phy_vendor_partnumber[16];
+        __le32 unused_2;
         u8 unused_3;
         u8 unused_4;
         u8 unused_5;
@@ -1569,7 +1826,7 @@ struct hwrm_port_phy_qcfg_output {
 };
 
 /* hwrm_port_mac_cfg */
-/* Input (32 bytes) */
+/* Input (40 bytes) */
 struct hwrm_port_mac_cfg_input {
         __le16 req_type;
         __le16 cmpl_ring;
@@ -1581,6 +1838,10 @@ struct hwrm_port_mac_cfg_input {
         #define PORT_MAC_CFG_REQ_FLAGS_COS_ASSIGNMENT_ENABLE       0x2UL
         #define PORT_MAC_CFG_REQ_FLAGS_TUNNEL_PRI2COS_ENABLE       0x4UL
         #define PORT_MAC_CFG_REQ_FLAGS_IP_DSCP2COS_ENABLE           0x8UL
+        #define PORT_MAC_CFG_REQ_FLAGS_PTP_RX_TS_CAPTURE_ENABLE    0x10UL
+        #define PORT_MAC_CFG_REQ_FLAGS_PTP_RX_TS_CAPTURE_DISABLE   0x20UL
+        #define PORT_MAC_CFG_REQ_FLAGS_PTP_TX_TS_CAPTURE_ENABLE    0x40UL
+        #define PORT_MAC_CFG_REQ_FLAGS_PTP_TX_TS_CAPTURE_DISABLE   0x80UL
         __le32 enables;
         #define PORT_MAC_CFG_REQ_ENABLES_IPG                        0x1UL
         #define PORT_MAC_CFG_REQ_ENABLES_LPBK                       0x2UL
@@ -1588,6 +1849,8 @@ struct hwrm_port_mac_cfg_input {
         #define PORT_MAC_CFG_REQ_ENABLES_LCOS_MAP_PRI               0x8UL
         #define PORT_MAC_CFG_REQ_ENABLES_TUNNEL_PRI2COS_MAP_PRI    0x10UL
         #define PORT_MAC_CFG_REQ_ENABLES_DSCP2COS_MAP_PRI           0x20UL
+        #define PORT_MAC_CFG_REQ_ENABLES_RX_TS_CAPTURE_PTP_MSG_TYPE 0x40UL
+        #define PORT_MAC_CFG_REQ_ENABLES_TX_TS_CAPTURE_PTP_MSG_TYPE 0x80UL
         __le16 port_id;
         u8 ipg;
         u8 lpbk;
@@ -1598,6 +1861,9 @@ struct hwrm_port_mac_cfg_input {
         u8 lcos_map_pri;
         u8 tunnel_pri2cos_map_pri;
         u8 dscp2pri_map_pri;
+        __le16 rx_ts_capture_ptp_msg_type;
+        __le16 tx_ts_capture_ptp_msg_type;
+        __le32 unused_0;
 };
 
 /* Output (16 bytes) */
@@ -1754,7 +2020,79 @@ struct hwrm_port_blink_led_output {
         u8 valid;
 };
 
-/* hwrm_queue_qportcfg */
+/* hwrm_port_phy_qcaps */
+/* Input (24 bytes) */
+struct hwrm_port_phy_qcaps_input {
+        __le16 req_type;
+        __le16 cmpl_ring;
+        __le16 seq_id;
+        __le16 target_id;
+        __le64 resp_addr;
+        __le16 port_id;
+        __le16 unused_0[3];
+};
+
+/* Output (24 bytes) */
+struct hwrm_port_phy_qcaps_output {
+        __le16 error_code;
+        __le16 req_type;
+        __le16 seq_id;
+        __le16 resp_len;
+        u8 eee_supported;
+        #define PORT_PHY_QCAPS_RESP_EEE_SUPPORTED                   0x1UL
+        #define PORT_PHY_QCAPS_RESP_RSVD1_MASK                      0xfeUL
+        #define PORT_PHY_QCAPS_RESP_RSVD1_SFT                       1
+        u8 unused_0;
+        __le16 supported_speeds_force_mode;
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_100MBHD 0x1UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_100MB 0x2UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_1GBHD 0x4UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_1GB 0x8UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_2GB 0x10UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_2_5GB 0x20UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_10GB 0x40UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_20GB 0x80UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_25GB 0x100UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_40GB 0x200UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_50GB 0x400UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_100GB 0x800UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_10MBHD 0x1000UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_FORCE_MODE_10MB 0x2000UL
+        __le16 supported_speeds_auto_mode;
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_100MBHD 0x1UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_100MB 0x2UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_1GBHD 0x4UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_1GB 0x8UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_2GB 0x10UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_2_5GB 0x20UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_10GB 0x40UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_20GB 0x80UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_25GB 0x100UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_40GB 0x200UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_50GB 0x400UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_100GB 0x800UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_10MBHD 0x1000UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_AUTO_MODE_10MB 0x2000UL
+        __le16 supported_speeds_eee_mode;
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_RSVD1 0x1UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_100MB 0x2UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_RSVD2 0x4UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_1GB  0x8UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_RSVD3 0x10UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_RSVD4 0x20UL
+        #define PORT_PHY_QCAPS_RESP_SUPPORTED_SPEEDS_EEE_MODE_10GB 0x40UL
+        __le32 tx_lpi_timer_low;
+        #define PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_LOW_MASK           0xffffffUL
+        #define PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_LOW_SFT            0
+        #define PORT_PHY_QCAPS_RESP_RSVD2_MASK                      0xff000000UL
+        #define PORT_PHY_QCAPS_RESP_RSVD2_SFT                       24
+        __le32 valid_tx_lpi_timer_high;
+        #define PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_HIGH_MASK          0xffffffUL
+        #define PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_HIGH_SFT           0
+        #define PORT_PHY_QCAPS_RESP_VALID_MASK                      0xff000000UL
+        #define PORT_PHY_QCAPS_RESP_VALID_SFT                       24
+};
+
 /* Input (24 bytes) */
 struct hwrm_queue_qportcfg_input {
         __le16 req_type;
@@ -1766,6 +2104,7 @@ struct hwrm_queue_qportcfg_input {
         #define QUEUE_QPORTCFG_REQ_FLAGS_PATH                       0x1UL
         #define QUEUE_QPORTCFG_REQ_FLAGS_PATH_TX                   (0x0UL << 0)
         #define QUEUE_QPORTCFG_REQ_FLAGS_PATH_RX                   (0x1UL << 0)
+        #define QUEUE_QPORTCFG_REQ_FLAGS_PATH_LAST    QUEUE_QPORTCFG_REQ_FLAGS_PATH_RX
         __le16 port_id;
         __le16 unused_0;
 };
@@ -1838,6 +2177,7 @@ struct hwrm_queue_cfg_input {
         #define QUEUE_CFG_REQ_FLAGS_PATH                            0x1UL
         #define QUEUE_CFG_REQ_FLAGS_PATH_TX                        (0x0UL << 0)
         #define QUEUE_CFG_REQ_FLAGS_PATH_RX                        (0x1UL << 0)
+        #define QUEUE_CFG_REQ_FLAGS_PATH_LAST    QUEUE_CFG_REQ_FLAGS_PATH_RX
         __le32 enables;
         #define QUEUE_CFG_REQ_ENABLES_DFLT_LEN                      0x1UL
         #define QUEUE_CFG_REQ_ENABLES_SERVICE_PROFILE               0x2UL
@@ -1875,6 +2215,7 @@ struct hwrm_queue_buffers_cfg_input {
         #define QUEUE_BUFFERS_CFG_REQ_FLAGS_PATH                    0x1UL
         #define QUEUE_BUFFERS_CFG_REQ_FLAGS_PATH_TX                (0x0UL << 0)
         #define QUEUE_BUFFERS_CFG_REQ_FLAGS_PATH_RX                (0x1UL << 0)
+        #define QUEUE_BUFFERS_CFG_REQ_FLAGS_PATH_LAST    QUEUE_BUFFERS_CFG_REQ_FLAGS_PATH_RX
         __le32 enables;
         #define QUEUE_BUFFERS_CFG_REQ_ENABLES_RESERVED              0x1UL
         #define QUEUE_BUFFERS_CFG_REQ_ENABLES_SHARED                0x2UL
@@ -1952,6 +2293,7 @@ struct hwrm_queue_pri2cos_cfg_input {
         #define QUEUE_PRI2COS_CFG_REQ_FLAGS_PATH                    0x1UL
         #define QUEUE_PRI2COS_CFG_REQ_FLAGS_PATH_TX                (0x0UL << 0)
         #define QUEUE_PRI2COS_CFG_REQ_FLAGS_PATH_RX                (0x1UL << 0)
+        #define QUEUE_PRI2COS_CFG_REQ_FLAGS_PATH_LAST    QUEUE_PRI2COS_CFG_REQ_FLAGS_PATH_RX
         #define QUEUE_PRI2COS_CFG_REQ_FLAGS_IVLAN                   0x2UL
         __le32 enables;
         u8 port_id;
@@ -2158,6 +2500,8 @@ struct hwrm_vnic_cfg_input {
         #define VNIC_CFG_REQ_FLAGS_DEFAULT                          0x1UL
         #define VNIC_CFG_REQ_FLAGS_VLAN_STRIP_MODE                  0x2UL
         #define VNIC_CFG_REQ_FLAGS_BD_STALL_MODE                    0x4UL
+        #define VNIC_CFG_REQ_FLAGS_ROCE_DUAL_VNIC_MODE              0x8UL
+        #define VNIC_CFG_REQ_FLAGS_ROCE_ONLY_VNIC_MODE              0x10UL
         __le32 enables;
         #define VNIC_CFG_REQ_ENABLES_DFLT_RING_GRP                  0x1UL
         #define VNIC_CFG_REQ_ENABLES_RSS_RULE                       0x2UL
@@ -2622,6 +2966,7 @@ struct hwrm_cfa_l2_filter_alloc_input {
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH                  0x1UL
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_TX              (0x0UL << 0)
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX              (0x1UL << 0)
+        #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_LAST    CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_LOOPBACK              0x2UL
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_DROP                  0x4UL
         #define CFA_L2_FILTER_ALLOC_REQ_FLAGS_OUTERMOST     0x8UL
@@ -2747,6 +3092,7 @@ struct hwrm_cfa_l2_filter_cfg_input {
         #define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH                    0x1UL
         #define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_TX                (0x0UL << 0)
         #define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX                (0x1UL << 0)
+        #define CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_LAST    CFA_L2_FILTER_CFG_REQ_FLAGS_PATH_RX
         #define CFA_L2_FILTER_CFG_REQ_FLAGS_DROP                    0x2UL
         __le32 enables;
         #define CFA_L2_FILTER_CFG_REQ_ENABLES_DST_ID                0x1UL
@@ -3337,6 +3683,41 @@ struct hwrm_fw_reset_output {
         u8 valid;
 };
 
+/* hwrm_fw_qstatus */
+/* Input (24 bytes) */
+struct hwrm_fw_qstatus_input {
+        __le16 req_type;
+        __le16 cmpl_ring;
+        __le16 seq_id;
+        __le16 target_id;
+        __le64 resp_addr;
+        u8 embedded_proc_type;
+        #define FW_QSTATUS_REQ_EMBEDDED_PROC_TYPE_BOOT             (0x0UL << 0)
+        #define FW_QSTATUS_REQ_EMBEDDED_PROC_TYPE_MGMT             (0x1UL << 0)
+        #define FW_QSTATUS_REQ_EMBEDDED_PROC_TYPE_NETCTRL          (0x2UL << 0)
+        #define FW_QSTATUS_REQ_EMBEDDED_PROC_TYPE_ROCE             (0x3UL << 0)
+        #define FW_QSTATUS_REQ_EMBEDDED_PROC_TYPE_RSVD             (0x4UL << 0)
+        u8 unused_0[7];
+};
+
+/* Output (16 bytes) */
+struct hwrm_fw_qstatus_output {
+        __le16 error_code;
+        __le16 req_type;
+        __le16 seq_id;
+        __le16 resp_len;
+        u8 selfrst_status;
+        #define FW_QSTATUS_RESP_SELFRST_STATUS_SELFRSTNONE         (0x0UL << 0)
+        #define FW_QSTATUS_RESP_SELFRST_STATUS_SELFRSTASAP         (0x1UL << 0)
+        #define FW_QSTATUS_RESP_SELFRST_STATUS_SELFRSTPCIERST     (0x2UL << 0)
+        u8 unused_0;
+        __le16 unused_1;
+        u8 unused_2;
+        u8 unused_3;
+        u8 unused_4;
+        u8 valid;
+};
+
 /* hwrm_exec_fwd_resp */
 /* Input (128 bytes) */
 struct hwrm_exec_fwd_resp_input {
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_nvm_defs.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_nvm_defs.h
index 43ef392c8588..40a7b0e09612 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_nvm_defs.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_nvm_defs.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
index 0c5f510492f1..8457850b0bdd 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -771,12 +771,8 @@ static int bnxt_vf_set_link(struct bnxt *bp, struct bnxt_vf_info *vf)
                             PORT_PHY_QCFG_RESP_LINK_NO_LINK) {
                                 phy_qcfg_resp.link =
                                         PORT_PHY_QCFG_RESP_LINK_LINK;
-                                if (phy_qcfg_resp.auto_link_speed)
-                                        phy_qcfg_resp.link_speed =
-                                                phy_qcfg_resp.auto_link_speed;
-                                else
-                                        phy_qcfg_resp.link_speed =
-                                                phy_qcfg_resp.force_link_speed;
+                                phy_qcfg_resp.link_speed = cpu_to_le16(
+                                        PORT_PHY_QCFG_RESP_LINK_SPEED_10GB);
                                 phy_qcfg_resp.duplex =
                                         PORT_PHY_QCFG_RESP_DUPLEX_FULL;
                                 phy_qcfg_resp.pause =
@@ -859,8 +855,8 @@ void bnxt_update_vf_mac(struct bnxt *bp)
          *    default but the stored zero MAC will allow the VF user to change
          *    the random MAC address using ndo_set_mac_address() if he wants.
          */
-        if (!ether_addr_equal(resp->perm_mac_address, bp->vf.mac_addr))
-                memcpy(bp->vf.mac_addr, resp->perm_mac_address, ETH_ALEN);
+        if (!ether_addr_equal(resp->mac_address, bp->vf.mac_addr))
+                memcpy(bp->vf.mac_addr, resp->mac_address, ETH_ALEN);
 
         /* overwrite netdev dev_addr with admin VF MAC */
         if (is_valid_ether_addr(bp->vf.mac_addr))
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.h
index c151280e3980..3f08354a247e 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.h
@@ -1,6 +1,6 @@
 /* Broadcom NetXtreme-C/E network driver.
  *
- * Copyright (c) 2014-2015 Broadcom Corporation
+ * Copyright (c) 2014-2016 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
index 6746fd03cb3a..f7b42b9fc979 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
@@ -104,8 +104,8 @@ static inline void dmadesc_set_addr(struct bcmgenet_priv *priv,
 static inline void dmadesc_set(struct bcmgenet_priv *priv,
                                void __iomem *d, dma_addr_t addr, u32 val)
 {
-        dmadesc_set_length_status(priv, d, val);
         dmadesc_set_addr(priv, d, addr);
+        dmadesc_set_length_status(priv, d, val);
 }
 
 static inline dma_addr_t dmadesc_get_addr(struct bcmgenet_priv *priv,
@@ -1171,6 +1171,7 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
         struct enet_cb *tx_cb_ptr;
         struct netdev_queue *txq;
         unsigned int pkts_compl = 0;
+        unsigned int bytes_compl = 0;
         unsigned int c_index;
         unsigned int txbds_ready;
         unsigned int txbds_processed = 0;
@@ -1193,16 +1194,13 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
                 tx_cb_ptr = &priv->tx_cbs[ring->clean_ptr];
                 if (tx_cb_ptr->skb) {
                         pkts_compl++;
-                        dev->stats.tx_packets++;
-                        dev->stats.tx_bytes += tx_cb_ptr->skb->len;
+                        bytes_compl += GENET_CB(tx_cb_ptr->skb)->bytes_sent;
                         dma_unmap_single(&dev->dev,
                                          dma_unmap_addr(tx_cb_ptr, dma_addr),
                                          dma_unmap_len(tx_cb_ptr, dma_len),
                                          DMA_TO_DEVICE);
                         bcmgenet_free_cb(tx_cb_ptr);
                 } else if (dma_unmap_addr(tx_cb_ptr, dma_addr)) {
-                        dev->stats.tx_bytes +=
-                                dma_unmap_len(tx_cb_ptr, dma_len);
                         dma_unmap_page(&dev->dev,
                                        dma_unmap_addr(tx_cb_ptr, dma_addr),
                                        dma_unmap_len(tx_cb_ptr, dma_len),
@@ -1220,6 +1218,9 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
         ring->free_bds += txbds_processed;
         ring->c_index = (ring->c_index + txbds_processed) & DMA_C_INDEX_MASK;
 
+        dev->stats.tx_packets += pkts_compl;
+        dev->stats.tx_bytes += bytes_compl;
+
         if (ring->free_bds > (MAX_SKB_FRAGS + 1)) {
                 txq = netdev_get_tx_queue(dev, ring->queue);
                 if (netif_tx_queue_stopped(txq))
@@ -1296,7 +1297,7 @@ static int bcmgenet_xmit_single(struct net_device *dev,
 
         tx_cb_ptr->skb = skb;
 
-        skb_len = skb_headlen(skb) < ETH_ZLEN ? ETH_ZLEN : skb_headlen(skb);
+        skb_len = skb_headlen(skb);
 
         mapping = dma_map_single(kdev, skb->data, skb_len, DMA_TO_DEVICE);
         ret = dma_mapping_error(kdev, mapping);
@@ -1330,6 +1331,7 @@ static int bcmgenet_xmit_frag(struct net_device *dev,
         struct bcmgenet_priv *priv = netdev_priv(dev);
         struct device *kdev = &priv->pdev->dev;
         struct enet_cb *tx_cb_ptr;
+        unsigned int frag_size;
         dma_addr_t mapping;
         int ret;
 
@@ -1337,10 +1339,12 @@ static int bcmgenet_xmit_frag(struct net_device *dev,
 
         if (unlikely(!tx_cb_ptr))
                 BUG();
+
         tx_cb_ptr->skb = NULL;
 
-        mapping = skb_frag_dma_map(kdev, frag, 0,
-                                   skb_frag_size(frag), DMA_TO_DEVICE);
+        frag_size = skb_frag_size(frag);
+
+        mapping = skb_frag_dma_map(kdev, frag, 0, frag_size, DMA_TO_DEVICE);
         ret = dma_mapping_error(kdev, mapping);
         if (ret) {
                 priv->mib.tx_dma_failed++;
@@ -1350,10 +1354,10 @@ static int bcmgenet_xmit_frag(struct net_device *dev,
         }
 
         dma_unmap_addr_set(tx_cb_ptr, dma_addr, mapping);
-        dma_unmap_len_set(tx_cb_ptr, dma_len, frag->size);
+        dma_unmap_len_set(tx_cb_ptr, dma_len, frag_size);
 
         dmadesc_set(priv, tx_cb_ptr->bd_addr, mapping,
-                    (frag->size << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
+                    (frag_size << DMA_BUFLENGTH_SHIFT) | dma_desc_flags |
                     (priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT));
 
         return 0;
@@ -1446,15 +1450,19 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
         else
                 index -= 1;
 
-        nr_frags = skb_shinfo(skb)->nr_frags;
         ring = &priv->tx_rings[index];
         txq = netdev_get_tx_queue(dev, ring->queue);
 
+        nr_frags = skb_shinfo(skb)->nr_frags;
+
         spin_lock_irqsave(&ring->lock, flags);
-        if (ring->free_bds <= nr_frags + 1) {
-                netif_tx_stop_queue(txq);
-                netdev_err(dev, "%s: tx ring %d full when queue %d awake\n",
-                           __func__, index, ring->queue);
+        if (ring->free_bds <= (nr_frags + 1)) {
+                if (!netif_tx_queue_stopped(txq)) {
+                        netif_tx_stop_queue(txq);
+                        netdev_err(dev,
+                                   "%s: tx ring %d full when queue %d awake\n",
+                                   __func__, index, ring->queue);
+                }
                 ret = NETDEV_TX_BUSY;
                 goto out;
         }
@@ -1464,6 +1472,11 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto out;
         }
 
+        /* Retain how many bytes will be sent on the wire, without TSB inserted
+         * by transmit checksum offload
+         */
+        GENET_CB(skb)->bytes_sent = skb->len;
+
         /* set the SKB transmit checksum */
         if (priv->desc_64b_en) {
                 skb = bcmgenet_put_tx_csum(dev, skb);
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.h b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
index 967367557309..1e2dc34d331a 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.h
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
@@ -531,6 +531,12 @@ struct bcmgenet_hw_params {
         u32             flags;
 };
 
+struct bcmgenet_skb_cb {
+        unsigned int bytes_sent;        /* bytes on the wire (no TSB) */
+};
+
+#define GENET_CB(skb)   ((struct bcmgenet_skb_cb *)((skb)->cb))
+
 struct bcmgenet_tx_ring {
         spinlock_t      lock;           /* ring lock */
         struct napi_struct napi;        /* NAPI per tx queue */
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index 3ce6095ced3d..eec3200ade4a 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -61,8 +61,7 @@
 #define MACB_WOL_HAS_MAGIC_PACKET       (0x1 << 0)
 #define MACB_WOL_ENABLED                (0x1 << 1)
 
-/*
- * Graceful stop timeouts in us. We should allow up to
+/* Graceful stop timeouts in us. We should allow up to
  * 1 frame time (10 Mbits/s, full-duplex, ignoring collisions)
  */
 #define MACB_HALT_TIMEOUT       1230
@@ -130,9 +129,8 @@ static void hw_writel(struct macb *bp, int offset, u32 value)
         writel_relaxed(value, bp->regs + offset);
 }
 
-/*
- * Find the CPU endianness by using the loopback bit of NCR register. When the
- * CPU is in big endian we need to program swaped mode for management
+/* Find the CPU endianness by using the loopback bit of NCR register. When the
+ * CPU is in big endian we need to program swapped mode for management
  * descriptor access.
  */
 static bool hw_is_native_io(void __iomem *addr)
@@ -189,7 +187,7 @@ static void macb_get_hwaddr(struct macb *bp)
 
         pdata = dev_get_platdata(&bp->pdev->dev);
 
-        /* Check all 4 address register for vaild address */
+        /* Check all 4 address register for valid address */
         for (i = 0; i < 4; i++) {
                 bottom = macb_or_gem_readl(bp, SA1B + i * 8);
                 top = macb_or_gem_readl(bp, SA1T + i * 8);
@@ -297,7 +295,7 @@ static void macb_set_tx_clk(struct clk *clk, int speed, struct net_device *dev)
         ferr = DIV_ROUND_UP(ferr, rate / 100000);
         if (ferr > 5)
                 netdev_warn(dev, "unable to generate target frequency: %ld Hz\n",
-                                rate);
+                            rate);
 
         if (clk_set_rate(clk, rate_rounded))
                 netdev_err(dev, "adjusting tx_clk failed.\n");
@@ -386,7 +384,8 @@ static int macb_mii_probe(struct net_device *dev)
 
         pdata = dev_get_platdata(&bp->pdev->dev);
         if (pdata && gpio_is_valid(pdata->phy_irq_pin)) {
-                ret = devm_gpio_request(&bp->pdev->dev, pdata->phy_irq_pin, "phy int");
+                ret = devm_gpio_request(&bp->pdev->dev, pdata->phy_irq_pin,
+                                        "phy int");
                 if (!ret) {
                         phy_irq = gpio_to_irq(pdata->phy_irq_pin);
                         phydev->irq = (phy_irq < 0) ? PHY_POLL : phy_irq;
@@ -430,7 +429,7 @@ static int macb_mii_init(struct macb *bp)
         macb_writel(bp, NCR, MACB_BIT(MPE));
 
         bp->mii_bus = mdiobus_alloc();
-        if (bp->mii_bus == NULL) {
+        if (!bp->mii_bus) {
                 err = -ENOMEM;
                 goto err_out;
         }
@@ -439,7 +438,7 @@ static int macb_mii_init(struct macb *bp)
         bp->mii_bus->read = &macb_mdio_read;
         bp->mii_bus->write = &macb_mdio_write;
         snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
-                bp->pdev->name, bp->pdev->id);
+                 bp->pdev->name, bp->pdev->id);
         bp->mii_bus->priv = bp;
         bp->mii_bus->parent = &bp->dev->dev;
         pdata = dev_get_platdata(&bp->pdev->dev);
@@ -452,7 +451,8 @@ static int macb_mii_init(struct macb *bp)
                 err = of_mdiobus_register(bp->mii_bus, np);
 
                 /* fallback to standard phy registration if no phy were
-                   found during dt phy registration */
+                 * found during dt phy registration
+                 */
                 if (!err && !phy_find_first(bp->mii_bus)) {
                         for (i = 0; i < PHY_MAX_ADDR; i++) {
                                 struct phy_device *phydev;
@@ -499,7 +499,7 @@ static void macb_update_stats(struct macb *bp)
 
         WARN_ON((unsigned long)(end - p - 1) != (MACB_TPF - MACB_PFR) / 4);
 
-        for(; p < end; p++, offset += 4)
+        for (; p < end; p++, offset += 4)
                 *p += bp->macb_reg_readl(bp, offset);
 }
 
@@ -567,8 +567,7 @@ static void macb_tx_error_task(struct work_struct *work)
         /* Make sure nobody is trying to queue up new packets */
         netif_tx_stop_all_queues(bp->dev);
 
-        /*
-         * Stop transmission now
+        /* Stop transmission now
          * (in case we have just queued new packets)
          * macb/gem must be halted to write TBQP register
          */
@@ -576,8 +575,7 @@ static void macb_tx_error_task(struct work_struct *work)
                 /* Just complain for now, reinitializing TX path can be good */
                 netdev_err(bp->dev, "BUG: halt tx timed out\n");
 
-        /*
-         * Treat frames in TX queue including the ones that caused the error.
+        /* Treat frames in TX queue including the ones that caused the error.
          * Free transmit buffers in upper layer.
          */
         for (tail = queue->tx_tail; tail != queue->tx_head; tail++) {
@@ -607,10 +605,9 @@ static void macb_tx_error_task(struct work_struct *work)
                                 bp->stats.tx_bytes += skb->len;
                         }
                 } else {
-                        /*
-                         * "Buffers exhausted mid-frame" errors may only happen
-                         * if the driver is buggy, so complain loudly about those.
-                         * Statistics are updated by hardware.
+                        /* "Buffers exhausted mid-frame" errors may only happen
+                         * if the driver is buggy, so complain loudly about
+                         * those. Statistics are updated by hardware.
                          */
                         if (ctrl & MACB_BIT(TX_BUF_EXHAUSTED))
                                 netdev_err(bp->dev,
@@ -662,7 +659,7 @@ static void macb_tx_interrupt(struct macb_queue *queue)
                 queue_writel(queue, ISR, MACB_BIT(TCOMP));
 
         netdev_vdbg(bp->dev, "macb_tx_interrupt status = 0x%03lx\n",
-                (unsigned long)status);
+                    (unsigned long)status);
 
         head = queue->tx_head;
         for (tail = queue->tx_tail; tail != head; tail++) {
@@ -722,7 +719,8 @@ static void gem_rx_refill(struct macb *bp)
         struct sk_buff          *skb;
         dma_addr_t              paddr;
 
-        while (CIRC_SPACE(bp->rx_prepared_head, bp->rx_tail, RX_RING_SIZE) > 0) {
+        while (CIRC_SPACE(bp->rx_prepared_head, bp->rx_tail,
+                          RX_RING_SIZE) > 0) {
                 entry = macb_rx_ring_wrap(bp->rx_prepared_head);
 
                 /* Make hw descriptor updates visible to CPU */
@@ -730,10 +728,10 @@ static void gem_rx_refill(struct macb *bp)
 
                 bp->rx_prepared_head++;
 
-                if (bp->rx_skbuff[entry] == NULL) {
+                if (!bp->rx_skbuff[entry]) {
                         /* allocate sk_buff for this free entry in ring */
                         skb = netdev_alloc_skb(bp->dev, bp->rx_buffer_size);
-                        if (unlikely(skb == NULL)) {
+                        if (unlikely(!skb)) {
                                 netdev_err(bp->dev,
                                            "Unable to allocate sk_buff\n");
                                 break;
@@ -741,7 +739,8 @@ static void gem_rx_refill(struct macb *bp)
 
                         /* now fill corresponding descriptor entry */
                         paddr = dma_map_single(&bp->pdev->dev, skb->data,
-                                               bp->rx_buffer_size, DMA_FROM_DEVICE);
+                                               bp->rx_buffer_size,
+                                               DMA_FROM_DEVICE);
                         if (dma_mapping_error(&bp->pdev->dev, paddr)) {
                                 dev_kfree_skb(skb);
                                 break;
@@ -766,7 +765,7 @@ static void gem_rx_refill(struct macb *bp)
         wmb();
 
         netdev_vdbg(bp->dev, "rx ring: prepared head %d, tail %d\n",
-                   bp->rx_prepared_head, bp->rx_tail);
+                    bp->rx_prepared_head, bp->rx_tail);
 }
 
 /* Mark DMA descriptors from begin up to and not including end as unused */
@@ -777,14 +776,14 @@ static void discard_partial_frame(struct macb *bp, unsigned int begin,
 
         for (frag = begin; frag != end; frag++) {
                 struct macb_dma_desc *desc = macb_rx_desc(bp, frag);
+
                 desc->addr &= ~MACB_BIT(RX_USED);
         }
 
         /* Make descriptor updates visible to hardware */
         wmb();
 
-        /*
-         * When this happens, the hardware stats registers for
+        /* When this happens, the hardware stats registers for
          * whatever caused this is updated, so we don't have to record
          * anything.
          */
@@ -880,11 +879,10 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
         len = desc->ctrl & bp->rx_frm_len_mask;
 
         netdev_vdbg(bp->dev, "macb_rx_frame frags %u - %u (len %u)\n",
-                macb_rx_ring_wrap(first_frag),
-                macb_rx_ring_wrap(last_frag), len);
+                    macb_rx_ring_wrap(first_frag),
+                    macb_rx_ring_wrap(last_frag), len);
 
-        /*
-         * The ethernet header starts NET_IP_ALIGN bytes into the
+        /* The ethernet header starts NET_IP_ALIGN bytes into the
          * first buffer. Since the header is 14 bytes, this makes the
          * payload word-aligned.
          *
@@ -917,11 +915,15 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
                 unsigned int frag_len = bp->rx_buffer_size;
 
                 if (offset + frag_len > len) {
-                        BUG_ON(frag != last_frag);
+                        if (unlikely(frag != last_frag)) {
+                                dev_kfree_skb_any(skb);
+                                return -1;
+                        }
                         frag_len = len - offset;
                 }
                 skb_copy_to_linear_data_offset(skb, offset,
-                                macb_rx_buffer(bp, frag), frag_len);
+                                               macb_rx_buffer(bp, frag),
+                                               frag_len);
                 offset += bp->rx_buffer_size;
                 desc = macb_rx_desc(bp, frag);
                 desc->addr &= ~MACB_BIT(RX_USED);
@@ -939,14 +941,29 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
         bp->stats.rx_packets++;
         bp->stats.rx_bytes += skb->len;
         netdev_vdbg(bp->dev, "received skb of length %u, csum: %08x\n",
-                   skb->len, skb->csum);
+                    skb->len, skb->csum);
         netif_receive_skb(skb);
 
         return 0;
 }
 
+static inline void macb_init_rx_ring(struct macb *bp)
+{
+        dma_addr_t addr;
+        int i;
+
+        addr = bp->rx_buffers_dma;
+        for (i = 0; i < RX_RING_SIZE; i++) {
+                bp->rx_ring[i].addr = addr;
+                bp->rx_ring[i].ctrl = 0;
+                addr += bp->rx_buffer_size;
+        }
+        bp->rx_ring[RX_RING_SIZE - 1].addr |= MACB_BIT(RX_WRAP);
+}
+
 static int macb_rx(struct macb *bp, int budget)
 {
+        bool reset_rx_queue = false;
         int received = 0;
         unsigned int tail;
         int first_frag = -1;
@@ -972,10 +989,18 @@ static int macb_rx(struct macb *bp, int budget)
 
                 if (ctrl & MACB_BIT(RX_EOF)) {
                         int dropped;
-                        BUG_ON(first_frag == -1);
+
+                        if (unlikely(first_frag == -1)) {
+                                reset_rx_queue = true;
+                                continue;
+                        }
 
                         dropped = macb_rx_frame(bp, first_frag, tail);
                         first_frag = -1;
+                        if (unlikely(dropped < 0)) {
+                                reset_rx_queue = true;
+                                continue;
+                        }
                         if (!dropped) {
                                 received++;
                                 budget--;
@@ -983,6 +1008,26 @@ static int macb_rx(struct macb *bp, int budget)
                 }
         }
 
+        if (unlikely(reset_rx_queue)) {
+                unsigned long flags;
+                u32 ctrl;
+
+                netdev_err(bp->dev, "RX queue corruption: reset it\n");
+
+                spin_lock_irqsave(&bp->lock, flags);
+
+                ctrl = macb_readl(bp, NCR);
+                macb_writel(bp, NCR, ctrl & ~MACB_BIT(RE));
+
+                macb_init_rx_ring(bp);
+                macb_writel(bp, RBQP, bp->rx_ring_dma);
+
+                macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
+
+                spin_unlock_irqrestore(&bp->lock, flags);
+                return received;
+        }
+
         if (first_frag != -1)
                 bp->rx_tail = first_frag;
         else
@@ -1003,7 +1048,7 @@ static int macb_poll(struct napi_struct *napi, int budget)
         work_done = 0;
 
         netdev_vdbg(bp->dev, "poll: status = %08lx, budget = %d\n",
-                   (unsigned long)status, budget);
+                    (unsigned long)status, budget);
 
         work_done = bp->macbgem_ops.mog_rx(bp, budget);
         if (work_done < budget) {
@@ -1053,8 +1098,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                             (unsigned long)status);
 
                 if (status & MACB_RX_INT_FLAGS) {
-                        /*
-                         * There's no point taking any more interrupts
+                        /* There's no point taking any more interrupts
                          * until we have processed the buffers. The
                          * scheduling call may fail if the poll routine
                          * is already scheduled, so disable interrupts
@@ -1083,8 +1127,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                 if (status & MACB_BIT(TCOMP))
                         macb_tx_interrupt(queue);
 
-                /*
-                 * Link change detection isn't possible with RMII, so we'll
+                /* Link change detection isn't possible with RMII, so we'll
                  * add that if/when we get our hands on a full-blown MII PHY.
                  */
 
@@ -1100,7 +1143,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                         macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
 
                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
-                                macb_writel(bp, ISR, MACB_BIT(RXUBR));
+                                queue_writel(queue, ISR, MACB_BIT(RXUBR));
                 }
 
                 if (status & MACB_BIT(ISR_ROVR)) {
@@ -1115,8 +1158,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                 }
 
                 if (status & MACB_BIT(HRESP)) {
-                        /*
-                         * TODO: Reset the hardware, and maybe move the
+                        /* TODO: Reset the hardware, and maybe move the
                          * netdev_err to a lower-priority context as well
                          * (work queue?)
                          */
@@ -1135,8 +1177,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
-/*
- * Polling receive - used by netconsole and other diagnostic tools
+/* Polling receive - used by netconsole and other diagnostic tools
  * to allow network i/o with interrupts disabled.
  */
 static void macb_poll_controller(struct net_device *dev)
@@ -1222,7 +1263,7 @@ static unsigned int macb_tx_map(struct macb *bp,
         }
 
         /* Should never happen */
-        if (unlikely(tx_skb == NULL)) {
+        if (unlikely(!tx_skb)) {
                 netdev_err(bp->dev, "BUG! empty skb!\n");
                 return 0;
         }
@@ -1292,16 +1333,16 @@ static int macb_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
 #if defined(DEBUG) && defined(VERBOSE_DEBUG)
         netdev_vdbg(bp->dev,
-                   "start_xmit: queue %hu len %u head %p data %p tail %p end %p\n",
-                   queue_index, skb->len, skb->head, skb->data,
-                   skb_tail_pointer(skb), skb_end_pointer(skb));
+                    "start_xmit: queue %hu len %u head %p data %p tail %p end %p\n",
+                    queue_index, skb->len, skb->head, skb->data,
+                    skb_tail_pointer(skb), skb_end_pointer(skb));
         print_hex_dump(KERN_DEBUG, "data: ", DUMP_PREFIX_OFFSET, 16, 1,
                        skb->data, 16, true);
 #endif
 
         /* Count how many TX buffer descriptors are needed to send this
          * socket buffer: skb fragments of jumbo frames may need to be
-         * splitted into many buffer descriptors.
+         * split into many buffer descriptors.
          */
         count = DIV_ROUND_UP(skb_headlen(skb), bp->max_tx_length);
         nr_frags = skb_shinfo(skb)->nr_frags;
@@ -1352,8 +1393,8 @@ static void macb_init_rx_buffer_size(struct macb *bp, size_t size)
 
                 if (bp->rx_buffer_size % RX_BUFFER_MULTIPLE) {
                         netdev_dbg(bp->dev,
-                                    "RX buffer must be multiple of %d bytes, expanding\n",
-                                    RX_BUFFER_MULTIPLE);
+                                   "RX buffer must be multiple of %d bytes, expanding\n",
+                                   RX_BUFFER_MULTIPLE);
                         bp->rx_buffer_size =
                                 roundup(bp->rx_buffer_size, RX_BUFFER_MULTIPLE);
                 }
@@ -1376,7 +1417,7 @@ static void gem_free_rx_buffers(struct macb *bp)
         for (i = 0; i < RX_RING_SIZE; i++) {
                 skb = bp->rx_skbuff[i];
 
-                if (skb == NULL)
+                if (!skb)
                         continue;
 
                 desc = &bp->rx_ring[i];
@@ -1432,10 +1473,10 @@ static int gem_alloc_rx_buffers(struct macb *bp)
         bp->rx_skbuff = kzalloc(size, GFP_KERNEL);
         if (!bp->rx_skbuff)
                 return -ENOMEM;
-        else
-                netdev_dbg(bp->dev,
-                           "Allocated %d RX struct sk_buff entries at %p\n",
-                           RX_RING_SIZE, bp->rx_skbuff);
+
+        netdev_dbg(bp->dev,
+                   "Allocated %d RX struct sk_buff entries at %p\n",
+                   RX_RING_SIZE, bp->rx_skbuff);
         return 0;
 }
 
@@ -1448,10 +1489,10 @@ static int macb_alloc_rx_buffers(struct macb *bp)
                                             &bp->rx_buffers_dma, GFP_KERNEL);
         if (!bp->rx_buffers)
                 return -ENOMEM;
-        else
-                netdev_dbg(bp->dev,
-                           "Allocated RX buffers of %d bytes at %08lx (mapped %p)\n",
-                           size, (unsigned long)bp->rx_buffers_dma, bp->rx_buffers);
+
+        netdev_dbg(bp->dev,
+                   "Allocated RX buffers of %d bytes at %08lx (mapped %p)\n",
+                   size, (unsigned long)bp->rx_buffers_dma, bp->rx_buffers);
         return 0;
 }
 
@@ -1523,15 +1564,8 @@ static void gem_init_rings(struct macb *bp)
 static void macb_init_rings(struct macb *bp)
 {
         int i;
-        dma_addr_t addr;
 
-        addr = bp->rx_buffers_dma;
-        for (i = 0; i < RX_RING_SIZE; i++) {
-                bp->rx_ring[i].addr = addr;
-                bp->rx_ring[i].ctrl = 0;
-                addr += bp->rx_buffer_size;
-        }
-        bp->rx_ring[RX_RING_SIZE - 1].addr |= MACB_BIT(RX_WRAP);
+        macb_init_rx_ring(bp);
 
         for (i = 0; i < TX_RING_SIZE; i++) {
                 bp->queues[0].tx_ring[i].addr = 0;
@@ -1549,8 +1583,7 @@ static void macb_reset_hw(struct macb *bp)
         struct macb_queue *queue;
         unsigned int q;
 
-        /*
-         * Disable RX and TX (XXX: Should we halt the transmission
+        /* Disable RX and TX (XXX: Should we halt the transmission
          * more gracefully?)
          */
         macb_writel(bp, NCR, 0);
@@ -1613,8 +1646,7 @@ static u32 macb_mdc_clk_div(struct macb *bp)
         return config;
 }
 
-/*
- * Get the DMA bus width field of the network configuration register that we
+/* Get the DMA bus width field of the network configuration register that we
  * should program.  We find the width from decoding the design configuration
  * register to find the maximum supported data bus width.
  */
@@ -1634,8 +1666,7 @@ static u32 macb_dbw(struct macb *bp)
         }
 }
 
-/*
- * Configure the receive DMA engine
+/* Configure the receive DMA engine
  * - use the correct receive buffer size
  * - set best burst length for DMA operations
  *   (if not supported by FIFO, it will fallback to default)
@@ -1723,8 +1754,7 @@ static void macb_init_hw(struct macb *bp)
         macb_writel(bp, NCR, MACB_BIT(RE) | MACB_BIT(TE) | MACB_BIT(MPE));
 }
 
-/*
- * The hash address register is 64 bits long and takes up two
+/* The hash address register is 64 bits long and takes up two
  * locations in the memory map.  The least significant bits are stored
  * in EMAC_HSL and the most significant bits in EMAC_HSH.
  *
@@ -1764,9 +1794,7 @@ static inline int hash_bit_value(int bitnr, __u8 *addr)
         return 0;
 }
 
-/*
- * Return the hash index value for the specified address.
- */
+/* Return the hash index value for the specified address. */
 static int hash_get_index(__u8 *addr)
 {
         int i, j, bitval;
@@ -1782,9 +1810,7 @@ static int hash_get_index(__u8 *addr)
         return hash_index;
 }
 
-/*
- * Add multicast addresses to the internal multicast-hash table.
- */
+/* Add multicast addresses to the internal multicast-hash table. */
 static void macb_sethashtable(struct net_device *dev)
 {
         struct netdev_hw_addr *ha;
@@ -1792,7 +1818,8 @@ static void macb_sethashtable(struct net_device *dev)
         unsigned int bitnr;
         struct macb *bp = netdev_priv(dev);
 
-        mc_filter[0] = mc_filter[1] = 0;
+        mc_filter[0] = 0;
+        mc_filter[1] = 0;
 
         netdev_for_each_mc_addr(ha, dev) {
                 bitnr = hash_get_index(ha->addr);
@@ -1803,9 +1830,7 @@ static void macb_sethashtable(struct net_device *dev)
         macb_or_gem_writel(bp, HRT, mc_filter[1]);
 }
 
-/*
- * Enable/Disable promiscuous and multicast modes.
- */
+/* Enable/Disable promiscuous and multicast modes. */
 static void macb_set_rx_mode(struct net_device *dev)
 {
         unsigned long cfg;
@@ -2122,9 +2147,8 @@ static void macb_get_regs(struct net_device *dev, struct ethtool_regs *regs,
 
         if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
                 regs_buff[12] = macb_or_gem_readl(bp, USRIO);
-        if (macb_is_gem(bp)) {
+        if (macb_is_gem(bp))
                 regs_buff[13] = gem_readl(bp, DMACFG);
-        }
 }
 
 static void macb_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
@@ -2247,11 +2271,11 @@ static const struct net_device_ops macb_netdev_ops = {
         .ndo_set_features       = macb_set_features,
 };
 
-/*
- * Configure peripheral capabilities according to device tree
+/* Configure peripheral capabilities according to device tree
  * and integration options used
  */
-static void macb_configure_caps(struct macb *bp, const struct macb_config *dt_conf)
+static void macb_configure_caps(struct macb *bp,
+                                const struct macb_config *dt_conf)
 {
         u32 dcfg;
 
@@ -2949,7 +2973,7 @@ static int macb_probe(struct platform_device *pdev)
 
         mac = of_get_mac_address(np);
         if (mac)
-                memcpy(bp->dev->dev_addr, mac, ETH_ALEN);
+                ether_addr_copy(bp->dev->dev_addr, mac);
         else
                 macb_get_hwaddr(bp);
 
@@ -2957,9 +2981,11 @@ static int macb_probe(struct platform_device *pdev)
         phy_node =  of_get_next_available_child(np, NULL);
         if (phy_node) {
                 int gpio = of_get_named_gpio(phy_node, "reset-gpios", 0);
-                if (gpio_is_valid(gpio))
+
+                if (gpio_is_valid(gpio)) {
                         bp->reset_gpio = gpio_to_desc(gpio);
-                gpiod_set_value(bp->reset_gpio, GPIOD_OUT_HIGH);
+                        gpiod_direction_output(bp->reset_gpio, 1);
+                }
         }
         of_node_put(phy_node);
 
@@ -3029,7 +3055,8 @@ static int macb_remove(struct platform_device *pdev)
                 mdiobus_free(bp->mii_bus);
 
                 /* Shutdown the PHY if there is a GPIO reset */
-                gpiod_set_value(bp->reset_gpio, GPIOD_OUT_LOW);
+                if (bp->reset_gpio)
+                        gpiod_set_value(bp->reset_gpio, 0);
 
                 unregister_netdev(dev);
                 clk_disable_unprepare(bp->tx_clk);
diff --git a/drivers/net/ethernet/chelsio/Kconfig b/drivers/net/ethernet/chelsio/Kconfig
index 4d187f22c48b..4686a85a8a22 100644
--- a/drivers/net/ethernet/chelsio/Kconfig
+++ b/drivers/net/ethernet/chelsio/Kconfig
@@ -96,6 +96,17 @@ config CHELSIO_T4_DCB
 
           If unsure, say N.
 
+config CHELSIO_T4_UWIRE
+        bool "Unified Wire Support for Chelsio T5 cards"
+        default n
+        depends on CHELSIO_T4
+        ---help---
+          Enable unified-wire offload features.
+          Say Y here if you want to enable unified-wire over Ethernet
+          in the driver.
+
+          If unsure, say N.
+
 config CHELSIO_T4_FCOE
         bool "Fibre Channel over Ethernet (FCoE) Support for Chelsio T5 cards"
         default n
diff --git a/drivers/net/ethernet/chelsio/cxgb4/Makefile b/drivers/net/ethernet/chelsio/cxgb4/Makefile
index ace0ab98d0f1..85c92821b239 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/Makefile
+++ b/drivers/net/ethernet/chelsio/cxgb4/Makefile
@@ -7,4 +7,5 @@ obj-$(CONFIG_CHELSIO_T4) += cxgb4.o
 cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o
 cxgb4-$(CONFIG_CHELSIO_T4_DCB) +=  cxgb4_dcb.o
 cxgb4-$(CONFIG_CHELSIO_T4_FCOE) +=  cxgb4_fcoe.o
+cxgb4-$(CONFIG_CHELSIO_T4_UWIRE) +=  cxgb4_ppm.o
 cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index 1dac6c6111bf..984a3cc26f86 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -404,6 +404,9 @@ enum {
         MAX_CTRL_QUEUES = NCHAN,      /* # of control Tx queues */
         MAX_RDMA_QUEUES = NCHAN,      /* # of streaming RDMA Rx queues */
         MAX_RDMA_CIQS = 32,        /* # of  RDMA concentrator IQs */
+
+        /* # of streaming iSCSIT Rx queues */
+        MAX_ISCSIT_QUEUES = MAX_OFLD_QSETS,
 };
 
 enum {
@@ -420,8 +423,8 @@ enum {
 enum {
         INGQ_EXTRAS = 2,        /* firmware event queue and */
                                 /*   forwarded interrupts */
-        MAX_INGQ = MAX_ETH_QSETS + MAX_OFLD_QSETS + MAX_RDMA_QUEUES
-                   + MAX_RDMA_CIQS + INGQ_EXTRAS,
+        MAX_INGQ = MAX_ETH_QSETS + MAX_OFLD_QSETS + MAX_RDMA_QUEUES +
+                   MAX_RDMA_CIQS + MAX_ISCSIT_QUEUES + INGQ_EXTRAS,
 };
 
 struct adapter;
@@ -508,6 +511,15 @@ struct pkt_gl {
 
 typedef int (*rspq_handler_t)(struct sge_rspq *q, const __be64 *rsp,
                               const struct pkt_gl *gl);
+typedef void (*rspq_flush_handler_t)(struct sge_rspq *q);
+/* LRO related declarations for ULD */
+struct t4_lro_mgr {
+#define MAX_LRO_SESSIONS                64
+        u8 lro_session_cnt;         /* # of sessions to aggregate */
+        unsigned long lro_pkts;     /* # of LRO super packets */
+        unsigned long lro_merged;   /* # of wire packets merged by LRO */
+        struct sk_buff_head lroq;   /* list of aggregated sessions */
+};
 
 struct sge_rspq {                   /* state for an SGE response queue */
         struct napi_struct napi;
@@ -532,6 +544,8 @@ struct sge_rspq {                   /* state for an SGE response queue */
         struct adapter *adap;
         struct net_device *netdev;  /* associated net device */
         rspq_handler_t handler;
+        rspq_flush_handler_t flush_handler;
+        struct t4_lro_mgr lro_mgr;
 #ifdef CONFIG_NET_RX_BUSY_POLL
 #define CXGB_POLL_STATE_IDLE            0
 #define CXGB_POLL_STATE_NAPI            BIT(0) /* NAPI owns this poll */
@@ -641,6 +655,7 @@ struct sge {
 
         struct sge_eth_rxq ethrxq[MAX_ETH_QSETS];
         struct sge_ofld_rxq iscsirxq[MAX_OFLD_QSETS];
+        struct sge_ofld_rxq iscsitrxq[MAX_ISCSIT_QUEUES];
         struct sge_ofld_rxq rdmarxq[MAX_RDMA_QUEUES];
         struct sge_ofld_rxq rdmaciq[MAX_RDMA_CIQS];
         struct sge_rspq fw_evtq ____cacheline_aligned_in_smp;
@@ -652,9 +667,11 @@ struct sge {
         u16 ethqsets;               /* # of active Ethernet queue sets */
         u16 ethtxq_rover;           /* Tx queue to clean up next */
         u16 iscsiqsets;              /* # of active iSCSI queue sets */
+        u16 niscsitq;               /* # of available iSCST Rx queues */
         u16 rdmaqs;                 /* # of available RDMA Rx queues */
         u16 rdmaciqs;               /* # of available RDMA concentrator IQs */
         u16 iscsi_rxq[MAX_OFLD_QSETS];
+        u16 iscsit_rxq[MAX_ISCSIT_QUEUES];
         u16 rdma_rxq[MAX_RDMA_QUEUES];
         u16 rdma_ciq[MAX_RDMA_CIQS];
         u16 timer_val[SGE_NTIMERS];
@@ -681,6 +698,7 @@ struct sge {
 
 #define for_each_ethrxq(sge, i) for (i = 0; i < (sge)->ethqsets; i++)
 #define for_each_iscsirxq(sge, i) for (i = 0; i < (sge)->iscsiqsets; i++)
+#define for_each_iscsitrxq(sge, i) for (i = 0; i < (sge)->niscsitq; i++)
 #define for_each_rdmarxq(sge, i) for (i = 0; i < (sge)->rdmaqs; i++)
 #define for_each_rdmaciq(sge, i) for (i = 0; i < (sge)->rdmaciqs; i++)
 
@@ -747,6 +765,8 @@ struct adapter {
         struct list_head rcu_node;
         struct list_head mac_hlist; /* list of MAC addresses in MPS Hash */
 
+        void *iscsi_ppm;
+
         struct tid_info tids;
         void **tid_release_head;
         spinlock_t tid_release_lock;
@@ -1113,7 +1133,8 @@ int t4_mgmt_tx(struct adapter *adap, struct sk_buff *skb);
 int t4_ofld_send(struct adapter *adap, struct sk_buff *skb);
 int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
                      struct net_device *dev, int intr_idx,
-                     struct sge_fl *fl, rspq_handler_t hnd, int cong);
+                     struct sge_fl *fl, rspq_handler_t hnd,
+                     rspq_flush_handler_t flush_handler, int cong);
 int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq,
                          struct net_device *dev, struct netdev_queue *netdevq,
                          unsigned int iqid);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
index e6a4072b494b..0bb41e9b9b1c 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c
@@ -2334,12 +2334,14 @@ static int sge_qinfo_show(struct seq_file *seq, void *v)
         struct adapter *adap = seq->private;
         int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4);
         int iscsi_entries = DIV_ROUND_UP(adap->sge.iscsiqsets, 4);
+        int iscsit_entries = DIV_ROUND_UP(adap->sge.niscsitq, 4);
         int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4);
         int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4);
         int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4);
         int i, r = (uintptr_t)v - 1;
         int iscsi_idx = r - eth_entries;
-        int rdma_idx = iscsi_idx - iscsi_entries;
+        int iscsit_idx = iscsi_idx - iscsi_entries;
+        int rdma_idx = iscsit_idx - iscsit_entries;
         int ciq_idx = rdma_idx - rdma_entries;
         int ctrl_idx =  ciq_idx - ciq_entries;
         int fq_idx =  ctrl_idx - ctrl_entries;
@@ -2453,6 +2455,35 @@ do { \
                 RL("FLLow:", fl.low);
                 RL("FLStarving:", fl.starving);
 
+        } else if (iscsit_idx < iscsit_entries) {
+                const struct sge_ofld_rxq *rx =
+                        &adap->sge.iscsitrxq[iscsit_idx * 4];
+                int n = min(4, adap->sge.niscsitq - 4 * iscsit_idx);
+
+                S("QType:", "iSCSIT");
+                R("RspQ ID:", rspq.abs_id);
+                R("RspQ size:", rspq.size);
+                R("RspQE size:", rspq.iqe_len);
+                R("RspQ CIDX:", rspq.cidx);
+                R("RspQ Gen:", rspq.gen);
+                S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
+                S3("u", "Intr pktcnt:",
+                   adap->sge.counter_val[rx[i].rspq.pktcnt_idx]);
+                R("FL ID:", fl.cntxt_id);
+                R("FL size:", fl.size - 8);
+                R("FL pend:", fl.pend_cred);
+                R("FL avail:", fl.avail);
+                R("FL PIDX:", fl.pidx);
+                R("FL CIDX:", fl.cidx);
+                RL("RxPackets:", stats.pkts);
+                RL("RxImmPkts:", stats.imm);
+                RL("RxNoMem:", stats.nomem);
+                RL("FLAllocErr:", fl.alloc_failed);
+                RL("FLLrgAlcErr:", fl.large_alloc_failed);
+                RL("FLMapErr:", fl.mapping_err);
+                RL("FLLow:", fl.low);
+                RL("FLStarving:", fl.starving);
+
         } else if (rdma_idx < rdma_entries) {
                 const struct sge_ofld_rxq *rx =
                                 &adap->sge.rdmarxq[rdma_idx * 4];
@@ -2543,6 +2574,7 @@ static int sge_queue_entries(const struct adapter *adap)
 {
         return DIV_ROUND_UP(adap->sge.ethqsets, 4) +
                DIV_ROUND_UP(adap->sge.iscsiqsets, 4) +
+               DIV_ROUND_UP(adap->sge.niscsitq, 4) +
                DIV_ROUND_UP(adap->sge.rdmaqs, 4) +
                DIV_ROUND_UP(adap->sge.rdmaciqs, 4) +
                DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index adad73f7c8cd..a1e329ec24cd 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -168,7 +168,8 @@ MODULE_PARM_DESC(force_init, "Forcibly become Master PF and initialize adapter,"
 static int dflt_msg_enable = DFLT_MSG_ENABLE;
 
 module_param(dflt_msg_enable, int, 0644);
-MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T4 default message enable bitmap");
+MODULE_PARM_DESC(dflt_msg_enable, "Chelsio T4 default message enable bitmap, "
+                 "deprecated parameter");
 
 /*
  * The driver uses the best interrupt scheme available on a platform in the
@@ -227,7 +228,7 @@ static DEFINE_MUTEX(uld_mutex);
 static LIST_HEAD(adap_rcu_list);
 static DEFINE_SPINLOCK(adap_rcu_lock);
 static struct cxgb4_uld_info ulds[CXGB4_ULD_MAX];
-static const char *uld_str[] = { "RDMA", "iSCSI" };
+static const char *const uld_str[] = { "RDMA", "iSCSI", "iSCSIT" };
 
 static void link_report(struct net_device *dev)
 {
@@ -664,6 +665,13 @@ out:
         return 0;
 }
 
+/* Flush the aggregated lro sessions */
+static void uldrx_flush_handler(struct sge_rspq *q)
+{
+        if (ulds[q->uld].lro_flush)
+                ulds[q->uld].lro_flush(&q->lro_mgr);
+}
+
 /**
  *      uldrx_handler - response queue handler for ULD queues
  *      @q: the response queue that received the packet
@@ -677,6 +685,7 @@ static int uldrx_handler(struct sge_rspq *q, const __be64 *rsp,
                          const struct pkt_gl *gl)
 {
         struct sge_ofld_rxq *rxq = container_of(q, struct sge_ofld_rxq, rspq);
+        int ret;
 
         /* FW can send CPLs encapsulated in a CPL_FW4_MSG.
          */
@@ -684,10 +693,19 @@ static int uldrx_handler(struct sge_rspq *q, const __be64 *rsp,
             ((const struct cpl_fw4_msg *)(rsp + 1))->type == FW_TYPE_RSSCPL)
                 rsp += 2;
 
-        if (ulds[q->uld].rx_handler(q->adap->uld_handle[q->uld], rsp, gl)) {
+        if (q->flush_handler)
+                ret = ulds[q->uld].lro_rx_handler(q->adap->uld_handle[q->uld],
+                                                  rsp, gl, &q->lro_mgr,
+                                                  &q->napi);
+        else
+                ret = ulds[q->uld].rx_handler(q->adap->uld_handle[q->uld],
+                                              rsp, gl);
+
+        if (ret) {
                 rxq->stats.nomem++;
                 return -1;
         }
+
         if (gl == NULL)
                 rxq->stats.imm++;
         else if (gl == CXGB4_MSG_AN)
@@ -754,6 +772,10 @@ static void name_msix_vecs(struct adapter *adap)
                 snprintf(adap->msix_info[msi_idx++].desc, n, "%s-iscsi%d",
                          adap->port[0]->name, i);
 
+        for_each_iscsitrxq(&adap->sge, i)
+                snprintf(adap->msix_info[msi_idx++].desc, n, "%s-iSCSIT%d",
+                         adap->port[0]->name, i);
+
         for_each_rdmarxq(&adap->sge, i)
                 snprintf(adap->msix_info[msi_idx++].desc, n, "%s-rdma%d",
                          adap->port[0]->name, i);
@@ -767,6 +789,7 @@ static int request_msix_queue_irqs(struct adapter *adap)
 {
         struct sge *s = &adap->sge;
         int err, ethqidx, iscsiqidx = 0, rdmaqidx = 0, rdmaciqqidx = 0;
+        int iscsitqidx = 0;
         int msi_index = 2;
 
         err = request_irq(adap->msix_info[1].vec, t4_sge_intr_msix, 0,
@@ -792,6 +815,15 @@ static int request_msix_queue_irqs(struct adapter *adap)
                         goto unwind;
                 msi_index++;
         }
+        for_each_iscsitrxq(s, iscsitqidx) {
+                err = request_irq(adap->msix_info[msi_index].vec,
+                                  t4_sge_intr_msix, 0,
+                                  adap->msix_info[msi_index].desc,
+                                  &s->iscsitrxq[iscsitqidx].rspq);
+                if (err)
+                        goto unwind;
+                msi_index++;
+        }
         for_each_rdmarxq(s, rdmaqidx) {
                 err = request_irq(adap->msix_info[msi_index].vec,
                                   t4_sge_intr_msix, 0,
@@ -819,6 +851,9 @@ unwind:
         while (--rdmaqidx >= 0)
                 free_irq(adap->msix_info[--msi_index].vec,
                          &s->rdmarxq[rdmaqidx].rspq);
+        while (--iscsitqidx >= 0)
+                free_irq(adap->msix_info[--msi_index].vec,
+                         &s->iscsitrxq[iscsitqidx].rspq);
         while (--iscsiqidx >= 0)
                 free_irq(adap->msix_info[--msi_index].vec,
                          &s->iscsirxq[iscsiqidx].rspq);
@@ -840,6 +875,9 @@ static void free_msix_queue_irqs(struct adapter *adap)
         for_each_iscsirxq(s, i)
                 free_irq(adap->msix_info[msi_index++].vec,
                          &s->iscsirxq[i].rspq);
+        for_each_iscsitrxq(s, i)
+                free_irq(adap->msix_info[msi_index++].vec,
+                         &s->iscsitrxq[i].rspq);
         for_each_rdmarxq(s, i)
                 free_irq(adap->msix_info[msi_index++].vec, &s->rdmarxq[i].rspq);
         for_each_rdmaciq(s, i)
@@ -984,7 +1022,7 @@ static void enable_rx(struct adapter *adap)
 
 static int alloc_ofld_rxqs(struct adapter *adap, struct sge_ofld_rxq *q,
                            unsigned int nq, unsigned int per_chan, int msi_idx,
-                           u16 *ids)
+                           u16 *ids, bool lro)
 {
         int i, err;
 
@@ -994,7 +1032,9 @@ static int alloc_ofld_rxqs(struct adapter *adap, struct sge_ofld_rxq *q,
                 err = t4_sge_alloc_rxq(adap, &q->rspq, false,
                                        adap->port[i / per_chan],
                                        msi_idx, q->fl.size ? &q->fl : NULL,
-                                       uldrx_handler, 0);
+                                       uldrx_handler,
+                                       lro ? uldrx_flush_handler : NULL,
+                                       0);
                 if (err)
                         return err;
                 memset(&q->stats, 0, sizeof(q->stats));
@@ -1024,7 +1064,7 @@ static int setup_sge_queues(struct adapter *adap)
                 msi_idx = 1;         /* vector 0 is for non-queue interrupts */
         else {
                 err = t4_sge_alloc_rxq(adap, &s->intrq, false, adap->port[0], 0,
-                                       NULL, NULL, -1);
+                                       NULL, NULL, NULL, -1);
                 if (err)
                         return err;
                 msi_idx = -((int)s->intrq.abs_id + 1);
@@ -1044,7 +1084,7 @@ static int setup_sge_queues(struct adapter *adap)
          *    new/deleted queues.
          */
         err = t4_sge_alloc_rxq(adap, &s->fw_evtq, true, adap->port[0],
-                               msi_idx, NULL, fwevtq_handler, -1);
+                               msi_idx, NULL, fwevtq_handler, NULL, -1);
         if (err) {
 freeout:        t4_free_sge_resources(adap);
                 return err;
@@ -1062,6 +1102,7 @@ freeout:	t4_free_sge_resources(adap);
                         err = t4_sge_alloc_rxq(adap, &q->rspq, false, dev,
                                                msi_idx, &q->fl,
                                                t4_ethrx_handler,
+                                               NULL,
                                                t4_get_mps_bg_map(adap,
                                                                  pi->tx_chan));
                         if (err)
@@ -1087,18 +1128,19 @@ freeout:	t4_free_sge_resources(adap);
                         goto freeout;
         }
 
-#define ALLOC_OFLD_RXQS(firstq, nq, per_chan, ids) do { \
-        err = alloc_ofld_rxqs(adap, firstq, nq, per_chan, msi_idx, ids); \
+#define ALLOC_OFLD_RXQS(firstq, nq, per_chan, ids, lro) do { \
+        err = alloc_ofld_rxqs(adap, firstq, nq, per_chan, msi_idx, ids, lro); \
         if (err) \
                 goto freeout; \
         if (msi_idx > 0) \
                 msi_idx += nq; \
 } while (0)
 
-        ALLOC_OFLD_RXQS(s->iscsirxq, s->iscsiqsets, j, s->iscsi_rxq);
-        ALLOC_OFLD_RXQS(s->rdmarxq, s->rdmaqs, 1, s->rdma_rxq);
+        ALLOC_OFLD_RXQS(s->iscsirxq, s->iscsiqsets, j, s->iscsi_rxq, false);
+        ALLOC_OFLD_RXQS(s->iscsitrxq, s->niscsitq, j, s->iscsit_rxq, true);
+        ALLOC_OFLD_RXQS(s->rdmarxq, s->rdmaqs, 1, s->rdma_rxq, false);
         j = s->rdmaciqs / adap->params.nports; /* rdmaq queues per channel */
-        ALLOC_OFLD_RXQS(s->rdmaciq, s->rdmaciqs, j, s->rdma_ciq);
+        ALLOC_OFLD_RXQS(s->rdmaciq, s->rdmaciqs, j, s->rdma_ciq, false);
 
 #undef ALLOC_OFLD_RXQS
 
@@ -2430,6 +2472,9 @@ static void uld_attach(struct adapter *adap, unsigned int uld)
         } else if (uld == CXGB4_ULD_ISCSI) {
                 lli.rxq_ids = adap->sge.iscsi_rxq;
                 lli.nrxq = adap->sge.iscsiqsets;
+        } else if (uld == CXGB4_ULD_ISCSIT) {
+                lli.rxq_ids = adap->sge.iscsit_rxq;
+                lli.nrxq = adap->sge.niscsitq;
         }
         lli.ntxq = adap->sge.iscsiqsets;
         lli.nchan = adap->params.nports;
@@ -2437,6 +2482,10 @@ static void uld_attach(struct adapter *adap, unsigned int uld)
         lli.wr_cred = adap->params.ofldq_wr_cred;
         lli.adapter_type = adap->params.chip;
         lli.iscsi_iolen = MAXRXDATA_G(t4_read_reg(adap, TP_PARA_REG2_A));
+        lli.iscsi_tagmask = t4_read_reg(adap, ULP_RX_ISCSI_TAGMASK_A);
+        lli.iscsi_pgsz_order = t4_read_reg(adap, ULP_RX_ISCSI_PSZ_A);
+        lli.iscsi_llimit = t4_read_reg(adap, ULP_RX_ISCSI_LLIMIT_A);
+        lli.iscsi_ppm = &adap->iscsi_ppm;
         lli.cclk_ps = 1000000000 / adap->params.vpd.cclk;
         lli.udb_density = 1 << adap->params.sge.eq_qpp;
         lli.ucq_density = 1 << adap->params.sge.iq_qpp;
@@ -4336,6 +4385,9 @@ static void cfg_queues(struct adapter *adap)
                 s->rdmaciqs = (s->rdmaciqs / adap->params.nports) *
                                 adap->params.nports;
                 s->rdmaciqs = max_t(int, s->rdmaciqs, adap->params.nports);
+
+                if (!is_t4(adap->params.chip))
+                        s->niscsitq = s->iscsiqsets;
         }
 
         for (i = 0; i < ARRAY_SIZE(s->ethrxq); i++) {
@@ -4362,6 +4414,16 @@ static void cfg_queues(struct adapter *adap)
                 r->fl.size = 72;
         }
 
+        if (!is_t4(adap->params.chip)) {
+                for (i = 0; i < ARRAY_SIZE(s->iscsitrxq); i++) {
+                        struct sge_ofld_rxq *r = &s->iscsitrxq[i];
+
+                        init_rspq(adap, &r->rspq, 5, 1, 1024, 64);
+                        r->rspq.uld = CXGB4_ULD_ISCSIT;
+                        r->fl.size = 72;
+                }
+        }
+
         for (i = 0; i < ARRAY_SIZE(s->rdmarxq); i++) {
                 struct sge_ofld_rxq *r = &s->rdmarxq[i];
 
@@ -4436,9 +4498,13 @@ static int enable_msix(struct adapter *adap)
 
         want = s->max_ethqsets + EXTRA_VECS;
         if (is_offload(adap)) {
-                want += s->rdmaqs + s->rdmaciqs + s->iscsiqsets;
+                want += s->rdmaqs + s->rdmaciqs + s->iscsiqsets +
+                        s->niscsitq;
                 /* need nchan for each possible ULD */
-                ofld_need = 3 * nchan;
+                if (is_t4(adap->params.chip))
+                        ofld_need = 3 * nchan;
+                else
+                        ofld_need = 4 * nchan;
         }
 #ifdef CONFIG_CHELSIO_T4_DCB
         /* For Data Center Bridging we need 8 Ethernet TX Priority Queues for
@@ -4470,12 +4536,16 @@ static int enable_msix(struct adapter *adap)
                 if (allocated < want) {
                         s->rdmaqs = nchan;
                         s->rdmaciqs = nchan;
+
+                        if (!is_t4(adap->params.chip))
+                                s->niscsitq = nchan;
                 }
 
                 /* leftovers go to OFLD */
                 i = allocated - EXTRA_VECS - s->max_ethqsets -
-                    s->rdmaqs - s->rdmaciqs;
+                    s->rdmaqs - s->rdmaciqs - s->niscsitq;
                 s->iscsiqsets = (i / nchan) * nchan;  /* round down */
+
         }
         for (i = 0; i < allocated; ++i)
                 adap->msix_info[i].vec = entries[i].vector;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.c
new file mode 100644
index 000000000000..d88a7a7b2400
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.c
@@ -0,0 +1,464 @@
+/*
+ * cxgb4_ppm.c: Chelsio common library for T4/T5 iSCSI PagePod Manager
+ *
+ * Copyright (c) 2016 Chelsio Communications, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Written by: Karen Xie (kxie@chelsio.com)
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/debugfs.h>
+#include <linux/export.h>
+#include <linux/list.h>
+#include <linux/skbuff.h>
+#include <linux/pci.h>
+#include <linux/scatterlist.h>
+
+#include "cxgb4_ppm.h"
+
+/* Direct Data Placement -
+ * Directly place the iSCSI Data-In or Data-Out PDU's payload into
+ * pre-posted final destination host-memory buffers based on the
+ * Initiator Task Tag (ITT) in Data-In or Target Task Tag (TTT)
+ * in Data-Out PDUs. The host memory address is programmed into
+ * h/w in the format of pagepod entries. The location of the
+ * pagepod entry is encoded into ddp tag which is used as the base
+ * for ITT/TTT.
+ */
+
+/* Direct-Data Placement page size adjustment
+ */
+int cxgbi_ppm_find_page_index(struct cxgbi_ppm *ppm, unsigned long pgsz)
+{
+        struct cxgbi_tag_format *tformat = &ppm->tformat;
+        int i;
+
+        for (i = 0; i < DDP_PGIDX_MAX; i++) {
+                if (pgsz == 1UL << (DDP_PGSZ_BASE_SHIFT +
+                                         tformat->pgsz_order[i])) {
+                        pr_debug("%s: %s ppm, pgsz %lu -> idx %d.\n",
+                                 __func__, ppm->ndev->name, pgsz, i);
+                        return i;
+                }
+        }
+        pr_info("ippm: ddp page size %lu not supported.\n", pgsz);
+        return DDP_PGIDX_MAX;
+}
+
+/* DDP setup & teardown
+ */
+static int ppm_find_unused_entries(unsigned long *bmap,
+                                   unsigned int max_ppods,
+                                   unsigned int start,
+                                   unsigned int nr,
+                                   unsigned int align_mask)
+{
+        unsigned long i;
+
+        i = bitmap_find_next_zero_area(bmap, max_ppods, start, nr, align_mask);
+
+        if (unlikely(i >= max_ppods) && (start > nr))
+                i = bitmap_find_next_zero_area(bmap, max_ppods, 0, start - 1,
+                                               align_mask);
+        if (unlikely(i >= max_ppods))
+                return -ENOSPC;
+
+        bitmap_set(bmap, i, nr);
+        return (int)i;
+}
+
+static void ppm_mark_entries(struct cxgbi_ppm *ppm, int i, int count,
+                             unsigned long caller_data)
+{
+        struct cxgbi_ppod_data *pdata = ppm->ppod_data + i;
+
+        pdata->caller_data = caller_data;
+        pdata->npods = count;
+
+        if (pdata->color == ((1 << PPOD_IDX_SHIFT) - 1))
+                pdata->color = 0;
+        else
+                pdata->color++;
+}
+
+static int ppm_get_cpu_entries(struct cxgbi_ppm *ppm, unsigned int count,
+                               unsigned long caller_data)
+{
+        struct cxgbi_ppm_pool *pool;
+        unsigned int cpu;
+        int i;
+
+        cpu = get_cpu();
+        pool = per_cpu_ptr(ppm->pool, cpu);
+        spin_lock_bh(&pool->lock);
+        put_cpu();
+
+        i = ppm_find_unused_entries(pool->bmap, ppm->pool_index_max,
+                                    pool->next, count, 0);
+        if (i < 0) {
+                pool->next = 0;
+                spin_unlock_bh(&pool->lock);
+                return -ENOSPC;
+        }
+
+        pool->next = i + count;
+        if (pool->next >= ppm->pool_index_max)
+                pool->next = 0;
+
+        spin_unlock_bh(&pool->lock);
+
+        pr_debug("%s: cpu %u, idx %d + %d (%d), next %u.\n",
+                 __func__, cpu, i, count, i + cpu * ppm->pool_index_max,
+                pool->next);
+
+        i += cpu * ppm->pool_index_max;
+        ppm_mark_entries(ppm, i, count, caller_data);
+
+        return i;
+}
+
+static int ppm_get_entries(struct cxgbi_ppm *ppm, unsigned int count,
+                           unsigned long caller_data)
+{
+        int i;
+
+        spin_lock_bh(&ppm->map_lock);
+        i = ppm_find_unused_entries(ppm->ppod_bmap, ppm->bmap_index_max,
+                                    ppm->next, count, 0);
+        if (i < 0) {
+                ppm->next = 0;
+                spin_unlock_bh(&ppm->map_lock);
+                pr_debug("ippm: NO suitable entries %u available.\n",
+                         count);
+                return -ENOSPC;
+        }
+
+        ppm->next = i + count;
+        if (ppm->next >= ppm->bmap_index_max)
+                ppm->next = 0;
+
+        spin_unlock_bh(&ppm->map_lock);
+
+        pr_debug("%s: idx %d + %d (%d), next %u, caller_data 0x%lx.\n",
+                 __func__, i, count, i + ppm->pool_rsvd, ppm->next,
+                 caller_data);
+
+        i += ppm->pool_rsvd;
+        ppm_mark_entries(ppm, i, count, caller_data);
+
+        return i;
+}
+
+static void ppm_unmark_entries(struct cxgbi_ppm *ppm, int i, int count)
+{
+        pr_debug("%s: idx %d + %d.\n", __func__, i, count);
+
+        if (i < ppm->pool_rsvd) {
+                unsigned int cpu;
+                struct cxgbi_ppm_pool *pool;
+
+                cpu = i / ppm->pool_index_max;
+                i %= ppm->pool_index_max;
+
+                pool = per_cpu_ptr(ppm->pool, cpu);
+                spin_lock_bh(&pool->lock);
+                bitmap_clear(pool->bmap, i, count);
+
+                if (i < pool->next)
+                        pool->next = i;
+                spin_unlock_bh(&pool->lock);
+
+                pr_debug("%s: cpu %u, idx %d, next %u.\n",
+                         __func__, cpu, i, pool->next);
+        } else {
+                spin_lock_bh(&ppm->map_lock);
+
+                i -= ppm->pool_rsvd;
+                bitmap_clear(ppm->ppod_bmap, i, count);
+
+                if (i < ppm->next)
+                        ppm->next = i;
+                spin_unlock_bh(&ppm->map_lock);
+
+                pr_debug("%s: idx %d, next %u.\n", __func__, i, ppm->next);
+        }
+}
+
+void cxgbi_ppm_ppod_release(struct cxgbi_ppm *ppm, u32 idx)
+{
+        struct cxgbi_ppod_data *pdata;
+
+        if (idx >= ppm->ppmax) {
+                pr_warn("ippm: idx too big %u > %u.\n", idx, ppm->ppmax);
+                return;
+        }
+
+        pdata = ppm->ppod_data + idx;
+        if (!pdata->npods) {
+                pr_warn("ippm: idx %u, npods 0.\n", idx);
+                return;
+        }
+
+        pr_debug("release idx %u, npods %u.\n", idx, pdata->npods);
+        ppm_unmark_entries(ppm, idx, pdata->npods);
+}
+EXPORT_SYMBOL(cxgbi_ppm_ppod_release);
+
+int cxgbi_ppm_ppods_reserve(struct cxgbi_ppm *ppm, unsigned short nr_pages,
+                            u32 per_tag_pg_idx, u32 *ppod_idx,
+                            u32 *ddp_tag, unsigned long caller_data)
+{
+        struct cxgbi_ppod_data *pdata;
+        unsigned int npods;
+        int idx = -1;
+        unsigned int hwidx;
+        u32 tag;
+
+        npods = (nr_pages + PPOD_PAGES_MAX - 1) >> PPOD_PAGES_SHIFT;
+        if (!npods) {
+                pr_warn("%s: pages %u -> npods %u, full.\n",
+                        __func__, nr_pages, npods);
+                return -EINVAL;
+        }
+
+        /* grab from cpu pool first */
+        idx = ppm_get_cpu_entries(ppm, npods, caller_data);
+        /* try the general pool */
+        if (idx < 0)
+                idx = ppm_get_entries(ppm, npods, caller_data);
+        if (idx < 0) {
+                pr_debug("ippm: pages %u, nospc %u, nxt %u, 0x%lx.\n",
+                         nr_pages, npods, ppm->next, caller_data);
+                return idx;
+        }
+
+        pdata = ppm->ppod_data + idx;
+        hwidx = ppm->base_idx + idx;
+
+        tag = cxgbi_ppm_make_ddp_tag(hwidx, pdata->color);
+
+        if (per_tag_pg_idx)
+                tag |= (per_tag_pg_idx << 30) & 0xC0000000;
+
+        *ppod_idx = idx;
+        *ddp_tag = tag;
+
+        pr_debug("ippm: sg %u, tag 0x%x(%u,%u), data 0x%lx.\n",
+                 nr_pages, tag, idx, npods, caller_data);
+
+        return npods;
+}
+EXPORT_SYMBOL(cxgbi_ppm_ppods_reserve);
+
+void cxgbi_ppm_make_ppod_hdr(struct cxgbi_ppm *ppm, u32 tag,
+                             unsigned int tid, unsigned int offset,
+                             unsigned int length,
+                             struct cxgbi_pagepod_hdr *hdr)
+{
+        /* The ddp tag in pagepod should be with bit 31:30 set to 0.
+         * The ddp Tag on the wire should be with non-zero 31:30 to the peer
+         */
+        tag &= 0x3FFFFFFF;
+
+        hdr->vld_tid = htonl(PPOD_VALID_FLAG | PPOD_TID(tid));
+
+        hdr->rsvd = 0;
+        hdr->pgsz_tag_clr = htonl(tag & ppm->tformat.idx_clr_mask);
+        hdr->max_offset = htonl(length);
+        hdr->page_offset = htonl(offset);
+
+        pr_debug("ippm: tag 0x%x, tid 0x%x, xfer %u, off %u.\n",
+                 tag, tid, length, offset);
+}
+EXPORT_SYMBOL(cxgbi_ppm_make_ppod_hdr);
+
+static void ppm_free(struct cxgbi_ppm *ppm)
+{
+        vfree(ppm);
+}
+
+static void ppm_destroy(struct kref *kref)
+{
+        struct cxgbi_ppm *ppm = container_of(kref,
+                                             struct cxgbi_ppm,
+                                             refcnt);
+        pr_info("ippm: kref 0, destroy %s ppm 0x%p.\n",
+                ppm->ndev->name, ppm);
+
+        *ppm->ppm_pp = NULL;
+
+        free_percpu(ppm->pool);
+        ppm_free(ppm);
+}
+
+int cxgbi_ppm_release(struct cxgbi_ppm *ppm)
+{
+        if (ppm) {
+                int rv;
+
+                rv = kref_put(&ppm->refcnt, ppm_destroy);
+                return rv;
+        }
+        return 1;
+}
+
+static struct cxgbi_ppm_pool *ppm_alloc_cpu_pool(unsigned int *total,
+                                                 unsigned int *pcpu_ppmax)
+{
+        struct cxgbi_ppm_pool *pools;
+        unsigned int ppmax = (*total) / num_possible_cpus();
+        unsigned int max = (PCPU_MIN_UNIT_SIZE - sizeof(*pools)) << 3;
+        unsigned int bmap;
+        unsigned int alloc_sz;
+        unsigned int count = 0;
+        unsigned int cpu;
+
+        /* make sure per cpu pool fits into PCPU_MIN_UNIT_SIZE */
+        if (ppmax > max)
+                ppmax = max;
+
+        /* pool size must be multiple of unsigned long */
+        bmap = BITS_TO_LONGS(ppmax);
+        ppmax = (bmap * sizeof(unsigned long)) << 3;
+
+        alloc_sz = sizeof(*pools) + sizeof(unsigned long) * bmap;
+        pools = __alloc_percpu(alloc_sz, __alignof__(struct cxgbi_ppm_pool));
+
+        if (!pools)
+                return NULL;
+
+        for_each_possible_cpu(cpu) {
+                struct cxgbi_ppm_pool *ppool = per_cpu_ptr(pools, cpu);
+
+                memset(ppool, 0, alloc_sz);
+                spin_lock_init(&ppool->lock);
+                count += ppmax;
+        }
+
+        *total = count;
+        *pcpu_ppmax = ppmax;
+
+        return pools;
+}
+
+int cxgbi_ppm_init(void **ppm_pp, struct net_device *ndev,
+                   struct pci_dev *pdev, void *lldev,
+                   struct cxgbi_tag_format *tformat,
+                   unsigned int ppmax,
+                   unsigned int llimit,
+                   unsigned int start,
+                   unsigned int reserve_factor)
+{
+        struct cxgbi_ppm *ppm = (struct cxgbi_ppm *)(*ppm_pp);
+        struct cxgbi_ppm_pool *pool = NULL;
+        unsigned int ppmax_pool = 0;
+        unsigned int pool_index_max = 0;
+        unsigned int alloc_sz;
+        unsigned int ppod_bmap_size;
+
+        if (ppm) {
+                pr_info("ippm: %s, ppm 0x%p,0x%p already initialized, %u/%u.\n",
+                        ndev->name, ppm_pp, ppm, ppm->ppmax, ppmax);
+                kref_get(&ppm->refcnt);
+                return 1;
+        }
+
+        if (reserve_factor) {
+                ppmax_pool = ppmax / reserve_factor;
+                pool = ppm_alloc_cpu_pool(&ppmax_pool, &pool_index_max);
+
+                pr_debug("%s: ppmax %u, cpu total %u, per cpu %u.\n",
+                         ndev->name, ppmax, ppmax_pool, pool_index_max);
+        }
+
+        ppod_bmap_size = BITS_TO_LONGS(ppmax - ppmax_pool);
+        alloc_sz = sizeof(struct cxgbi_ppm) +
+                        ppmax * (sizeof(struct cxgbi_ppod_data)) +
+                        ppod_bmap_size * sizeof(unsigned long);
+
+        ppm = vmalloc(alloc_sz);
+        if (!ppm)
+                goto release_ppm_pool;
+
+        memset(ppm, 0, alloc_sz);
+
+        ppm->ppod_bmap = (unsigned long *)(&ppm->ppod_data[ppmax]);
+
+        if ((ppod_bmap_size >> 3) > (ppmax - ppmax_pool)) {
+                unsigned int start = ppmax - ppmax_pool;
+                unsigned int end = ppod_bmap_size >> 3;
+
+                bitmap_set(ppm->ppod_bmap, ppmax, end - start);
+                pr_info("%s: %u - %u < %u * 8, mask extra bits %u, %u.\n",
+                        __func__, ppmax, ppmax_pool, ppod_bmap_size, start,
+                        end);
+        }
+
+        spin_lock_init(&ppm->map_lock);
+        kref_init(&ppm->refcnt);
+
+        memcpy(&ppm->tformat, tformat, sizeof(struct cxgbi_tag_format));
+
+        ppm->ppm_pp = ppm_pp;
+        ppm->ndev = ndev;
+        ppm->pdev = pdev;
+        ppm->lldev = lldev;
+        ppm->ppmax = ppmax;
+        ppm->next = 0;
+        ppm->llimit = llimit;
+        ppm->base_idx = start > llimit ?
+                        (start - llimit + 1) >> PPOD_SIZE_SHIFT : 0;
+        ppm->bmap_index_max = ppmax - ppmax_pool;
+
+        ppm->pool = pool;
+        ppm->pool_rsvd = ppmax_pool;
+        ppm->pool_index_max = pool_index_max;
+
+        /* check one more time */
+        if (*ppm_pp) {
+                ppm_free(ppm);
+                ppm = (struct cxgbi_ppm *)(*ppm_pp);
+
+                pr_info("ippm: %s, ppm 0x%p,0x%p already initialized, %u/%u.\n",
+                        ndev->name, ppm_pp, *ppm_pp, ppm->ppmax, ppmax);
+
+                kref_get(&ppm->refcnt);
+                return 1;
+        }
+        *ppm_pp = ppm;
+
+        ppm->tformat.pgsz_idx_dflt = cxgbi_ppm_find_page_index(ppm, PAGE_SIZE);
+
+        pr_info("ippm %s: ppm 0x%p, 0x%p, base %u/%u, pg %lu,%u, rsvd %u,%u.\n",
+                ndev->name, ppm_pp, ppm, ppm->base_idx, ppm->ppmax, PAGE_SIZE,
+                ppm->tformat.pgsz_idx_dflt, ppm->pool_rsvd,
+                ppm->pool_index_max);
+
+        return 0;
+
+release_ppm_pool:
+        free_percpu(pool);
+        return -ENOMEM;
+}
+EXPORT_SYMBOL(cxgbi_ppm_init);
+
+unsigned int cxgbi_tagmask_set(unsigned int ppmax)
+{
+        unsigned int bits = fls(ppmax);
+
+        if (bits > PPOD_IDX_MAX_SIZE)
+                bits = PPOD_IDX_MAX_SIZE;
+
+        pr_info("ippm: ppmax %u/0x%x -> bits %u, tagmask 0x%x.\n",
+                ppmax, ppmax, bits, 1 << (bits + PPOD_IDX_SHIFT));
+
+        return 1 << (bits + PPOD_IDX_SHIFT);
+}
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.h
new file mode 100644
index 000000000000..d48732673b75
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ppm.h
@@ -0,0 +1,310 @@
+/*
+ * cxgb4_ppm.h: Chelsio common library for T4/T5 iSCSI ddp operation
+ *
+ * Copyright (c) 2016 Chelsio Communications, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Written by: Karen Xie (kxie@chelsio.com)
+ */
+
+#ifndef __CXGB4PPM_H__
+#define __CXGB4PPM_H__
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/debugfs.h>
+#include <linux/list.h>
+#include <linux/netdevice.h>
+#include <linux/scatterlist.h>
+#include <linux/skbuff.h>
+#include <linux/vmalloc.h>
+#include <linux/bitmap.h>
+
+struct cxgbi_pagepod_hdr {
+        u32 vld_tid;
+        u32 pgsz_tag_clr;
+        u32 max_offset;
+        u32 page_offset;
+        u64 rsvd;
+};
+
+#define PPOD_PAGES_MAX                  4
+struct cxgbi_pagepod {
+        struct cxgbi_pagepod_hdr hdr;
+        u64 addr[PPOD_PAGES_MAX + 1];
+};
+
+/* ddp tag format
+ * for a 32-bit tag:
+ * bit #
+ * 31 .....   .....  0
+ *     X   Y...Y Z...Z, where
+ *     ^   ^^^^^ ^^^^
+ *     |   |      |____ when ddp bit = 0: color bits
+ *     |   |
+ *     |   |____ when ddp bit = 0: idx into the ddp memory region
+ *     |
+ *     |____ ddp bit: 0 - ddp tag, 1 - non-ddp tag
+ *
+ *  [page selector:2] [sw/free bits] [0] [idx] [color:6]
+ */
+
+#define DDP_PGIDX_MAX           4
+#define DDP_PGSZ_BASE_SHIFT     12      /* base page 4K */
+
+struct cxgbi_task_tag_info {
+        unsigned char flags;
+#define CXGBI_PPOD_INFO_FLAG_VALID      0x1
+#define CXGBI_PPOD_INFO_FLAG_MAPPED     0x2
+        unsigned char cid;
+        unsigned short pg_shift;
+        unsigned int npods;
+        unsigned int idx;
+        unsigned int tag;
+        struct cxgbi_pagepod_hdr hdr;
+        int nents;
+        int nr_pages;
+        struct scatterlist *sgl;
+};
+
+struct cxgbi_tag_format {
+        unsigned char pgsz_order[DDP_PGIDX_MAX];
+        unsigned char pgsz_idx_dflt;
+        unsigned char free_bits:4;
+        unsigned char color_bits:4;
+        unsigned char idx_bits;
+        unsigned char rsvd_bits;
+        unsigned int  no_ddp_mask;
+        unsigned int  idx_mask;
+        unsigned int  color_mask;
+        unsigned int  idx_clr_mask;
+        unsigned int  rsvd_mask;
+};
+
+struct cxgbi_ppod_data {
+        unsigned char pg_idx:2;
+        unsigned char color:6;
+        unsigned char chan_id;
+        unsigned short npods;
+        unsigned long caller_data;
+};
+
+/* per cpu ppm pool */
+struct cxgbi_ppm_pool {
+        unsigned int base;              /* base index */
+        unsigned int next;              /* next possible free index */
+        spinlock_t lock;                /* ppm pool lock */
+        unsigned long bmap[0];
+} ____cacheline_aligned_in_smp;
+
+struct cxgbi_ppm {
+        struct kref refcnt;
+        struct net_device *ndev;        /* net_device, 1st port */
+        struct pci_dev *pdev;
+        void *lldev;
+        void **ppm_pp;
+        struct cxgbi_tag_format tformat;
+        unsigned int ppmax;
+        unsigned int llimit;
+        unsigned int base_idx;
+
+        unsigned int pool_rsvd;
+        unsigned int pool_index_max;
+        struct cxgbi_ppm_pool __percpu *pool;
+        /* map lock */
+        spinlock_t map_lock;            /* ppm map lock */
+        unsigned int bmap_index_max;
+        unsigned int next;
+        unsigned long *ppod_bmap;
+        struct cxgbi_ppod_data ppod_data[0];
+};
+
+#define DDP_THRESHOLD           512
+
+#define PPOD_PAGES_SHIFT        2       /*  4 pages per pod */
+
+#define IPPOD_SIZE               sizeof(struct cxgbi_pagepod)  /*  64 */
+#define PPOD_SIZE_SHIFT         6
+
+/* page pods are allocated in groups of this size (must be power of 2) */
+#define PPOD_CLUSTER_SIZE       16U
+
+#define ULPMEM_DSGL_MAX_NPPODS  16      /*  1024/PPOD_SIZE */
+#define ULPMEM_IDATA_MAX_NPPODS 3       /* (PPOD_SIZE * 3 + ulptx hdr) < 256B */
+#define PCIE_MEMWIN_MAX_NPPODS  16      /*  1024/PPOD_SIZE */
+
+#define PPOD_COLOR_SHIFT        0
+#define PPOD_COLOR(x)           ((x) << PPOD_COLOR_SHIFT)
+
+#define PPOD_IDX_SHIFT          6
+#define PPOD_IDX_MAX_SIZE       24
+
+#define PPOD_TID_SHIFT          0
+#define PPOD_TID(x)             ((x) << PPOD_TID_SHIFT)
+
+#define PPOD_TAG_SHIFT          6
+#define PPOD_TAG(x)             ((x) << PPOD_TAG_SHIFT)
+
+#define PPOD_VALID_SHIFT        24
+#define PPOD_VALID(x)           ((x) << PPOD_VALID_SHIFT)
+#define PPOD_VALID_FLAG         PPOD_VALID(1U)
+
+#define PPOD_PI_EXTRACT_CTL_SHIFT       31
+#define PPOD_PI_EXTRACT_CTL(x)          ((x) << PPOD_PI_EXTRACT_CTL_SHIFT)
+#define PPOD_PI_EXTRACT_CTL_FLAG        V_PPOD_PI_EXTRACT_CTL(1U)
+
+#define PPOD_PI_TYPE_SHIFT              29
+#define PPOD_PI_TYPE_MASK               0x3
+#define PPOD_PI_TYPE(x)                 ((x) << PPOD_PI_TYPE_SHIFT)
+
+#define PPOD_PI_CHECK_CTL_SHIFT         27
+#define PPOD_PI_CHECK_CTL_MASK          0x3
+#define PPOD_PI_CHECK_CTL(x)            ((x) << PPOD_PI_CHECK_CTL_SHIFT)
+
+#define PPOD_PI_REPORT_CTL_SHIFT        25
+#define PPOD_PI_REPORT_CTL_MASK         0x3
+#define PPOD_PI_REPORT_CTL(x)           ((x) << PPOD_PI_REPORT_CTL_SHIFT)
+
+static inline int cxgbi_ppm_is_ddp_tag(struct cxgbi_ppm *ppm, u32 tag)
+{
+        return !(tag & ppm->tformat.no_ddp_mask);
+}
+
+static inline int cxgbi_ppm_sw_tag_is_usable(struct cxgbi_ppm *ppm,
+                                             u32 tag)
+{
+        /* the sw tag must be using <= 31 bits */
+        return !(tag & 0x80000000U);
+}
+
+static inline int cxgbi_ppm_make_non_ddp_tag(struct cxgbi_ppm *ppm,
+                                             u32 sw_tag,
+                                             u32 *final_tag)
+{
+        struct cxgbi_tag_format *tformat = &ppm->tformat;
+
+        if (!cxgbi_ppm_sw_tag_is_usable(ppm, sw_tag)) {
+                pr_info("sw_tag 0x%x NOT usable.\n", sw_tag);
+                return -EINVAL;
+        }
+
+        if (!sw_tag) {
+                *final_tag = tformat->no_ddp_mask;
+        } else {
+                unsigned int shift = tformat->idx_bits + tformat->color_bits;
+                u32 lower = sw_tag & tformat->idx_clr_mask;
+                u32 upper = (sw_tag >> shift) << (shift + 1);
+
+                *final_tag = upper | tformat->no_ddp_mask | lower;
+        }
+        return 0;
+}
+
+static inline u32 cxgbi_ppm_decode_non_ddp_tag(struct cxgbi_ppm *ppm,
+                                               u32 tag)
+{
+        struct cxgbi_tag_format *tformat = &ppm->tformat;
+        unsigned int shift = tformat->idx_bits + tformat->color_bits;
+        u32 lower = tag & tformat->idx_clr_mask;
+        u32 upper = (tag >> tformat->rsvd_bits) << shift;
+
+        return upper | lower;
+}
+
+static inline u32 cxgbi_ppm_ddp_tag_get_idx(struct cxgbi_ppm *ppm,
+                                            u32 ddp_tag)
+{
+        u32 hw_idx = (ddp_tag >> PPOD_IDX_SHIFT) &
+                        ppm->tformat.idx_mask;
+
+        return hw_idx - ppm->base_idx;
+}
+
+static inline u32 cxgbi_ppm_make_ddp_tag(unsigned int hw_idx,
+                                         unsigned char color)
+{
+        return (hw_idx << PPOD_IDX_SHIFT) | ((u32)color);
+}
+
+static inline unsigned long
+cxgbi_ppm_get_tag_caller_data(struct cxgbi_ppm *ppm,
+                              u32 ddp_tag)
+{
+        u32 idx = cxgbi_ppm_ddp_tag_get_idx(ppm, ddp_tag);
+
+        return ppm->ppod_data[idx].caller_data;
+}
+
+/* sw bits are the free bits */
+static inline int cxgbi_ppm_ddp_tag_update_sw_bits(struct cxgbi_ppm *ppm,
+                                                   u32 val, u32 orig_tag,
+                                                   u32 *final_tag)
+{
+        struct cxgbi_tag_format *tformat = &ppm->tformat;
+        u32 v = val >> tformat->free_bits;
+
+        if (v) {
+                pr_info("sw_bits 0x%x too large, avail bits %u.\n",
+                        val, tformat->free_bits);
+                return -EINVAL;
+        }
+        if (!cxgbi_ppm_is_ddp_tag(ppm, orig_tag))
+                return -EINVAL;
+
+        *final_tag = (val << tformat->rsvd_bits) |
+                     (orig_tag & ppm->tformat.rsvd_mask);
+        return 0;
+}
+
+static inline void cxgbi_ppm_ppod_clear(struct cxgbi_pagepod *ppod)
+{
+        ppod->hdr.vld_tid = 0U;
+}
+
+static inline void cxgbi_tagmask_check(unsigned int tagmask,
+                                       struct cxgbi_tag_format *tformat)
+{
+        unsigned int bits = fls(tagmask);
+
+        /* reserve top most 2 bits for page selector */
+        tformat->free_bits = 32 - 2 - bits;
+        tformat->rsvd_bits = bits;
+        tformat->color_bits = PPOD_IDX_SHIFT;
+        tformat->idx_bits = bits - 1 - PPOD_IDX_SHIFT;
+        tformat->no_ddp_mask = 1 << (bits - 1);
+        tformat->idx_mask = (1 << tformat->idx_bits) - 1;
+        tformat->color_mask = (1 << PPOD_IDX_SHIFT) - 1;
+        tformat->idx_clr_mask = (1 << (bits - 1)) - 1;
+        tformat->rsvd_mask = (1 << bits) - 1;
+
+        pr_info("ippm: tagmask 0x%x, rsvd %u=%u+%u+1, mask 0x%x,0x%x, "
+                "pg %u,%u,%u,%u.\n",
+                tagmask, tformat->rsvd_bits, tformat->idx_bits,
+                tformat->color_bits, tformat->no_ddp_mask, tformat->rsvd_mask,
+                tformat->pgsz_order[0], tformat->pgsz_order[1],
+                tformat->pgsz_order[2], tformat->pgsz_order[3]);
+}
+
+int cxgbi_ppm_find_page_index(struct cxgbi_ppm *ppm, unsigned long pgsz);
+void cxgbi_ppm_make_ppod_hdr(struct cxgbi_ppm *ppm, u32 tag,
+                             unsigned int tid, unsigned int offset,
+                             unsigned int length,
+                             struct cxgbi_pagepod_hdr *hdr);
+void cxgbi_ppm_ppod_release(struct cxgbi_ppm *, u32 idx);
+int cxgbi_ppm_ppods_reserve(struct cxgbi_ppm *, unsigned short nr_pages,
+                            u32 per_tag_pg_idx, u32 *ppod_idx, u32 *ddp_tag,
+                            unsigned long caller_data);
+int cxgbi_ppm_init(void **ppm_pp, struct net_device *, struct pci_dev *,
+                   void *lldev, struct cxgbi_tag_format *,
+                   unsigned int ppmax, unsigned int llimit,
+                   unsigned int start,
+                   unsigned int reserve_factor);
+int cxgbi_ppm_release(struct cxgbi_ppm *ppm);
+void cxgbi_tagmask_check(unsigned int tagmask, struct cxgbi_tag_format *);
+unsigned int cxgbi_tagmask_set(unsigned int ppmax);
+
+#endif  /*__CXGB4PPM_H__*/
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
index cf711d5f15be..f3c58aaa932d 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
@@ -191,6 +191,7 @@ static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)
 enum cxgb4_uld {
         CXGB4_ULD_RDMA,
         CXGB4_ULD_ISCSI,
+        CXGB4_ULD_ISCSIT,
         CXGB4_ULD_MAX
 };
 
@@ -212,6 +213,7 @@ struct l2t_data;
 struct net_device;
 struct pkt_gl;
 struct tp_tcp_stats;
+struct t4_lro_mgr;
 
 struct cxgb4_range {
         unsigned int start;
@@ -273,6 +275,10 @@ struct cxgb4_lld_info {
         unsigned int max_ordird_qp;          /* Max ORD/IRD depth per RDMA QP */
         unsigned int max_ird_adapter;        /* Max IRD memory per adapter */
         bool ulptx_memwrite_dsgl;            /* use of T5 DSGL allowed */
+        unsigned int iscsi_tagmask;          /* iscsi ddp tag mask */
+        unsigned int iscsi_pgsz_order;       /* iscsi ddp page size orders */
+        unsigned int iscsi_llimit;           /* chip's iscsi region llimit */
+        void **iscsi_ppm;                    /* iscsi page pod manager */
         int nodeid;                          /* device numa node id */
 };
 
@@ -283,6 +289,11 @@ struct cxgb4_uld_info {
                           const struct pkt_gl *gl);
         int (*state_change)(void *handle, enum cxgb4_state new_state);
         int (*control)(void *handle, enum cxgb4_control control, ...);
+        int (*lro_rx_handler)(void *handle, const __be64 *rsp,
+                              const struct pkt_gl *gl,
+                              struct t4_lro_mgr *lro_mgr,
+                              struct napi_struct *napi);
+        void (*lro_flush)(struct t4_lro_mgr *);
 };
 
 int cxgb4_register_uld(enum cxgb4_uld type, const struct cxgb4_uld_info *p);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/l2t.c b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
index 5b0f3ef348e9..60a26037a1c6 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/l2t.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/l2t.c
@@ -48,8 +48,6 @@
 #include "t4_regs.h"
 #include "t4_values.h"
 
-#define VLAN_NONE 0xfff
-
 /* identifies sync vs async L2T_WRITE_REQs */
 #define SYNC_WR_S    12
 #define SYNC_WR_V(x) ((x) << SYNC_WR_S)
diff --git a/drivers/net/ethernet/chelsio/cxgb4/l2t.h b/drivers/net/ethernet/chelsio/cxgb4/l2t.h
index 4e2d47ac102b..79665bd8f881 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/l2t.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/l2t.h
@@ -39,6 +39,8 @@
 #include <linux/if_ether.h>
 #include <linux/atomic.h>
 
+#define VLAN_NONE 0xfff
+
 enum { L2T_SIZE = 4096 };     /* # of L2T entries */
 
 enum {
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index deca4a2956cc..13b144bcf725 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -2157,8 +2157,11 @@ static int process_responses(struct sge_rspq *q, int budget)
 
         while (likely(budget_left)) {
                 rc = (void *)q->cur_desc + (q->iqe_len - sizeof(*rc));
-                if (!is_new_response(rc, q))
+                if (!is_new_response(rc, q)) {
+                        if (q->flush_handler)
+                                q->flush_handler(q);
                         break;
+                }
 
                 dma_rmb();
                 rsp_type = RSPD_TYPE_G(rc->type_gen);
@@ -2544,7 +2547,8 @@ static void __iomem *bar2_address(struct adapter *adapter,
  */
 int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
                      struct net_device *dev, int intr_idx,
-                     struct sge_fl *fl, rspq_handler_t hnd, int cong)
+                     struct sge_fl *fl, rspq_handler_t hnd,
+                     rspq_flush_handler_t flush_hnd, int cong)
 {
         int ret, flsz = 0;
         struct fw_iq_cmd c;
@@ -2648,6 +2652,10 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq,
         iq->size--;                           /* subtract status entry */
         iq->netdev = dev;
         iq->handler = hnd;
+        iq->flush_handler = flush_hnd;
+
+        memset(&iq->lro_mgr, 0, sizeof(struct t4_lro_mgr));
+        skb_queue_head_init(&iq->lro_mgr.lroq);
 
         /* set offset to -1 to distinguish ingress queues without FL */
         iq->offset = fl ? 0 : -1;
@@ -2992,6 +3000,7 @@ void t4_free_sge_resources(struct adapter *adap)
 
         /* clean up RDMA and iSCSI Rx queues */
         t4_free_ofld_rxqs(adap, adap->sge.iscsiqsets, adap->sge.iscsirxq);
+        t4_free_ofld_rxqs(adap, adap->sge.niscsitq, adap->sge.iscsitrxq);
         t4_free_ofld_rxqs(adap, adap->sge.rdmaqs, adap->sge.rdmarxq);
         t4_free_ofld_rxqs(adap, adap->sge.rdmaciqs, adap->sge.rdmaciq);
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
index 1d2d1da40c80..80417fc564d4 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
@@ -51,6 +51,7 @@ enum {
         CPL_TX_PKT            = 0xE,
         CPL_L2T_WRITE_REQ     = 0x12,
         CPL_TID_RELEASE       = 0x1A,
+        CPL_TX_DATA_ISO       = 0x1F,
 
         CPL_CLOSE_LISTSRV_RPL = 0x20,
         CPL_L2T_WRITE_RPL     = 0x23,
@@ -344,6 +345,87 @@ struct cpl_pass_open_rpl {
         u8 status;
 };
 
+struct tcp_options {
+        __be16 mss;
+        __u8 wsf;
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+        __u8:4;
+        __u8 unknown:1;
+        __u8:1;
+        __u8 sack:1;
+        __u8 tstamp:1;
+#else
+        __u8 tstamp:1;
+        __u8 sack:1;
+        __u8:1;
+        __u8 unknown:1;
+        __u8:4;
+#endif
+};
+
+struct cpl_pass_accept_req {
+        union opcode_tid ot;
+        __be16 rsvd;
+        __be16 len;
+        __be32 hdr_len;
+        __be16 vlan;
+        __be16 l2info;
+        __be32 tos_stid;
+        struct tcp_options tcpopt;
+};
+
+/* cpl_pass_accept_req.hdr_len fields */
+#define SYN_RX_CHAN_S    0
+#define SYN_RX_CHAN_M    0xF
+#define SYN_RX_CHAN_V(x) ((x) << SYN_RX_CHAN_S)
+#define SYN_RX_CHAN_G(x) (((x) >> SYN_RX_CHAN_S) & SYN_RX_CHAN_M)
+
+#define TCP_HDR_LEN_S    10
+#define TCP_HDR_LEN_M    0x3F
+#define TCP_HDR_LEN_V(x) ((x) << TCP_HDR_LEN_S)
+#define TCP_HDR_LEN_G(x) (((x) >> TCP_HDR_LEN_S) & TCP_HDR_LEN_M)
+
+#define IP_HDR_LEN_S    16
+#define IP_HDR_LEN_M    0x3FF
+#define IP_HDR_LEN_V(x) ((x) << IP_HDR_LEN_S)
+#define IP_HDR_LEN_G(x) (((x) >> IP_HDR_LEN_S) & IP_HDR_LEN_M)
+
+#define ETH_HDR_LEN_S    26
+#define ETH_HDR_LEN_M    0x1F
+#define ETH_HDR_LEN_V(x) ((x) << ETH_HDR_LEN_S)
+#define ETH_HDR_LEN_G(x) (((x) >> ETH_HDR_LEN_S) & ETH_HDR_LEN_M)
+
+/* cpl_pass_accept_req.l2info fields */
+#define SYN_MAC_IDX_S    0
+#define SYN_MAC_IDX_M    0x1FF
+#define SYN_MAC_IDX_V(x) ((x) << SYN_MAC_IDX_S)
+#define SYN_MAC_IDX_G(x) (((x) >> SYN_MAC_IDX_S) & SYN_MAC_IDX_M)
+
+#define SYN_XACT_MATCH_S    9
+#define SYN_XACT_MATCH_V(x) ((x) << SYN_XACT_MATCH_S)
+#define SYN_XACT_MATCH_F    SYN_XACT_MATCH_V(1U)
+
+#define SYN_INTF_S    12
+#define SYN_INTF_M    0xF
+#define SYN_INTF_V(x) ((x) << SYN_INTF_S)
+#define SYN_INTF_G(x) (((x) >> SYN_INTF_S) & SYN_INTF_M)
+
+enum {                     /* TCP congestion control algorithms */
+        CONG_ALG_RENO,
+        CONG_ALG_TAHOE,
+        CONG_ALG_NEWRENO,
+        CONG_ALG_HIGHSPEED
+};
+
+#define CONG_CNTRL_S    14
+#define CONG_CNTRL_M    0x3
+#define CONG_CNTRL_V(x) ((x) << CONG_CNTRL_S)
+#define CONG_CNTRL_G(x) (((x) >> CONG_CNTRL_S) & CONG_CNTRL_M)
+
+#define T5_ISS_S    18
+#define T5_ISS_V(x) ((x) << T5_ISS_S)
+#define T5_ISS_F    T5_ISS_V(1U)
+
 struct cpl_pass_accept_rpl {
         WR_HDR;
         union opcode_tid ot;
@@ -818,6 +900,110 @@ struct cpl_iscsi_hdr {
 #define ISCSI_DDP_V(x) ((x) << ISCSI_DDP_S)
 #define ISCSI_DDP_F    ISCSI_DDP_V(1U)
 
+struct cpl_rx_data_ddp {
+        union opcode_tid ot;
+        __be16 urg;
+        __be16 len;
+        __be32 seq;
+        union {
+                __be32 nxt_seq;
+                __be32 ddp_report;
+        };
+        __be32 ulp_crc;
+        __be32 ddpvld;
+};
+
+#define cpl_rx_iscsi_ddp cpl_rx_data_ddp
+
+struct cpl_iscsi_data {
+        union opcode_tid ot;
+        __u8 rsvd0[2];
+        __be16 len;
+        __be32 seq;
+        __be16 urg;
+        __u8 rsvd1;
+        __u8 status;
+};
+
+struct cpl_tx_data_iso {
+        __be32 op_to_scsi;
+        __u8   reserved1;
+        __u8   ahs_len;
+        __be16 mpdu;
+        __be32 burst_size;
+        __be32 len;
+        __be32 reserved2_seglen_offset;
+        __be32 datasn_offset;
+        __be32 buffer_offset;
+        __be32 reserved3;
+
+        /* encapsulated CPL_TX_DATA follows here */
+};
+
+/* cpl_tx_data_iso.op_to_scsi fields */
+#define CPL_TX_DATA_ISO_OP_S    24
+#define CPL_TX_DATA_ISO_OP_M    0xff
+#define CPL_TX_DATA_ISO_OP_V(x) ((x) << CPL_TX_DATA_ISO_OP_S)
+#define CPL_TX_DATA_ISO_OP_G(x) \
+        (((x) >> CPL_TX_DATA_ISO_OP_S) & CPL_TX_DATA_ISO_OP_M)
+
+#define CPL_TX_DATA_ISO_FIRST_S         23
+#define CPL_TX_DATA_ISO_FIRST_M         0x1
+#define CPL_TX_DATA_ISO_FIRST_V(x)      ((x) << CPL_TX_DATA_ISO_FIRST_S)
+#define CPL_TX_DATA_ISO_FIRST_G(x)      \
+        (((x) >> CPL_TX_DATA_ISO_FIRST_S) & CPL_TX_DATA_ISO_FIRST_M)
+#define CPL_TX_DATA_ISO_FIRST_F CPL_TX_DATA_ISO_FIRST_V(1U)
+
+#define CPL_TX_DATA_ISO_LAST_S          22
+#define CPL_TX_DATA_ISO_LAST_M          0x1
+#define CPL_TX_DATA_ISO_LAST_V(x)       ((x) << CPL_TX_DATA_ISO_LAST_S)
+#define CPL_TX_DATA_ISO_LAST_G(x)       \
+        (((x) >> CPL_TX_DATA_ISO_LAST_S) & CPL_TX_DATA_ISO_LAST_M)
+#define CPL_TX_DATA_ISO_LAST_F  CPL_TX_DATA_ISO_LAST_V(1U)
+
+#define CPL_TX_DATA_ISO_CPLHDRLEN_S     21
+#define CPL_TX_DATA_ISO_CPLHDRLEN_M     0x1
+#define CPL_TX_DATA_ISO_CPLHDRLEN_V(x)  ((x) << CPL_TX_DATA_ISO_CPLHDRLEN_S)
+#define CPL_TX_DATA_ISO_CPLHDRLEN_G(x)  \
+        (((x) >> CPL_TX_DATA_ISO_CPLHDRLEN_S) & CPL_TX_DATA_ISO_CPLHDRLEN_M)
+#define CPL_TX_DATA_ISO_CPLHDRLEN_F     CPL_TX_DATA_ISO_CPLHDRLEN_V(1U)
+
+#define CPL_TX_DATA_ISO_HDRCRC_S        20
+#define CPL_TX_DATA_ISO_HDRCRC_M        0x1
+#define CPL_TX_DATA_ISO_HDRCRC_V(x)     ((x) << CPL_TX_DATA_ISO_HDRCRC_S)
+#define CPL_TX_DATA_ISO_HDRCRC_G(x)     \
+        (((x) >> CPL_TX_DATA_ISO_HDRCRC_S) & CPL_TX_DATA_ISO_HDRCRC_M)
+#define CPL_TX_DATA_ISO_HDRCRC_F        CPL_TX_DATA_ISO_HDRCRC_V(1U)
+
+#define CPL_TX_DATA_ISO_PLDCRC_S        19
+#define CPL_TX_DATA_ISO_PLDCRC_M        0x1
+#define CPL_TX_DATA_ISO_PLDCRC_V(x)     ((x) << CPL_TX_DATA_ISO_PLDCRC_S)
+#define CPL_TX_DATA_ISO_PLDCRC_G(x)     \
+        (((x) >> CPL_TX_DATA_ISO_PLDCRC_S) & CPL_TX_DATA_ISO_PLDCRC_M)
+#define CPL_TX_DATA_ISO_PLDCRC_F        CPL_TX_DATA_ISO_PLDCRC_V(1U)
+
+#define CPL_TX_DATA_ISO_IMMEDIATE_S     18
+#define CPL_TX_DATA_ISO_IMMEDIATE_M     0x1
+#define CPL_TX_DATA_ISO_IMMEDIATE_V(x)  ((x) << CPL_TX_DATA_ISO_IMMEDIATE_S)
+#define CPL_TX_DATA_ISO_IMMEDIATE_G(x)  \
+        (((x) >> CPL_TX_DATA_ISO_IMMEDIATE_S) & CPL_TX_DATA_ISO_IMMEDIATE_M)
+#define CPL_TX_DATA_ISO_IMMEDIATE_F     CPL_TX_DATA_ISO_IMMEDIATE_V(1U)
+
+#define CPL_TX_DATA_ISO_SCSI_S          16
+#define CPL_TX_DATA_ISO_SCSI_M          0x3
+#define CPL_TX_DATA_ISO_SCSI_V(x)       ((x) << CPL_TX_DATA_ISO_SCSI_S)
+#define CPL_TX_DATA_ISO_SCSI_G(x)       \
+        (((x) >> CPL_TX_DATA_ISO_SCSI_S) & CPL_TX_DATA_ISO_SCSI_M)
+
+/* cpl_tx_data_iso.reserved2_seglen_offset fields */
+#define CPL_TX_DATA_ISO_SEGLEN_OFFSET_S         0
+#define CPL_TX_DATA_ISO_SEGLEN_OFFSET_M         0xffffff
+#define CPL_TX_DATA_ISO_SEGLEN_OFFSET_V(x)      \
+        ((x) << CPL_TX_DATA_ISO_SEGLEN_OFFSET_S)
+#define CPL_TX_DATA_ISO_SEGLEN_OFFSET_G(x)      \
+        (((x) >> CPL_TX_DATA_ISO_SEGLEN_OFFSET_S) & \
+         CPL_TX_DATA_ISO_SEGLEN_OFFSET_M)
+
 struct cpl_rx_data {
         union opcode_tid ot;
         __be16 rsvd;
@@ -854,6 +1040,15 @@ struct cpl_rx_data_ack {
 #define RX_FORCE_ACK_V(x) ((x) << RX_FORCE_ACK_S)
 #define RX_FORCE_ACK_F    RX_FORCE_ACK_V(1U)
 
+#define RX_DACK_MODE_S    29
+#define RX_DACK_MODE_M    0x3
+#define RX_DACK_MODE_V(x) ((x) << RX_DACK_MODE_S)
+#define RX_DACK_MODE_G(x) (((x) >> RX_DACK_MODE_S) & RX_DACK_MODE_M)
+
+#define RX_DACK_CHANGE_S    31
+#define RX_DACK_CHANGE_V(x) ((x) << RX_DACK_CHANGE_S)
+#define RX_DACK_CHANGE_F    RX_DACK_CHANGE_V(1U)
+
 struct cpl_rx_pkt {
         struct rss_header rsshdr;
         u8 opcode;
@@ -1090,6 +1285,12 @@ struct cpl_fw4_ack {
         __be64 rsvd1;
 };
 
+enum {
+        CPL_FW4_ACK_FLAGS_SEQVAL        = 0x1,  /* seqn valid */
+        CPL_FW4_ACK_FLAGS_CH            = 0x2,  /* channel change complete */
+        CPL_FW4_ACK_FLAGS_FLOWC         = 0x4,  /* fw_flowc_wr complete */
+};
+
 struct cpl_fw6_msg {
         u8 opcode;
         u8 type;
@@ -1115,6 +1316,17 @@ struct cpl_fw6_msg_ofld_connection_wr_rpl {
         __u8    rsvd[2];
 };
 
+struct cpl_tx_data {
+        union opcode_tid ot;
+        __be32 len;
+        __be32 rsvd;
+        __be32 flags;
+};
+
+/* cpl_tx_data.flags field */
+#define TX_FORCE_S      13
+#define TX_FORCE_V(x)   ((x) << TX_FORCE_S)
+
 enum {
         ULP_TX_MEM_READ = 2,
         ULP_TX_MEM_WRITE = 3,
@@ -1143,6 +1355,11 @@ struct ulptx_sgl {
         struct ulptx_sge_pair sge[0];
 };
 
+struct ulptx_idata {
+        __be32 cmd_more;
+        __be32 len;
+};
+
 #define ULPTX_NSGE_S    0
 #define ULPTX_NSGE_V(x) ((x) << ULPTX_NSGE_S)
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
index 06bc2d2e7a73..a2cdfc1261dc 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
@@ -166,6 +166,7 @@ CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN
         CH_PCI_ID_TABLE_FENTRY(0x5099), /* Custom 2x40G QSFP */
         CH_PCI_ID_TABLE_FENTRY(0x509a), /* Custom T520-CR */
         CH_PCI_ID_TABLE_FENTRY(0x509b), /* Custom T540-CR LOM */
+        CH_PCI_ID_TABLE_FENTRY(0x509c), /* Custom T520-CR*/
 
         /* T6 adapters:
          */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index c8661c77b4e3..7ad6d4e75b2a 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -101,6 +101,7 @@ enum fw_wr_opcodes {
         FW_RI_BIND_MW_WR               = 0x18,
         FW_RI_FR_NSMR_WR               = 0x19,
         FW_RI_INV_LSTAG_WR             = 0x1a,
+        FW_ISCSI_TX_DATA_WR            = 0x45,
         FW_LASTC2E_WR                  = 0x70
 };
 
@@ -561,7 +562,12 @@ enum fw_flowc_mnem {
         FW_FLOWC_MNEM_SNDBUF,
         FW_FLOWC_MNEM_MSS,
         FW_FLOWC_MNEM_TXDATAPLEN_MAX,
-        FW_FLOWC_MNEM_SCHEDCLASS = 11,
+        FW_FLOWC_MNEM_TCPSTATE,
+        FW_FLOWC_MNEM_EOSTATE,
+        FW_FLOWC_MNEM_SCHEDCLASS,
+        FW_FLOWC_MNEM_DCBPRIO,
+        FW_FLOWC_MNEM_SND_SCALE,
+        FW_FLOWC_MNEM_RCV_SCALE,
 };
 
 struct fw_flowc_mnemval {
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
index 1cc8a7a69457..730fec73d5a6 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
@@ -74,7 +74,8 @@ static int dflt_msg_enable = DFLT_MSG_ENABLE;
 
 module_param(dflt_msg_enable, int, 0644);
 MODULE_PARM_DESC(dflt_msg_enable,
-                 "default adapter ethtool message level bitmap");
+                 "default adapter ethtool message level bitmap, "
+                 "deprecated parameter");
 
 /*
  * The driver uses the best interrupt scheme available on a platform in the
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 37c081583084..08243c2ff4b4 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -943,8 +943,8 @@ fec_restart(struct net_device *ndev)
                 else
                         val &= ~FEC_RACC_OPTIONS;
                 writel(val, fep->hwp + FEC_RACC);
+                writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
         }
-        writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
 #endif
 
         /*
diff --git a/drivers/net/ethernet/freescale/fman/fman.c b/drivers/net/ethernet/freescale/fman/fman.c
index 79a210aaf0bb..ea83712a6d62 100644
--- a/drivers/net/ethernet/freescale/fman/fman.c
+++ b/drivers/net/ethernet/freescale/fman/fman.c
@@ -35,6 +35,7 @@
 #include "fman.h"
 #include "fman_muram.h"
 
+#include <linux/fsl/guts.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/module.h>
@@ -1871,6 +1872,90 @@ err_fm_state:
         return -EINVAL;
 }
 
+static int fman_reset(struct fman *fman)
+{
+        u32 count;
+        int err = 0;
+
+        if (fman->state->rev_info.major < 6) {
+                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
+                /* Wait for reset completion */
+                count = 100;
+                do {
+                        udelay(1);
+                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
+                         FPM_RSTC_FM_RESET) && --count);
+                if (count == 0)
+                        err = -EBUSY;
+
+                goto _return;
+        } else {
+                struct device_node *guts_node;
+                struct ccsr_guts __iomem *guts_regs;
+                u32 devdisr2, reg;
+
+                /* Errata A007273 */
+                guts_node =
+                        of_find_compatible_node(NULL, NULL,
+                                                "fsl,qoriq-device-config-2.0");
+                if (!guts_node) {
+                        dev_err(fman->dev, "%s: Couldn't find guts node\n",
+                                __func__);
+                        goto guts_node;
+                }
+
+                guts_regs = of_iomap(guts_node, 0);
+                if (!guts_regs) {
+                        dev_err(fman->dev, "%s: Couldn't map %s regs\n",
+                                __func__, guts_node->full_name);
+                        goto guts_regs;
+                }
+#define FMAN1_ALL_MACS_MASK     0xFCC00000
+#define FMAN2_ALL_MACS_MASK     0x000FCC00
+                /* Read current state */
+                devdisr2 = ioread32be(&guts_regs->devdisr2);
+                if (fman->dts_params.id == 0)
+                        reg = devdisr2 & ~FMAN1_ALL_MACS_MASK;
+                else
+                        reg = devdisr2 & ~FMAN2_ALL_MACS_MASK;
+
+                /* Enable all MACs */
+                iowrite32be(reg, &guts_regs->devdisr2);
+
+                /* Perform FMan reset */
+                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
+
+                /* Wait for reset completion */
+                count = 100;
+                do {
+                        udelay(1);
+                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
+                         FPM_RSTC_FM_RESET) && --count);
+                if (count == 0) {
+                        iounmap(guts_regs);
+                        of_node_put(guts_node);
+                        err = -EBUSY;
+                        goto _return;
+                }
+
+                /* Restore devdisr2 value */
+                iowrite32be(devdisr2, &guts_regs->devdisr2);
+
+                iounmap(guts_regs);
+                of_node_put(guts_node);
+
+                goto _return;
+
+guts_regs:
+                of_node_put(guts_node);
+guts_node:
+                dev_dbg(fman->dev, "%s: Didn't perform FManV3 reset due to Errata A007273!\n",
+                        __func__);
+        }
+_return:
+        return err;
+}
+
 static int fman_init(struct fman *fman)
 {
         struct fman_cfg *cfg = NULL;
@@ -1914,22 +1999,9 @@ static int fman_init(struct fman *fman)
                 fman->liodn_base[i] = liodn_base;
         }
 
-        /* FMan Reset (supported only for FMan V2) */
-        if (fman->state->rev_info.major >= 6) {
-                /* Errata A007273 */
-                dev_dbg(fman->dev, "%s: FManV3 reset is not supported!\n",
-                        __func__);
-        } else {
-                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
-                /* Wait for reset completion */
-                count = 100;
-                do {
-                        udelay(1);
-                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
-                         FPM_RSTC_FM_RESET) && --count);
-                if (count == 0)
-                        return -EBUSY;
-        }
+        err = fman_reset(fman);
+        if (err)
+                return err;
 
         if (ioread32be(&fman->qmi_regs->fmqm_gs) & QMI_GS_HALT_NOT_BUSY) {
                 resume(fman->fpm_regs);
diff --git a/drivers/net/ethernet/hisilicon/hns/hnae.h b/drivers/net/ethernet/hisilicon/hns/hnae.h
index 1cbcb9fa3fb5..e8d36aaea223 100644
--- a/drivers/net/ethernet/hisilicon/hns/hnae.h
+++ b/drivers/net/ethernet/hisilicon/hns/hnae.h
@@ -147,6 +147,8 @@ enum hnae_led_state {
 
 #define HNSV2_TXD_BUFNUM_S 0
 #define HNSV2_TXD_BUFNUM_M (0x7 << HNSV2_TXD_BUFNUM_S)
+#define HNSV2_TXD_PORTID_S      4
+#define HNSV2_TXD_PORTID_M      (0X7 << HNSV2_TXD_PORTID_S)
 #define HNSV2_TXD_RI_B   1
 #define HNSV2_TXD_L4CS_B   2
 #define HNSV2_TXD_L3CS_B   3
@@ -467,7 +469,7 @@ struct hnae_ae_ops {
                                    u32 *tx_usecs, u32 *rx_usecs);
         void (*get_rx_max_coalesced_frames)(struct hnae_handle *handle,
                                             u32 *tx_frames, u32 *rx_frames);
-        void (*set_coalesce_usecs)(struct hnae_handle *handle, u32 timeout);
+        int (*set_coalesce_usecs)(struct hnae_handle *handle, u32 timeout);
         int (*set_coalesce_frames)(struct hnae_handle *handle,
                                    u32 coalesce_frames);
         void (*set_promisc_mode)(struct hnae_handle *handle, u32 en);
@@ -516,6 +518,7 @@ struct hnae_handle {
         int q_num;
         int vf_id;
         u32 eport_id;
+        u32 dport_id;   /* v2 tx bd should fill the dport_id */
         enum hnae_port_type port_type;
         struct list_head node;    /* list to hnae_ae_dev->handle_list */
         struct hnae_buf_ops *bops; /* operation for the buffer */
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
index d4f92ed322d6..159142272afb 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
@@ -159,11 +159,6 @@ struct hnae_handle *hns_ae_get_handle(struct hnae_ae_dev *dev,
                 ae_handle->qs[i]->tx_ring.q = ae_handle->qs[i];
 
                 ring_pair_cb->used_by_vf = 1;
-                if (port_idx < DSAF_SERVICE_PORT_NUM_PER_DSAF)
-                        ring_pair_cb->port_id_in_dsa = port_idx;
-                else
-                        ring_pair_cb->port_id_in_dsa = 0;
-
                 ring_pair_cb++;
         }
 
@@ -175,6 +170,7 @@ struct hnae_handle *hns_ae_get_handle(struct hnae_ae_dev *dev,
         ae_handle->phy_node = vf_cb->mac_cb->phy_node;
         ae_handle->if_support = vf_cb->mac_cb->if_support;
         ae_handle->port_type = vf_cb->mac_cb->mac_type;
+        ae_handle->dport_id = port_idx;
 
         return ae_handle;
 vf_id_err:
@@ -403,11 +399,16 @@ static void hns_ae_get_ring_bdnum_limit(struct hnae_queue *queue,
 static void hns_ae_get_pauseparam(struct hnae_handle *handle,
                                   u32 *auto_neg, u32 *rx_en, u32 *tx_en)
 {
-        assert(handle);
+        struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle);
+        struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
 
-        hns_mac_get_autoneg(hns_get_mac_cb(handle), auto_neg);
+        hns_mac_get_autoneg(mac_cb, auto_neg);
 
-        hns_mac_get_pauseparam(hns_get_mac_cb(handle), rx_en, tx_en);
+        hns_mac_get_pauseparam(mac_cb, rx_en, tx_en);
+
+        /* Service port's pause feature is provided by DSAF, not mac */
+        if (handle->port_type == HNAE_PORT_SERVICE)
+                hns_dsaf_get_rx_mac_pause_en(dsaf_dev, mac_cb->mac_id, rx_en);
 }
 
 static int hns_ae_set_autoneg(struct hnae_handle *handle, u8 enable)
@@ -419,7 +420,10 @@ static int hns_ae_set_autoneg(struct hnae_handle *handle, u8 enable)
 
 static void hns_ae_set_promisc_mode(struct hnae_handle *handle, u32 en)
 {
+        struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle);
+
         hns_dsaf_set_promisc_mode(hns_ae_get_dsaf_dev(handle->dev), en);
+        hns_mac_set_promisc(mac_cb, (u8)!!en);
 }
 
 static int hns_ae_get_autoneg(struct hnae_handle *handle)
@@ -437,71 +441,67 @@ static int hns_ae_set_pauseparam(struct hnae_handle *handle,
                                  u32 autoneg, u32 rx_en, u32 tx_en)
 {
         struct hns_mac_cb *mac_cb = hns_get_mac_cb(handle);
+        struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
         int ret;
 
         ret = hns_mac_set_autoneg(mac_cb, autoneg);
         if (ret)
                 return ret;
 
+        /* Service port's pause feature is provided by DSAF, not mac */
+        if (handle->port_type == HNAE_PORT_SERVICE) {
+                ret = hns_dsaf_set_rx_mac_pause_en(dsaf_dev,
+                                                   mac_cb->mac_id, rx_en);
+                if (ret)
+                        return ret;
+                rx_en = 0;
+        }
         return hns_mac_set_pauseparam(mac_cb, rx_en, tx_en);
 }
 
 static void hns_ae_get_coalesce_usecs(struct hnae_handle *handle,
                                       u32 *tx_usecs, u32 *rx_usecs)
 {
-        int port;
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        *tx_usecs = hns_rcb_get_coalesce_usecs(
-                hns_ae_get_dsaf_dev(handle->dev),
-                hns_dsaf_get_comm_idx_by_port(port));
-        *rx_usecs = hns_rcb_get_coalesce_usecs(
-                hns_ae_get_dsaf_dev(handle->dev),
-                hns_dsaf_get_comm_idx_by_port(port));
+        *tx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common,
+                                               ring_pair->port_id_in_comm);
+        *rx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common,
+                                               ring_pair->port_id_in_comm);
 }
 
 static void hns_ae_get_rx_max_coalesced_frames(struct hnae_handle *handle,
                                                u32 *tx_frames, u32 *rx_frames)
 {
-        int port;
-
-        assert(handle);
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
-
-        *tx_frames = hns_rcb_get_coalesced_frames(
-                hns_ae_get_dsaf_dev(handle->dev), port);
-        *rx_frames = hns_rcb_get_coalesced_frames(
-                hns_ae_get_dsaf_dev(handle->dev), port);
+        *tx_frames = hns_rcb_get_coalesced_frames(ring_pair->rcb_common,
+                                                  ring_pair->port_id_in_comm);
+        *rx_frames = hns_rcb_get_coalesced_frames(ring_pair->rcb_common,
+                                                  ring_pair->port_id_in_comm);
 }
 
-static void hns_ae_set_coalesce_usecs(struct hnae_handle *handle,
-                                      u32 timeout)
+static int hns_ae_set_coalesce_usecs(struct hnae_handle *handle,
+                                     u32 timeout)
 {
-        int port;
-
-        assert(handle);
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        hns_rcb_set_coalesce_usecs(hns_ae_get_dsaf_dev(handle->dev),
-                                   port, timeout);
+        return hns_rcb_set_coalesce_usecs(
+                ring_pair->rcb_common, ring_pair->port_id_in_comm, timeout);
 }
 
 static int  hns_ae_set_coalesce_frames(struct hnae_handle *handle,
                                        u32 coalesce_frames)
 {
-        int port;
-        int ret;
-
-        assert(handle);
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
-
-        ret = hns_rcb_set_coalesced_frames(hns_ae_get_dsaf_dev(handle->dev),
-                                           port, coalesce_frames);
-        return ret;
+        return hns_rcb_set_coalesced_frames(
+                ring_pair->rcb_common,
+                ring_pair->port_id_in_comm, coalesce_frames);
 }
 
 void hns_ae_update_stats(struct hnae_handle *handle,
@@ -787,7 +787,8 @@ static int hns_ae_get_rss(struct hnae_handle *handle, u32 *indir, u8 *key,
                 memcpy(key, ppe_cb->rss_key, HNS_PPEV2_RSS_KEY_SIZE);
 
         /* update the current hash->queue mappings from the shadow RSS table */
-        memcpy(indir, ppe_cb->rss_indir_table, HNS_PPEV2_RSS_IND_TBL_SIZE);
+        memcpy(indir, ppe_cb->rss_indir_table,
+               HNS_PPEV2_RSS_IND_TBL_SIZE * sizeof(*indir));
 
         return 0;
 }
@@ -799,10 +800,11 @@ static int hns_ae_set_rss(struct hnae_handle *handle, const u32 *indir,
 
         /* set the RSS Hash Key if specififed by the user */
         if (key)
-                hns_ppe_set_rss_key(ppe_cb, (int *)key);
+                hns_ppe_set_rss_key(ppe_cb, (u32 *)key);
 
         /* update the shadow RSS table with user specified qids */
-        memcpy(ppe_cb->rss_indir_table, indir, HNS_PPEV2_RSS_IND_TBL_SIZE);
+        memcpy(ppe_cb->rss_indir_table, indir,
+               HNS_PPEV2_RSS_IND_TBL_SIZE * sizeof(*indir));
 
         /* now update the hardware */
         hns_ppe_set_indir_table(ppe_cb, ppe_cb->rss_indir_table);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
index b8517b00e706..44abb08de155 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
@@ -290,6 +290,24 @@ static int hns_gmac_adjust_link(void *mac_drv, enum mac_speed speed,
         return 0;
 }
 
+static void hns_gmac_set_uc_match(void *mac_drv, u16 en)
+{
+        struct mac_driver *drv = mac_drv;
+
+        dsaf_set_dev_bit(drv, GMAC_REC_FILT_CONTROL_REG,
+                         GMAC_UC_MATCH_EN_B, !en);
+        dsaf_set_dev_bit(drv, GMAC_STATION_ADDR_HIGH_2_REG,
+                         GMAC_ADDR_EN_B, !en);
+}
+
+static void hns_gmac_set_promisc(void *mac_drv, u8 en)
+{
+        struct mac_driver *drv = mac_drv;
+
+        if (drv->mac_cb->mac_type == HNAE_PORT_DEBUG)
+                hns_gmac_set_uc_match(mac_drv, en);
+}
+
 static void hns_gmac_init(void *mac_drv)
 {
         u32 port;
@@ -305,6 +323,8 @@ static void hns_gmac_init(void *mac_drv)
         mdelay(10);
         hns_gmac_disable(mac_drv, MAC_COMM_MODE_RX_AND_TX);
         hns_gmac_tx_loop_pkt_dis(mac_drv);
+        if (drv->mac_cb->mac_type == HNAE_PORT_DEBUG)
+                hns_gmac_set_uc_match(mac_drv, 0);
 }
 
 void hns_gmac_update_stats(void *mac_drv)
@@ -402,14 +422,17 @@ static void hns_gmac_set_mac_addr(void *mac_drv, char *mac_addr)
 {
         struct mac_driver *drv = (struct mac_driver *)mac_drv;
 
-        if (drv->mac_id >= DSAF_SERVICE_NW_NUM) {
-                u32 high_val = mac_addr[1] | (mac_addr[0] << 8);
+        u32 high_val = mac_addr[1] | (mac_addr[0] << 8);
 
-                u32 low_val = mac_addr[5] | (mac_addr[4] << 8)
-                        | (mac_addr[3] << 16) | (mac_addr[2] << 24);
-                dsaf_write_dev(drv, GMAC_STATION_ADDR_LOW_2_REG, low_val);
-                dsaf_write_dev(drv, GMAC_STATION_ADDR_HIGH_2_REG, high_val);
-        }
+        u32 low_val = mac_addr[5] | (mac_addr[4] << 8)
+                | (mac_addr[3] << 16) | (mac_addr[2] << 24);
+
+        u32 val = dsaf_read_dev(drv, GMAC_STATION_ADDR_HIGH_2_REG);
+        u32 sta_addr_en = dsaf_get_bit(val, GMAC_ADDR_EN_B);
+
+        dsaf_write_dev(drv, GMAC_STATION_ADDR_LOW_2_REG, low_val);
+        dsaf_write_dev(drv, GMAC_STATION_ADDR_HIGH_2_REG,
+                       high_val | (sta_addr_en << GMAC_ADDR_EN_B));
 }
 
 static int hns_gmac_config_loopback(void *mac_drv, enum hnae_loop loop_mode,
@@ -641,7 +664,8 @@ static void hns_gmac_get_strings(u32 stringset, u8 *data)
                 return;
 
         for (i = 0; i < ARRAY_SIZE(g_gmac_stats_string); i++) {
-                snprintf(buff, ETH_GSTRING_LEN, g_gmac_stats_string[i].desc);
+                snprintf(buff, ETH_GSTRING_LEN, "%s",
+                         g_gmac_stats_string[i].desc);
                 buff = buff + ETH_GSTRING_LEN;
         }
 }
@@ -699,6 +723,7 @@ void *hns_gmac_config(struct hns_mac_cb *mac_cb, struct mac_params *mac_param)
         mac_drv->get_sset_count = hns_gmac_get_sset_count;
         mac_drv->get_strings = hns_gmac_get_strings;
         mac_drv->update_stats = hns_gmac_update_stats;
+        mac_drv->set_promiscuous = hns_gmac_set_promisc;
 
         return (void *)mac_drv;
 }
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c
index 5ef0e96e918a..10c367d20955 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.c
@@ -439,9 +439,8 @@ int hns_mac_vm_config_bc_en(struct hns_mac_cb *mac_cb, u32 vmid, bool enable)
 
 void hns_mac_reset(struct hns_mac_cb *mac_cb)
 {
-        struct mac_driver *drv;
-
-        drv = hns_mac_get_drv(mac_cb);
+        struct mac_driver *drv = hns_mac_get_drv(mac_cb);
+        bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
 
         drv->mac_init(drv);
 
@@ -456,7 +455,7 @@ void hns_mac_reset(struct hns_mac_cb *mac_cb)
 
         if (drv->mac_pausefrm_cfg) {
                 if (mac_cb->mac_type == HNAE_PORT_DEBUG)
-                        drv->mac_pausefrm_cfg(drv, 0, 0);
+                        drv->mac_pausefrm_cfg(drv, !is_ver1, !is_ver1);
                 else /* mac rx must disable, dsaf pfc close instead of it*/
                         drv->mac_pausefrm_cfg(drv, 0, 1);
         }
@@ -467,8 +466,13 @@ int hns_mac_set_mtu(struct hns_mac_cb *mac_cb, u32 new_mtu)
         struct mac_driver *drv = hns_mac_get_drv(mac_cb);
         u32 buf_size = mac_cb->dsaf_dev->buf_size;
         u32 new_frm = new_mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;
+        u32 max_frm = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver) ?
+                        MAC_MAX_MTU : MAC_MAX_MTU_V2;
+
+        if (mac_cb->mac_type == HNAE_PORT_DEBUG)
+                max_frm = MAC_MAX_MTU_DBG;
 
-        if ((new_mtu < MAC_MIN_MTU) || (new_frm > MAC_MAX_MTU) ||
+        if ((new_mtu < MAC_MIN_MTU) || (new_frm > max_frm) ||
             (new_frm > HNS_RCB_RING_MAX_BD_PER_PKT * buf_size))
                 return -EINVAL;
 
@@ -556,14 +560,6 @@ void hns_mac_get_pauseparam(struct hns_mac_cb *mac_cb, u32 *rx_en, u32 *tx_en)
                 *rx_en = 0;
                 *tx_en = 0;
         }
-
-        /* Due to the chip defect, the service mac's rx pause CAN'T be enabled.
-         * We set the rx pause frm always be true (1), because DSAF deals with
-         * the rx pause frm instead of service mac. After all, we still support
-         * rx pause frm.
-         */
-        if (mac_cb->mac_type == HNAE_PORT_SERVICE)
-                *rx_en = 1;
 }
 
 /**
@@ -597,20 +593,13 @@ int hns_mac_set_autoneg(struct hns_mac_cb *mac_cb, u8 enable)
 int hns_mac_set_pauseparam(struct hns_mac_cb *mac_cb, u32 rx_en, u32 tx_en)
 {
         struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
+        bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
 
-        if (mac_cb->mac_type == HNAE_PORT_SERVICE) {
-                if (!rx_en) {
-                        dev_err(mac_cb->dev, "disable rx_pause is not allowed!");
-                        return -EINVAL;
-                }
-        } else if (mac_cb->mac_type == HNAE_PORT_DEBUG) {
-                if (tx_en || rx_en) {
-                        dev_err(mac_cb->dev, "enable tx_pause or enable rx_pause are not allowed!");
+        if (mac_cb->mac_type == HNAE_PORT_DEBUG) {
+                if (is_ver1 && (tx_en || rx_en)) {
+                        dev_err(mac_cb->dev, "macv1 cann't enable tx/rx_pause!");
                         return -EINVAL;
                 }
-        } else {
-                dev_err(mac_cb->dev, "Unsupport this operation!");
-                return -EINVAL;
         }
 
         if (mac_ctrl_drv->mac_pausefrm_cfg)
@@ -861,6 +850,14 @@ int hns_mac_get_sset_count(struct hns_mac_cb *mac_cb, int stringset)
         return mac_ctrl_drv->get_sset_count(stringset);
 }
 
+void hns_mac_set_promisc(struct hns_mac_cb *mac_cb, u8 en)
+{
+        struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
+
+        if (mac_ctrl_drv->set_promiscuous)
+                mac_ctrl_drv->set_promiscuous(mac_ctrl_drv, en);
+}
+
 int hns_mac_get_regs_count(struct hns_mac_cb *mac_cb)
 {
         struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.h
index 0b052191d751..823b6e78c8aa 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_mac.h
@@ -26,7 +26,9 @@ struct dsaf_device;
 
 #define MAC_DEFAULT_MTU (ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN + ETH_DATA_LEN)
 #define MAC_MAX_MTU             9600
+#define MAC_MAX_MTU_V2          9728
 #define MAC_MIN_MTU             68
+#define MAC_MAX_MTU_DBG         MAC_DEFAULT_MTU
 
 #define MAC_DEFAULT_PAUSE_TIME 0xff
 
@@ -365,7 +367,7 @@ struct mac_driver {
         /*config rx pause enable*/
         void (*set_rx_ignore_pause_frames)(void *mac_drv, u32 enable);
         /* config rx mode for promiscuous*/
-        int (*set_promiscuous)(void *mac_drv, u8 enable);
+        void (*set_promiscuous)(void *mac_drv, u8 enable);
         /* get mac id */
         void (*mac_get_id)(void *mac_drv, u8 *mac_id);
         void (*mac_pausefrm_cfg)(void *mac_drv, u32 rx_en, u32 tx_en);
@@ -453,4 +455,6 @@ int hns_mac_get_regs_count(struct hns_mac_cb *mac_cb);
 void hns_set_led_opt(struct hns_mac_cb *mac_cb);
 int hns_cpld_led_set_id(struct hns_mac_cb *mac_cb,
                         enum hnae_led_state status);
+void hns_mac_set_promisc(struct hns_mac_cb *mac_cb, u8 en);
+
 #endif /* _HNS_DSAF_MAC_H */
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
index 38fc5be3870c..8439f6d8e360 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
@@ -748,8 +748,9 @@ static void hns_dsaf_tbl_stat_en(struct dsaf_device *dsaf_dev)
  */
 static void hns_dsaf_rocee_bp_en(struct dsaf_device *dsaf_dev)
 {
-        dsaf_set_dev_bit(dsaf_dev, DSAF_XGE_CTRL_SIG_CFG_0_REG,
-                         DSAF_FC_XGE_TX_PAUSE_S, 1);
+        if (AE_IS_VER1(dsaf_dev->dsaf_ver))
+                dsaf_set_dev_bit(dsaf_dev, DSAF_XGE_CTRL_SIG_CFG_0_REG,
+                                 DSAF_FC_XGE_TX_PAUSE_S, 1);
 }
 
 /* set msk for dsaf exception irq*/
@@ -1021,12 +1022,52 @@ static void hns_dsaf_tbl_tcam_init(struct dsaf_device *dsaf_dev)
  * @mac_cb: mac contrl block
  */
 static void hns_dsaf_pfc_en_cfg(struct dsaf_device *dsaf_dev,
-                                int mac_id, int en)
+                                int mac_id, int tc_en)
+{
+        dsaf_write_dev(dsaf_dev, DSAF_PFC_EN_0_REG + mac_id * 4, tc_en);
+}
+
+static void hns_dsaf_set_pfc_pause(struct dsaf_device *dsaf_dev,
+                                   int mac_id, int tx_en, int rx_en)
+{
+        if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
+                if (!tx_en || !rx_en)
+                        dev_err(dsaf_dev->dev, "dsaf v1 can not close pfc!\n");
+
+                return;
+        }
+
+        dsaf_set_dev_bit(dsaf_dev, DSAF_PAUSE_CFG_REG + mac_id * 4,
+                         DSAF_PFC_PAUSE_RX_EN_B, !!rx_en);
+        dsaf_set_dev_bit(dsaf_dev, DSAF_PAUSE_CFG_REG + mac_id * 4,
+                         DSAF_PFC_PAUSE_TX_EN_B, !!tx_en);
+}
+
+int hns_dsaf_set_rx_mac_pause_en(struct dsaf_device *dsaf_dev, int mac_id,
+                                 u32 en)
+{
+        if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
+                if (!en)
+                        dev_err(dsaf_dev->dev, "dsafv1 can't close rx_pause!\n");
+
+                return -EINVAL;
+        }
+
+        dsaf_set_dev_bit(dsaf_dev, DSAF_PAUSE_CFG_REG + mac_id * 4,
+                         DSAF_MAC_PAUSE_RX_EN_B, !!en);
+
+        return 0;
+}
+
+void hns_dsaf_get_rx_mac_pause_en(struct dsaf_device *dsaf_dev, int mac_id,
+                                  u32 *en)
 {
-        if (!en)
-                dsaf_write_dev(dsaf_dev, DSAF_PFC_EN_0_REG + mac_id * 4, 0);
+        if (AE_IS_VER1(dsaf_dev->dsaf_ver))
+                *en = 1;
         else
-                dsaf_write_dev(dsaf_dev, DSAF_PFC_EN_0_REG + mac_id * 4, 0xff);
+                *en = dsaf_get_dev_bit(dsaf_dev,
+                                       DSAF_PAUSE_CFG_REG + mac_id * 4,
+                                       DSAF_MAC_PAUSE_RX_EN_B);
 }
 
 /**
@@ -1038,6 +1079,7 @@ static void hns_dsaf_comm_init(struct dsaf_device *dsaf_dev)
 {
         u32 i;
         u32 o_dsaf_cfg;
+        bool is_ver1 = AE_IS_VER1(dsaf_dev->dsaf_ver);
 
         o_dsaf_cfg = dsaf_read_dev(dsaf_dev, DSAF_CFG_0_REG);
         dsaf_set_bit(o_dsaf_cfg, DSAF_CFG_EN_S, dsaf_dev->dsaf_en);
@@ -1063,8 +1105,10 @@ static void hns_dsaf_comm_init(struct dsaf_device *dsaf_dev)
         hns_dsaf_sw_port_type_cfg(dsaf_dev, DSAF_SW_PORT_TYPE_NON_VLAN);
 
         /*set dsaf pfc  to 0 for parseing rx pause*/
-        for (i = 0; i < DSAF_COMM_CHN; i++)
+        for (i = 0; i < DSAF_COMM_CHN; i++) {
                 hns_dsaf_pfc_en_cfg(dsaf_dev, i, 0);
+                hns_dsaf_set_pfc_pause(dsaf_dev, i, is_ver1, is_ver1);
+        }
 
         /*msk and  clr exception irqs */
         for (i = 0; i < DSAF_COMM_CHN; i++) {
@@ -2012,6 +2056,8 @@ void hns_dsaf_update_stats(struct dsaf_device *dsaf_dev, u32 node_num)
 {
         struct dsaf_hw_stats *hw_stats
                 = &dsaf_dev->hw_stats[node_num];
+        bool is_ver1 = AE_IS_VER1(dsaf_dev->dsaf_ver);
+        u32 reg_tmp;
 
         hw_stats->pad_drop += dsaf_read_dev(dsaf_dev,
                 DSAF_INODE_PAD_DISCARD_NUM_0_REG + 0x80 * (u64)node_num);
@@ -2021,8 +2067,12 @@ void hns_dsaf_update_stats(struct dsaf_device *dsaf_dev, u32 node_num)
                 DSAF_INODE_FINAL_IN_PKT_NUM_0_REG + 0x80 * (u64)node_num);
         hw_stats->rx_pkt_id += dsaf_read_dev(dsaf_dev,
                 DSAF_INODE_SBM_PID_NUM_0_REG + 0x80 * (u64)node_num);
-        hw_stats->rx_pause_frame += dsaf_read_dev(dsaf_dev,
-                DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG + 0x80 * (u64)node_num);
+
+        reg_tmp = is_ver1 ? DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG :
+                            DSAFV2_INODE_FINAL_IN_PAUSE_NUM_0_REG;
+        hw_stats->rx_pause_frame +=
+                dsaf_read_dev(dsaf_dev, reg_tmp + 0x80 * (u64)node_num);
+
         hw_stats->release_buf_num += dsaf_read_dev(dsaf_dev,
                 DSAF_INODE_SBM_RELS_NUM_0_REG + 0x80 * (u64)node_num);
         hw_stats->sbm_drop += dsaf_read_dev(dsaf_dev,
@@ -2055,6 +2105,8 @@ void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
         u32 i = 0;
         u32 j;
         u32 *p = data;
+        u32 reg_tmp;
+        bool is_ver1 = AE_IS_VER1(ddev->dsaf_ver);
 
         /* dsaf common registers */
         p[0] = dsaf_read_dev(ddev, DSAF_SRAM_INIT_OVER_0_REG);
@@ -2119,8 +2171,9 @@ void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
                                 DSAF_INODE_FINAL_IN_PKT_NUM_0_REG + j * 0x80);
                 p[190 + i] = dsaf_read_dev(ddev,
                                 DSAF_INODE_SBM_PID_NUM_0_REG + j * 0x80);
-                p[193 + i] = dsaf_read_dev(ddev,
-                                DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG + j * 0x80);
+                reg_tmp = is_ver1 ? DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG :
+                                    DSAFV2_INODE_FINAL_IN_PAUSE_NUM_0_REG;
+                p[193 + i] = dsaf_read_dev(ddev, reg_tmp + j * 0x80);
                 p[196 + i] = dsaf_read_dev(ddev,
                                 DSAF_INODE_SBM_RELS_NUM_0_REG + j * 0x80);
                 p[199 + i] = dsaf_read_dev(ddev,
@@ -2218,17 +2271,17 @@ void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
         /* dsaf onode registers */
         for (i = 0; i < DSAF_XOD_NUM; i++) {
                 p[311 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + i * 0x90);
                 p[319 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + i * 0x90);
                 p[327 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + i * 0x90);
                 p[335 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + i * 0x90);
                 p[343 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + i * 0x90);
                 p[351 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TOKEN_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TOKEN_CFG_0_REG + i * 0x90);
         }
 
         p[359] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_0_0_REG + port * 0x90);
@@ -2367,8 +2420,11 @@ void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
         p[496] = dsaf_read_dev(ddev, DSAF_NETPORT_CTRL_SIG_0_REG + port * 0x4);
         p[497] = dsaf_read_dev(ddev, DSAF_XGE_CTRL_SIG_CFG_0_REG + port * 0x4);
 
+        if (!is_ver1)
+                p[498] = dsaf_read_dev(ddev, DSAF_PAUSE_CFG_REG + port * 0x4);
+
         /* mark end of dsaf regs */
-        for (i = 498; i < 504; i++)
+        for (i = 499; i < 504; i++)
                 p[i] = 0xdddddddd;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.h
index 5fea226efaf3..e8eedc571296 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.h
@@ -417,6 +417,11 @@ void hns_dsaf_get_strings(int stringset, u8 *data, int port);
 void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data);
 int hns_dsaf_get_regs_count(void);
 void hns_dsaf_set_promisc_mode(struct dsaf_device *dsaf_dev, u32 en);
+
+void hns_dsaf_get_rx_mac_pause_en(struct dsaf_device *dsaf_dev, int mac_id,
+                                  u32 *en);
+int hns_dsaf_set_rx_mac_pause_en(struct dsaf_device *dsaf_dev, int mac_id,
+                                 u32 en);
 void hns_dsaf_set_inner_lb(struct dsaf_device *dsaf_dev, u32 mac_id, u32 en);
 
 #endif /* __HNS_DSAF_MAIN_H__ */
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
index 607c3be42241..e69b02287c44 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
@@ -244,31 +244,35 @@ void hns_ppe_com_srst(struct ppe_common_cb *ppe_common, u32 val)
  */
 phy_interface_t hns_mac_get_phy_if(struct hns_mac_cb *mac_cb)
 {
-        u32 hilink3_mode;
-        u32 hilink4_mode;
+        u32 mode;
+        u32 reg;
+        u32 shift;
+        bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
         void __iomem *sys_ctl_vaddr = mac_cb->sys_ctl_vaddr;
-        int dev_id = mac_cb->mac_id;
+        int mac_id = mac_cb->mac_id;
         phy_interface_t phy_if = PHY_INTERFACE_MODE_NA;
 
-        hilink3_mode = dsaf_read_reg(sys_ctl_vaddr, HNS_MAC_HILINK3_REG);
-        hilink4_mode = dsaf_read_reg(sys_ctl_vaddr, HNS_MAC_HILINK4_REG);
-        if (dev_id >= 0 && dev_id <= 3) {
-                if (hilink4_mode == 0)
-                        phy_if = PHY_INTERFACE_MODE_SGMII;
-                else
+        if (is_ver1 && (mac_id >= 6 && mac_id <= 7)) {
+                phy_if = PHY_INTERFACE_MODE_SGMII;
+        } else if (mac_id >= 0 && mac_id <= 3) {
+                reg = is_ver1 ? HNS_MAC_HILINK4_REG : HNS_MAC_HILINK4V2_REG;
+                mode = dsaf_read_reg(sys_ctl_vaddr, reg);
+                /* mac_id 0, 1, 2, 3 ---> hilink4 lane 0, 1, 2, 3 */
+                shift = is_ver1 ? 0 : mac_id;
+                if (dsaf_get_bit(mode, shift))
                         phy_if = PHY_INTERFACE_MODE_XGMII;
-        } else if (dev_id >= 4 && dev_id <= 5) {
-                if (hilink3_mode == 0)
-                        phy_if = PHY_INTERFACE_MODE_SGMII;
                 else
+                        phy_if = PHY_INTERFACE_MODE_SGMII;
+        } else if (mac_id >= 4 && mac_id <= 7) {
+                reg = is_ver1 ? HNS_MAC_HILINK3_REG : HNS_MAC_HILINK3V2_REG;
+                mode = dsaf_read_reg(sys_ctl_vaddr, reg);
+                /* mac_id 4, 5, 6, 7 ---> hilink3 lane 2, 3, 0, 1 */
+                shift = is_ver1 ? 0 : mac_id <= 5 ? mac_id - 2 : mac_id - 6;
+                if (dsaf_get_bit(mode, shift))
                         phy_if = PHY_INTERFACE_MODE_XGMII;
-        } else {
-                phy_if = PHY_INTERFACE_MODE_SGMII;
+                else
+                        phy_if = PHY_INTERFACE_MODE_SGMII;
         }
-
-        dev_dbg(mac_cb->dev,
-                "hilink3_mode=%d, hilink4_mode=%d dev_id=%d, phy_if=%d\n",
-                hilink3_mode, hilink4_mode, dev_id, phy_if);
         return phy_if;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
index f302ef9073c6..ab27b3b14ca3 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.c
@@ -27,7 +27,7 @@ void hns_ppe_set_tso_enable(struct hns_ppe_cb *ppe_cb, u32 value)
 void hns_ppe_set_rss_key(struct hns_ppe_cb *ppe_cb,
                          const u32 rss_key[HNS_PPEV2_RSS_KEY_NUM])
 {
-        int key_item = 0;
+        u32 key_item;
 
         for (key_item = 0; key_item < HNS_PPEV2_RSS_KEY_NUM; key_item++)
                 dsaf_write_dev(ppe_cb, PPEV2_RSS_KEY_REG + key_item * 0x4,
@@ -332,10 +332,12 @@ static void hns_ppe_init_hw(struct hns_ppe_cb *ppe_cb)
         /* clr and msk except irq*/
         hns_ppe_exc_irq_en(ppe_cb, 0);
 
-        if (ppe_common_cb->ppe_mode == PPE_COMMON_MODE_DEBUG)
+        if (ppe_common_cb->ppe_mode == PPE_COMMON_MODE_DEBUG) {
                 hns_ppe_set_port_mode(ppe_cb, PPE_MODE_GE);
-        else
+                dsaf_write_dev(ppe_cb, PPE_CFG_PAUSE_IDLE_CNT_REG, 0);
+        } else {
                 hns_ppe_set_port_mode(ppe_cb, PPE_MODE_XGE);
+        }
 
         hns_ppe_checksum_hw(ppe_cb, 0xffffffff);
         hns_ppe_cnt_clr_ce(ppe_cb);
@@ -343,6 +345,9 @@ static void hns_ppe_init_hw(struct hns_ppe_cb *ppe_cb)
         if (!AE_IS_VER1(dsaf_dev->dsaf_ver)) {
                 hns_ppe_set_vlan_strip(ppe_cb, 0);
 
+                dsaf_write_dev(ppe_cb, PPE_CFG_MAX_FRAME_LEN_REG,
+                               HNS_PPEV2_MAX_FRAME_LEN);
+
                 /* set default RSS key in h/w */
                 hns_ppe_set_rss_key(ppe_cb, ppe_cb->rss_key);
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.h
index 0f5cb6962acf..e9c0ec2fa0dd 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_ppe.h
@@ -30,6 +30,8 @@
 #define HNS_PPEV2_RSS_KEY_SIZE 40 /* in bytes or 320 bits */
 #define HNS_PPEV2_RSS_KEY_NUM (HNS_PPEV2_RSS_KEY_SIZE / sizeof(u32))
 
+#define HNS_PPEV2_MAX_FRAME_LEN 0X980
+
 enum ppe_qid_mode {
         PPE_QID_MODE0 = 0, /* fixed queue id mode */
         PPE_QID_MODE1,     /* switch:128VM non switch:6Port/4VM/4TC */
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
index 12188807468c..28ee26e5c478 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
@@ -215,9 +215,9 @@ static void hns_rcb_ring_init(struct ring_pair_cb *ring_pair, int ring_type)
                 dsaf_write_dev(q, RCB_RING_RX_RING_BD_LEN_REG,
                                bd_size_type);
                 dsaf_write_dev(q, RCB_RING_RX_RING_BD_NUM_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
                 dsaf_write_dev(q, RCB_RING_RX_RING_PKTLINE_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
         } else {
                 dsaf_write_dev(q, RCB_RING_TX_RING_BASEADDR_L_REG,
                                (u32)dma);
@@ -227,9 +227,9 @@ static void hns_rcb_ring_init(struct ring_pair_cb *ring_pair, int ring_type)
                 dsaf_write_dev(q, RCB_RING_TX_RING_BD_LEN_REG,
                                bd_size_type);
                 dsaf_write_dev(q, RCB_RING_TX_RING_BD_NUM_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
                 dsaf_write_dev(q, RCB_RING_TX_RING_PKTLINE_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
         }
 }
 
@@ -256,50 +256,16 @@ static void hns_rcb_set_port_desc_cnt(struct rcb_common_cb *rcb_common,
                        desc_cnt);
 }
 
-/**
- *hns_rcb_set_port_coalesced_frames - set rcb port coalesced frames
- *@rcb_common: rcb_common device
- *@port_idx:port index
- *@coalesced_frames:BD num for coalesced frames
- */
-static int  hns_rcb_set_port_coalesced_frames(struct rcb_common_cb *rcb_common,
-                                              u32 port_idx,
-                                              u32 coalesced_frames)
-{
-        if (coalesced_frames >= rcb_common->desc_num ||
-            coalesced_frames > HNS_RCB_MAX_COALESCED_FRAMES)
-                return -EINVAL;
-
-        dsaf_write_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4,
-                       coalesced_frames);
-        return 0;
-}
-
-/**
- *hns_rcb_get_port_coalesced_frames - set rcb port coalesced frames
- *@rcb_common: rcb_common device
- *@port_idx:port index
- * return coaleseced frames value
- */
-static u32 hns_rcb_get_port_coalesced_frames(struct rcb_common_cb *rcb_common,
-                                             u32 port_idx)
+static void hns_rcb_set_port_timeout(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout)
 {
-        if (port_idx >= HNS_RCB_SERVICE_NW_ENGINE_NUM)
-                port_idx = 0;
-
-        return dsaf_read_dev(rcb_common,
-                             RCB_CFG_PKTLINE_REG + port_idx * 4);
-}
-
-/**
- *hns_rcb_set_timeout - set rcb port coalesced time_out
- *@rcb_common: rcb_common device
- *@time_out:time for coalesced time_out
- */
-static void hns_rcb_set_timeout(struct rcb_common_cb *rcb_common,
-                                u32 timeout)
-{
-        dsaf_write_dev(rcb_common, RCB_CFG_OVERTIME_REG, timeout);
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver))
+                dsaf_write_dev(rcb_common, RCB_CFG_OVERTIME_REG,
+                               timeout * HNS_RCB_CLK_FREQ_MHZ);
+        else
+                dsaf_write_dev(rcb_common,
+                               RCB_PORT_CFG_OVERTIME_REG + port_idx * 4,
+                               timeout);
 }
 
 static int hns_rcb_common_get_port_num(struct rcb_common_cb *rcb_common)
@@ -361,10 +327,11 @@ int hns_rcb_common_init_hw(struct rcb_common_cb *rcb_common)
 
         for (i = 0; i < port_num; i++) {
                 hns_rcb_set_port_desc_cnt(rcb_common, i, rcb_common->desc_num);
-                (void)hns_rcb_set_port_coalesced_frames(
-                        rcb_common, i, rcb_common->coalesced_frames);
+                (void)hns_rcb_set_coalesced_frames(
+                        rcb_common, i, HNS_RCB_DEF_COALESCED_FRAMES);
+                hns_rcb_set_port_timeout(
+                        rcb_common, i, HNS_RCB_DEF_COALESCED_USECS);
         }
-        hns_rcb_set_timeout(rcb_common, rcb_common->timeout);
 
         dsaf_write_dev(rcb_common, RCB_COM_CFG_ENDIAN_REG,
                        HNS_RCB_COMMON_ENDIAN);
@@ -460,7 +427,8 @@ static void hns_rcb_ring_pair_get_cfg(struct ring_pair_cb *ring_pair_cb)
         hns_rcb_ring_get_cfg(&ring_pair_cb->q, TX_RING);
 }
 
-static int hns_rcb_get_port(struct rcb_common_cb *rcb_common, int ring_idx)
+static int hns_rcb_get_port_in_comm(
+        struct rcb_common_cb *rcb_common, int ring_idx)
 {
         int comm_index = rcb_common->comm_index;
         int port;
@@ -470,7 +438,7 @@ static int hns_rcb_get_port(struct rcb_common_cb *rcb_common, int ring_idx)
                 q_num = (int)rcb_common->max_q_per_vf * rcb_common->max_vfn;
                 port = ring_idx / q_num;
         } else {
-                port = HNS_RCB_SERVICE_NW_ENGINE_NUM + comm_index - 1;
+                port = 0; /* config debug-ports port_id_in_comm to 0*/
         }
 
         return port;
@@ -518,7 +486,8 @@ void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common)
                 ring_pair_cb->index = i;
                 ring_pair_cb->q.io_base =
                         RCB_COMM_BASE_TO_RING_BASE(rcb_common->io_base, i);
-                ring_pair_cb->port_id_in_dsa = hns_rcb_get_port(rcb_common, i);
+                ring_pair_cb->port_id_in_comm =
+                        hns_rcb_get_port_in_comm(rcb_common, i);
                 ring_pair_cb->virq[HNS_RCB_IRQ_IDX_TX] =
                 is_ver1 ? irq_of_parse_and_map(np, base_irq_idx + i * 2) :
                           platform_get_irq(pdev, base_irq_idx + i * 3 + 1);
@@ -534,82 +503,95 @@ void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common)
 /**
  *hns_rcb_get_coalesced_frames - get rcb port coalesced frames
  *@rcb_common: rcb_common device
- *@comm_index:port index
- *return coalesced_frames
+ *@port_idx:port id in comm
+ *
+ *Returns: coalesced_frames
  */
-u32 hns_rcb_get_coalesced_frames(struct dsaf_device *dsaf_dev, int port)
+u32 hns_rcb_get_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-
-        return hns_rcb_get_port_coalesced_frames(rcb_comm, port);
+        return dsaf_read_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4);
 }
 
 /**
  *hns_rcb_get_coalesce_usecs - get rcb port coalesced time_out
  *@rcb_common: rcb_common device
- *@comm_index:port index
- *return time_out
+ *@port_idx:port id in comm
+ *
+ *Returns: time_out
  */
-u32 hns_rcb_get_coalesce_usecs(struct dsaf_device *dsaf_dev, int comm_index)
+u32 hns_rcb_get_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx)
 {
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-
-        return rcb_comm->timeout;
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver))
+                return dsaf_read_dev(rcb_common, RCB_CFG_OVERTIME_REG) /
+                       HNS_RCB_CLK_FREQ_MHZ;
+        else
+                return dsaf_read_dev(rcb_common,
+                                     RCB_PORT_CFG_OVERTIME_REG + port_idx * 4);
 }
 
 /**
  *hns_rcb_set_coalesce_usecs - set rcb port coalesced time_out
  *@rcb_common: rcb_common device
- *@comm_index: comm :index
- *@etx_usecs:tx time for coalesced time_out
- *@rx_usecs:rx time for coalesced time_out
+ *@port_idx:port id in comm
+ *@timeout:tx/rx time for coalesced time_out
+ *
+ * Returns:
+ * Zero for success, or an error code in case of failure
  */
-void hns_rcb_set_coalesce_usecs(struct dsaf_device *dsaf_dev,
-                                int port, u32 timeout)
+int hns_rcb_set_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
+        u32 old_timeout = hns_rcb_get_coalesce_usecs(rcb_common, port_idx);
 
-        if (rcb_comm->timeout == timeout)
-                return;
+        if (timeout == old_timeout)
+                return 0;
 
-        if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
-                dev_err(dsaf_dev->dev,
-                        "error: not support coalesce_usecs setting!\n");
-                return;
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) {
+                if (rcb_common->comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+                        dev_err(rcb_common->dsaf_dev->dev,
+                                "error: not support coalesce_usecs setting!\n");
+                        return -EINVAL;
+                }
         }
-        rcb_comm->timeout = timeout;
-        hns_rcb_set_timeout(rcb_comm, rcb_comm->timeout);
+        if (timeout > HNS_RCB_MAX_COALESCED_USECS) {
+                dev_err(rcb_common->dsaf_dev->dev,
+                        "error: not support coalesce %dus!\n", timeout);
+                return -EINVAL;
+        }
+        hns_rcb_set_port_timeout(rcb_common, port_idx, timeout);
+        return 0;
 }
 
 /**
  *hns_rcb_set_coalesced_frames - set rcb coalesced frames
  *@rcb_common: rcb_common device
- *@tx_frames:tx BD num for coalesced frames
- *@rx_frames:rx BD num for coalesced frames
- *Return 0 on success, negative on failure
+ *@port_idx:port id in comm
+ *@coalesced_frames:tx/rx BD num for coalesced frames
+ *
+ * Returns:
+ * Zero for success, or an error code in case of failure
  */
-int hns_rcb_set_coalesced_frames(struct dsaf_device *dsaf_dev,
-                                 int port, u32 coalesced_frames)
+int hns_rcb_set_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-        u32 coalesced_reg_val;
-        int ret;
+        u32 old_waterline = hns_rcb_get_coalesced_frames(rcb_common, port_idx);
 
-        coalesced_reg_val = hns_rcb_get_port_coalesced_frames(rcb_comm, port);
-
-        if (coalesced_reg_val == coalesced_frames)
+        if (coalesced_frames == old_waterline)
                 return 0;
 
-        if (coalesced_frames >= HNS_RCB_MIN_COALESCED_FRAMES) {
-                ret = hns_rcb_set_port_coalesced_frames(rcb_comm, port,
-                                                        coalesced_frames);
-                return ret;
-        } else {
+        if (coalesced_frames >= rcb_common->desc_num ||
+            coalesced_frames > HNS_RCB_MAX_COALESCED_FRAMES ||
+            coalesced_frames < HNS_RCB_MIN_COALESCED_FRAMES) {
+                dev_err(rcb_common->dsaf_dev->dev,
+                        "error: not support coalesce_frames setting!\n");
                 return -EINVAL;
         }
+
+        dsaf_write_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4,
+                       coalesced_frames);
+        return 0;
 }
 
 /**
@@ -749,8 +731,6 @@ int hns_rcb_common_get_cfg(struct dsaf_device *dsaf_dev,
         rcb_common->dsaf_dev = dsaf_dev;
 
         rcb_common->desc_num = dsaf_dev->desc_num;
-        rcb_common->coalesced_frames = HNS_RCB_DEF_COALESCED_FRAMES;
-        rcb_common->timeout = HNS_RCB_MAX_TIME_OUT;
 
         hns_rcb_get_queue_mode(dsaf_mode, comm_index, &max_vfn, &max_q_per_vf);
         rcb_common->max_vfn = max_vfn;
@@ -951,6 +931,10 @@ void hns_rcb_get_strings(int stringset, u8 *data, int index)
 void hns_rcb_get_common_regs(struct rcb_common_cb *rcb_com, void *data)
 {
         u32 *regs = data;
+        bool is_ver1 = AE_IS_VER1(rcb_com->dsaf_dev->dsaf_ver);
+        bool is_dbg = (rcb_com->comm_index != HNS_DSAF_COMM_SERVICE_NW_IDX);
+        u32 reg_tmp;
+        u32 reg_num_tmp;
         u32 i = 0;
 
         /*rcb common registers */
@@ -1004,12 +988,16 @@ void hns_rcb_get_common_regs(struct rcb_common_cb *rcb_com, void *data)
                         = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_REG + 4 * i);
         }
 
-        regs[70] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_REG);
-        regs[71] = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_INT_NUM_REG);
-        regs[72] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_INT_NUM_REG);
+        reg_tmp = is_ver1 ? RCB_CFG_OVERTIME_REG : RCB_PORT_CFG_OVERTIME_REG;
+        reg_num_tmp = (is_ver1 || is_dbg) ? 1 : 6;
+        for (i = 0; i < reg_num_tmp; i++)
+                regs[70 + i] = dsaf_read_dev(rcb_com, reg_tmp);
+
+        regs[76] = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_INT_NUM_REG);
+        regs[77] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_INT_NUM_REG);
 
         /* mark end of rcb common regs */
-        for (i = 73; i < 80; i++)
+        for (i = 78; i < 80; i++)
                 regs[i] = 0xcccccccc;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
index 81fe9f849973..eb61014ad615 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
@@ -38,7 +38,9 @@ struct rcb_common_cb;
 #define HNS_RCB_MAX_COALESCED_FRAMES            1023
 #define HNS_RCB_MIN_COALESCED_FRAMES            1
 #define HNS_RCB_DEF_COALESCED_FRAMES            50
-#define HNS_RCB_MAX_TIME_OUT                    0x500
+#define HNS_RCB_CLK_FREQ_MHZ                    350
+#define HNS_RCB_MAX_COALESCED_USECS             0x3ff
+#define HNS_RCB_DEF_COALESCED_USECS             3
 
 #define HNS_RCB_COMMON_ENDIAN                   1
 
@@ -82,7 +84,7 @@ struct ring_pair_cb {
 
         int virq[HNS_RCB_IRQ_NUM_PER_QUEUE];
 
-        u8 port_id_in_dsa;
+        u8 port_id_in_comm;
         u8 used_by_vf;
 
         struct hns_ring_hw_stats hw_stats;
@@ -97,8 +99,6 @@ struct rcb_common_cb {
 
         u8 comm_index;
         u32 ring_num;
-        u32 coalesced_frames; /* frames  threshold of  rx interrupt   */
-        u32 timeout; /* time threshold of  rx interrupt  */
         u32 desc_num; /*  desc num per queue*/
 
         struct ring_pair_cb ring_pair_cb[0];
@@ -125,13 +125,14 @@ void hns_rcbv2_int_clr_hw(struct hnae_queue *q, u32 flag);
 void hns_rcb_init_hw(struct ring_pair_cb *ring);
 void hns_rcb_reset_ring_hw(struct hnae_queue *q);
 void hns_rcb_wait_fbd_clean(struct hnae_queue **qs, int q_num, u32 flag);
-
-u32 hns_rcb_get_coalesced_frames(struct dsaf_device *dsaf_dev, int comm_index);
-u32 hns_rcb_get_coalesce_usecs(struct dsaf_device *dsaf_dev, int comm_index);
-void hns_rcb_set_coalesce_usecs(struct dsaf_device *dsaf_dev,
-                                int comm_index, u32 timeout);
-int hns_rcb_set_coalesced_frames(struct dsaf_device *dsaf_dev,
-                                 int comm_index, u32 coalesce_frames);
+u32 hns_rcb_get_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx);
+u32 hns_rcb_get_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx);
+int hns_rcb_set_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout);
+int hns_rcb_set_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames);
 void hns_rcb_update_stats(struct hnae_queue *queue);
 
 void hns_rcb_get_stats(struct hnae_queue *queue, u64 *data);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
index 60d695daa471..7ff195e60b02 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
@@ -103,6 +103,8 @@
 /*serdes offset**/
 #define HNS_MAC_HILINK3_REG DSAF_SUB_SC_HILINK3_CRG_CTRL0_REG
 #define HNS_MAC_HILINK4_REG DSAF_SUB_SC_HILINK4_CRG_CTRL0_REG
+#define HNS_MAC_HILINK3V2_REG DSAF_SUB_SC_HILINK3_CRG_CTRL1_REG
+#define HNS_MAC_HILINK4V2_REG DSAF_SUB_SC_HILINK4_CRG_CTRL1_REG
 #define HNS_MAC_LANE0_CTLEDFE_REG 0x000BFFCCULL
 #define HNS_MAC_LANE1_CTLEDFE_REG 0x000BFFBCULL
 #define HNS_MAC_LANE2_CTLEDFE_REG 0x000BFFACULL
@@ -135,6 +137,7 @@
 #define DSAF_PPE_INT_STS_0_REG          0x1E0
 #define DSAF_ROCEE_INT_STS_0_REG        0x200
 #define DSAFV2_SERDES_LBK_0_REG         0x220
+#define DSAF_PAUSE_CFG_REG              0x240
 #define DSAF_PPE_QID_CFG_0_REG          0x300
 #define DSAF_SW_PORT_TYPE_0_REG         0x320
 #define DSAF_STP_PORT_TYPE_0_REG        0x340
@@ -153,6 +156,7 @@
 #define DSAF_INODE_FINAL_IN_PKT_NUM_0_REG       0x1030
 #define DSAF_INODE_SBM_PID_NUM_0_REG            0x1038
 #define DSAF_INODE_FINAL_IN_PAUSE_NUM_0_REG     0x103C
+#define DSAFV2_INODE_FINAL_IN_PAUSE_NUM_0_REG   0x1024
 #define DSAF_INODE_SBM_RELS_NUM_0_REG           0x104C
 #define DSAF_INODE_SBM_DROP_NUM_0_REG           0x1050
 #define DSAF_INODE_CRC_FALSE_NUM_0_REG          0x1054
@@ -404,6 +408,7 @@
 #define RCB_CFG_OVERTIME_REG                    0x9300
 #define RCB_CFG_PKTLINE_INT_NUM_REG             0x9304
 #define RCB_CFG_OVERTIME_INT_NUM_REG            0x9308
+#define RCB_PORT_CFG_OVERTIME_REG               0x9430
 
 #define RCB_RING_RX_RING_BASEADDR_L_REG         0x00000
 #define RCB_RING_RX_RING_BASEADDR_H_REG         0x00004
@@ -708,6 +713,10 @@
 #define DSAF_PFC_UNINT_CNT_M ((1ULL << 9) - 1)
 #define DSAF_PFC_UNINT_CNT_S 0
 
+#define DSAF_MAC_PAUSE_RX_EN_B 2
+#define DSAF_PFC_PAUSE_RX_EN_B 1
+#define DSAF_PFC_PAUSE_TX_EN_B 0
+
 #define DSAF_PPE_QID_CFG_M 0xFF
 #define DSAF_PPE_QID_CFG_S 0
 
@@ -922,6 +931,8 @@
 #define GMAC_LP_REG_CF2MI_LP_EN_B       2
 
 #define GMAC_MODE_CHANGE_EB_B   0
+#define GMAC_UC_MATCH_EN_B      0
+#define GMAC_ADDR_EN_B          16
 
 #define GMAC_RECV_CTRL_STRIP_PAD_EN_B   3
 #define GMAC_RECV_CTRL_RUNT_PKT_EN_B    4
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c
index 802d55457f19..fd90f3737963 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_xgmac.c
@@ -7,7 +7,7 @@
  * (at your option) any later version.
  */
 
-#include <asm-generic/io-64-nonatomic-hi-lo.h>
+#include <linux/io-64-nonatomic-hi-lo.h>
 #include <linux/of_mdio.h>
 #include "hns_dsaf_main.h"
 #include "hns_dsaf_mac.h"
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
index 3f77ff77abbc..687204b780b0 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
@@ -48,7 +48,6 @@ static void fill_v2_desc(struct hnae_ring *ring, void *priv,
         struct iphdr *iphdr;
         struct ipv6hdr *ipv6hdr;
         struct sk_buff *skb;
-        int skb_tmp_len;
         __be16 protocol;
         u8 bn_pid = 0;
         u8 rrcfv = 0;
@@ -66,10 +65,14 @@ static void fill_v2_desc(struct hnae_ring *ring, void *priv,
         desc->addr = cpu_to_le64(dma);
         desc->tx.send_size = cpu_to_le16((u16)size);
 
-        /*config bd buffer end */
+        /* config bd buffer end */
         hnae_set_bit(rrcfv, HNSV2_TXD_VLD_B, 1);
         hnae_set_field(bn_pid, HNSV2_TXD_BUFNUM_M, 0, buf_num - 1);
 
+        /* fill port_id in the tx bd for sending management pkts */
+        hnae_set_field(bn_pid, HNSV2_TXD_PORTID_M,
+                       HNSV2_TXD_PORTID_S, ring->q->handle->dport_id);
+
         if (type == DESC_TYPE_SKB) {
                 skb = (struct sk_buff *)priv;
 
@@ -90,13 +93,13 @@ static void fill_v2_desc(struct hnae_ring *ring, void *priv,
                                 hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1);
 
                                 /* check for tcp/udp header */
-                                if (iphdr->protocol == IPPROTO_TCP) {
+                                if (iphdr->protocol == IPPROTO_TCP &&
+                                    skb_is_gso(skb)) {
                                         hnae_set_bit(tvsvsn,
                                                      HNSV2_TXD_TSE_B, 1);
-                                        skb_tmp_len = SKB_TMP_LEN(skb);
                                         l4_len = tcp_hdrlen(skb);
-                                        mss = mtu - skb_tmp_len - ETH_FCS_LEN;
-                                        paylen = skb->len - skb_tmp_len;
+                                        mss = skb_shinfo(skb)->gso_size;
+                                        paylen = skb->len - SKB_TMP_LEN(skb);
                                 }
                         } else if (skb->protocol == htons(ETH_P_IPV6)) {
                                 hnae_set_bit(tvsvsn, HNSV2_TXD_IPV6_B, 1);
@@ -104,13 +107,13 @@ static void fill_v2_desc(struct hnae_ring *ring, void *priv,
                                 hnae_set_bit(rrcfv, HNSV2_TXD_L4CS_B, 1);
 
                                 /* check for tcp/udp header */
-                                if (ipv6hdr->nexthdr == IPPROTO_TCP) {
+                                if (ipv6hdr->nexthdr == IPPROTO_TCP &&
+                                    skb_is_gso(skb) && skb_is_gso_v6(skb)) {
                                         hnae_set_bit(tvsvsn,
                                                      HNSV2_TXD_TSE_B, 1);
-                                        skb_tmp_len = SKB_TMP_LEN(skb);
                                         l4_len = tcp_hdrlen(skb);
-                                        mss = mtu - skb_tmp_len - ETH_FCS_LEN;
-                                        paylen = skb->len - skb_tmp_len;
+                                        mss = skb_shinfo(skb)->gso_size;
+                                        paylen = skb->len - SKB_TMP_LEN(skb);
                                 }
                         }
                         desc->tx.ip_offset = ip_offset;
@@ -564,6 +567,7 @@ static int hns_nic_poll_rx_skb(struct hns_nic_ring_data *ring_data,
         struct sk_buff *skb;
         struct hnae_desc *desc;
         struct hnae_desc_cb *desc_cb;
+        struct ethhdr *eh;
         unsigned char *va;
         int bnum, length, i;
         int pull_len;
@@ -670,6 +674,14 @@ out_bnum_err:
                 return -EFAULT;
         }
 
+        /* filter out multicast pkt with the same src mac as this port */
+        eh = eth_hdr(skb);
+        if (unlikely(is_multicast_ether_addr(eh->h_dest) &&
+                     ether_addr_equal(ndev->dev_addr, eh->h_source))) {
+                dev_kfree_skb_any(skb);
+                return -EFAULT;
+        }
+
         ring->stats.rx_pkts++;
         ring->stats.rx_bytes += skb->len;
 
@@ -901,10 +913,7 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data,
 static void hns_nic_tx_fini_pro(struct hns_nic_ring_data *ring_data)
 {
         struct hnae_ring *ring = ring_data->ring;
-        int head = ring->next_to_clean;
-
-        /* for hardware bug fixed */
-        head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
+        int head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
 
         if (head != ring->next_to_clean) {
                 ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
@@ -947,8 +956,8 @@ static int hns_nic_common_poll(struct napi_struct *napi, int budget)
                 napi_complete(napi);
                 ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
                         ring_data->ring, 0);
-
-                ring_data->fini_process(ring_data);
+                if (ring_data->fini_process)
+                        ring_data->fini_process(ring_data);
                 return 0;
         }
 
@@ -1711,6 +1720,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
 {
         struct hnae_handle *h = priv->ae_handle;
         struct hns_nic_ring_data *rd;
+        bool is_ver1 = AE_IS_VER1(priv->enet_ver);
         int i;
 
         if (h->q_num > NIC_MAX_Q_PER_VF) {
@@ -1728,7 +1738,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
                 rd->queue_index = i;
                 rd->ring = &h->qs[i]->tx_ring;
                 rd->poll_one = hns_nic_tx_poll_one;
-                rd->fini_process = hns_nic_tx_fini_pro;
+                rd->fini_process = is_ver1 ? hns_nic_tx_fini_pro : NULL;
 
                 netif_napi_add(priv->netdev, &rd->napi,
                                hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM);
@@ -1740,7 +1750,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
                 rd->ring = &h->qs[i - h->q_num]->rx_ring;
                 rd->poll_one = hns_nic_rx_poll_one;
                 rd->ex_process = hns_nic_rx_up_pro;
-                rd->fini_process = hns_nic_rx_fini_pro;
+                rd->fini_process = is_ver1 ? hns_nic_rx_fini_pro : NULL;
 
                 netif_napi_add(priv->netdev, &rd->napi,
                                hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM);
@@ -1804,7 +1814,7 @@ static int hns_nic_try_get_ae(struct net_device *ndev)
         h = hnae_get_handle(&priv->netdev->dev,
                             priv->ae_node, priv->port_id, NULL);
         if (IS_ERR_OR_NULL(h)) {
-                ret = PTR_ERR(h);
+                ret = -ENODEV;
                 dev_dbg(priv->dev, "has not handle, register notifier!\n");
                 goto out;
         }
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
index 3c4a3bc31a89..3d746c887873 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
@@ -794,8 +794,10 @@ static int hns_set_coalesce(struct net_device *net_dev,
             (!ops->set_coalesce_frames))
                 return -ESRCH;
 
-        ops->set_coalesce_usecs(priv->ae_handle,
-                                        ec->rx_coalesce_usecs);
+        ret = ops->set_coalesce_usecs(priv->ae_handle,
+                                      ec->rx_coalesce_usecs);
+        if (ret)
+                return ret;
 
         ret = ops->set_coalesce_frames(
                 priv->ae_handle,
@@ -1013,8 +1015,8 @@ int hns_phy_led_set(struct net_device *netdev, int value)
         struct phy_device *phy_dev = priv->phy;
 
         retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_LED);
-        retval = phy_write(phy_dev, HNS_LED_FC_REG, value);
-        retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
+        retval |= phy_write(phy_dev, HNS_LED_FC_REG, value);
+        retval |= phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
         if (retval) {
                 netdev_err(netdev, "mdiobus_write fail !\n");
                 return retval;
@@ -1173,18 +1175,15 @@ hns_get_rss_key_size(struct net_device *netdev)
 {
         struct hns_nic_priv *priv = netdev_priv(netdev);
         struct hnae_ae_ops *ops;
-        u32 ret;
 
         if (AE_IS_VER1(priv->enet_ver)) {
                 netdev_err(netdev,
                            "RSS feature is not supported on this hardware\n");
-                return -EOPNOTSUPP;
+                return 0;
         }
 
         ops = priv->ae_handle->dev->ops;
-        ret = ops->get_rss_key_size(priv->ae_handle);
-
-        return ret;
+        return ops->get_rss_key_size(priv->ae_handle);
 }
 
 static u32
@@ -1192,18 +1191,15 @@ hns_get_rss_indir_size(struct net_device *netdev)
 {
         struct hns_nic_priv *priv = netdev_priv(netdev);
         struct hnae_ae_ops *ops;
-        u32 ret;
 
         if (AE_IS_VER1(priv->enet_ver)) {
                 netdev_err(netdev,
                            "RSS feature is not supported on this hardware\n");
-                return -EOPNOTSUPP;
+                return 0;
         }
 
         ops = priv->ae_handle->dev->ops;
-        ret = ops->get_rss_indir_size(priv->ae_handle);
-
-        return ret;
+        return ops->get_rss_indir_size(priv->ae_handle);
 }
 
 static int
@@ -1211,7 +1207,6 @@ hns_get_rss(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc)
 {
         struct hns_nic_priv *priv = netdev_priv(netdev);
         struct hnae_ae_ops *ops;
-        int ret;
 
         if (AE_IS_VER1(priv->enet_ver)) {
                 netdev_err(netdev,
@@ -1224,9 +1219,7 @@ hns_get_rss(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc)
         if (!indir)
                 return 0;
 
-        ret = ops->get_rss(priv->ae_handle, indir, key, hfunc);
-
-        return 0;
+        return ops->get_rss(priv->ae_handle, indir, key, hfunc);
 }
 
 static int
@@ -1235,7 +1228,6 @@ hns_set_rss(struct net_device *netdev, const u32 *indir, const u8 *key,
 {
         struct hns_nic_priv *priv = netdev_priv(netdev);
         struct hnae_ae_ops *ops;
-        int ret;
 
         if (AE_IS_VER1(priv->enet_ver)) {
                 netdev_err(netdev,
@@ -1252,7 +1244,22 @@ hns_set_rss(struct net_device *netdev, const u32 *indir, const u8 *key,
         if (!indir)
                 return 0;
 
-        ret = ops->set_rss(priv->ae_handle, indir, key, hfunc);
+        return ops->set_rss(priv->ae_handle, indir, key, hfunc);
+}
+
+static int hns_get_rxnfc(struct net_device *netdev,
+                         struct ethtool_rxnfc *cmd,
+                         u32 *rule_locs)
+{
+        struct hns_nic_priv *priv = netdev_priv(netdev);
+
+        switch (cmd->cmd) {
+        case ETHTOOL_GRXRINGS:
+                cmd->data = priv->ae_handle->q_num;
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
 
         return 0;
 }
@@ -1280,6 +1287,7 @@ static struct ethtool_ops hns_ethtool_ops = {
         .get_rxfh_indir_size = hns_get_rss_indir_size,
         .get_rxfh = hns_get_rss,
         .set_rxfh = hns_set_rss,
+        .get_rxnfc = hns_get_rxnfc,
 };
 
 void hns_ethtool_set_ops(struct net_device *ndev)
diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c
index 6e9e16eee5d0..864cb21351a4 100644
--- a/drivers/net/ethernet/ibm/ibmvnic.c
+++ b/drivers/net/ethernet/ibm/ibmvnic.c
@@ -61,6 +61,7 @@
 #include <linux/proc_fs.h>
 #include <linux/in.h>
 #include <linux/ip.h>
+#include <linux/ipv6.h>
 #include <linux/irq.h>
 #include <linux/kthread.h>
 #include <linux/seq_file.h>
@@ -94,6 +95,7 @@ static int ibmvnic_reenable_crq_queue(struct ibmvnic_adapter *);
 static int ibmvnic_send_crq(struct ibmvnic_adapter *, union ibmvnic_crq *);
 static int send_subcrq(struct ibmvnic_adapter *adapter, u64 remote_handle,
                        union sub_crq *sub_crq);
+static int send_subcrq_indirect(struct ibmvnic_adapter *, u64, u64, u64);
 static irqreturn_t ibmvnic_interrupt_rx(int irq, void *instance);
 static int enable_scrq_irq(struct ibmvnic_adapter *,
                            struct ibmvnic_sub_crq_queue *);
@@ -561,10 +563,141 @@ static int ibmvnic_close(struct net_device *netdev)
         return 0;
 }
 
+/**
+ * build_hdr_data - creates L2/L3/L4 header data buffer
+ * @hdr_field - bitfield determining needed headers
+ * @skb - socket buffer
+ * @hdr_len - array of header lengths
+ * @tot_len - total length of data
+ *
+ * Reads hdr_field to determine which headers are needed by firmware.
+ * Builds a buffer containing these headers.  Saves individual header
+ * lengths and total buffer length to be used to build descriptors.
+ */
+static int build_hdr_data(u8 hdr_field, struct sk_buff *skb,
+                          int *hdr_len, u8 *hdr_data)
+{
+        int len = 0;
+        u8 *hdr;
+
+        hdr_len[0] = sizeof(struct ethhdr);
+
+        if (skb->protocol == htons(ETH_P_IP)) {
+                hdr_len[1] = ip_hdr(skb)->ihl * 4;
+                if (ip_hdr(skb)->protocol == IPPROTO_TCP)
+                        hdr_len[2] = tcp_hdrlen(skb);
+                else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
+                        hdr_len[2] = sizeof(struct udphdr);
+        } else if (skb->protocol == htons(ETH_P_IPV6)) {
+                hdr_len[1] = sizeof(struct ipv6hdr);
+                if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
+                        hdr_len[2] = tcp_hdrlen(skb);
+                else if (ipv6_hdr(skb)->nexthdr == IPPROTO_UDP)
+                        hdr_len[2] = sizeof(struct udphdr);
+        }
+
+        memset(hdr_data, 0, 120);
+        if ((hdr_field >> 6) & 1) {
+                hdr = skb_mac_header(skb);
+                memcpy(hdr_data, hdr, hdr_len[0]);
+                len += hdr_len[0];
+        }
+
+        if ((hdr_field >> 5) & 1) {
+                hdr = skb_network_header(skb);
+                memcpy(hdr_data + len, hdr, hdr_len[1]);
+                len += hdr_len[1];
+        }
+
+        if ((hdr_field >> 4) & 1) {
+                hdr = skb_transport_header(skb);
+                memcpy(hdr_data + len, hdr, hdr_len[2]);
+                len += hdr_len[2];
+        }
+        return len;
+}
+
+/**
+ * create_hdr_descs - create header and header extension descriptors
+ * @hdr_field - bitfield determining needed headers
+ * @data - buffer containing header data
+ * @len - length of data buffer
+ * @hdr_len - array of individual header lengths
+ * @scrq_arr - descriptor array
+ *
+ * Creates header and, if needed, header extension descriptors and
+ * places them in a descriptor array, scrq_arr
+ */
+
+static void create_hdr_descs(u8 hdr_field, u8 *hdr_data, int len, int *hdr_len,
+                             union sub_crq *scrq_arr)
+{
+        union sub_crq hdr_desc;
+        int tmp_len = len;
+        u8 *data, *cur;
+        int tmp;
+
+        while (tmp_len > 0) {
+                cur = hdr_data + len - tmp_len;
+
+                memset(&hdr_desc, 0, sizeof(hdr_desc));
+                if (cur != hdr_data) {
+                        data = hdr_desc.hdr_ext.data;
+                        tmp = tmp_len > 29 ? 29 : tmp_len;
+                        hdr_desc.hdr_ext.first = IBMVNIC_CRQ_CMD;
+                        hdr_desc.hdr_ext.type = IBMVNIC_HDR_EXT_DESC;
+                        hdr_desc.hdr_ext.len = tmp;
+                } else {
+                        data = hdr_desc.hdr.data;
+                        tmp = tmp_len > 24 ? 24 : tmp_len;
+                        hdr_desc.hdr.first = IBMVNIC_CRQ_CMD;
+                        hdr_desc.hdr.type = IBMVNIC_HDR_DESC;
+                        hdr_desc.hdr.len = tmp;
+                        hdr_desc.hdr.l2_len = (u8)hdr_len[0];
+                        hdr_desc.hdr.l3_len = cpu_to_be16((u16)hdr_len[1]);
+                        hdr_desc.hdr.l4_len = (u8)hdr_len[2];
+                        hdr_desc.hdr.flag = hdr_field << 1;
+                }
+                memcpy(data, cur, tmp);
+                tmp_len -= tmp;
+                *scrq_arr = hdr_desc;
+                scrq_arr++;
+        }
+}
+
+/**
+ * build_hdr_descs_arr - build a header descriptor array
+ * @skb - socket buffer
+ * @num_entries - number of descriptors to be sent
+ * @subcrq - first TX descriptor
+ * @hdr_field - bit field determining which headers will be sent
+ *
+ * This function will build a TX descriptor array with applicable
+ * L2/L3/L4 packet header descriptors to be sent by send_subcrq_indirect.
+ */
+
+static void build_hdr_descs_arr(struct ibmvnic_tx_buff *txbuff,
+                                int *num_entries, u8 hdr_field)
+{
+        int hdr_len[3] = {0, 0, 0};
+        int tot_len, len;
+        u8 *hdr_data = txbuff->hdr_data;
+
+        tot_len = build_hdr_data(hdr_field, txbuff->skb, hdr_len,
+                                 txbuff->hdr_data);
+        len = tot_len;
+        len -= 24;
+        if (len > 0)
+                num_entries += len % 29 ? len / 29 + 1 : len / 29;
+        create_hdr_descs(hdr_field, hdr_data, tot_len, hdr_len,
+                         txbuff->indir_arr + 1);
+}
+
 static int ibmvnic_xmit(struct sk_buff *skb, struct net_device *netdev)
 {
         struct ibmvnic_adapter *adapter = netdev_priv(netdev);
         int queue_num = skb_get_queue_mapping(skb);
+        u8 *hdrs = (u8 *)&adapter->tx_rx_desc_req;
         struct device *dev = &adapter->vdev->dev;
         struct ibmvnic_tx_buff *tx_buff = NULL;
         struct ibmvnic_tx_pool *tx_pool;
@@ -579,6 +712,7 @@ static int ibmvnic_xmit(struct sk_buff *skb, struct net_device *netdev)
         unsigned long lpar_rc;
         union sub_crq tx_crq;
         unsigned int offset;
+        int num_entries = 1;
         unsigned char *dst;
         u64 *handle_array;
         int index = 0;
@@ -644,11 +778,35 @@ static int ibmvnic_xmit(struct sk_buff *skb, struct net_device *netdev)
                         tx_crq.v1.flags1 |= IBMVNIC_TX_PROT_UDP;
         }
 
-        if (skb->ip_summed == CHECKSUM_PARTIAL)
+        if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 tx_crq.v1.flags1 |= IBMVNIC_TX_CHKSUM_OFFLOAD;
-
-        lpar_rc = send_subcrq(adapter, handle_array[0], &tx_crq);
-
+                hdrs += 2;
+        }
+        /* determine if l2/3/4 headers are sent to firmware */
+        if ((*hdrs >> 7) & 1 &&
+            (skb->protocol == htons(ETH_P_IP) ||
+             skb->protocol == htons(ETH_P_IPV6))) {
+                build_hdr_descs_arr(tx_buff, &num_entries, *hdrs);
+                tx_crq.v1.n_crq_elem = num_entries;
+                tx_buff->indir_arr[0] = tx_crq;
+                tx_buff->indir_dma = dma_map_single(dev, tx_buff->indir_arr,
+                                                    sizeof(tx_buff->indir_arr),
+                                                    DMA_TO_DEVICE);
+                if (dma_mapping_error(dev, tx_buff->indir_dma)) {
+                        if (!firmware_has_feature(FW_FEATURE_CMO))
+                                dev_err(dev, "tx: unable to map descriptor array\n");
+                        tx_map_failed++;
+                        tx_dropped++;
+                        ret = NETDEV_TX_BUSY;
+                        goto out;
+                }
+                lpar_rc = send_subcrq_indirect(adapter, handle_array[queue_num],
+                                               (u64)tx_buff->indir_dma,
+                                               (u64)num_entries);
+        } else {
+                lpar_rc = send_subcrq(adapter, handle_array[queue_num],
+                                      &tx_crq);
+        }
         if (lpar_rc != H_SUCCESS) {
                 dev_err(dev, "tx failed with code %ld\n", lpar_rc);
 
@@ -832,7 +990,7 @@ restart_poll:
                 netdev->stats.rx_bytes += length;
                 frames_processed++;
         }
-        replenish_pools(adapter);
+        replenish_rx_pool(adapter, &adapter->rx_pool[scrq_num]);
 
         if (frames_processed < budget) {
                 enable_scrq_irq(adapter, adapter->rx_scrq[scrq_num]);
@@ -1159,6 +1317,7 @@ static int ibmvnic_complete_tx(struct ibmvnic_adapter *adapter,
         union sub_crq *next;
         int index;
         int i, j;
+        u8 first;
 
 restart_loop:
         while (pending_scrq(adapter, scrq)) {
@@ -1181,6 +1340,13 @@ restart_loop:
                                 txbuff->data_dma[j] = 0;
                                 txbuff->used_bounce = false;
                         }
+                        /* if sub_crq was sent indirectly */
+                        first = txbuff->indir_arr[0].generic.first;
+                        if (first == IBMVNIC_CRQ_CMD) {
+                                dma_unmap_single(dev, txbuff->indir_dma,
+                                                 sizeof(txbuff->indir_arr),
+                                                 DMA_TO_DEVICE);
+                        }
 
                         if (txbuff->last_frag)
                                 dev_kfree_skb_any(txbuff->skb);
@@ -1261,9 +1427,9 @@ static void init_sub_crqs(struct ibmvnic_adapter *adapter, int retry)
                     entries_page : adapter->max_rx_add_entries_per_subcrq;
 
                 /* Choosing the maximum number of queues supported by firmware*/
-                adapter->req_tx_queues = adapter->min_tx_queues;
-                adapter->req_rx_queues = adapter->min_rx_queues;
-                adapter->req_rx_add_queues = adapter->min_rx_add_queues;
+                adapter->req_tx_queues = adapter->max_tx_queues;
+                adapter->req_rx_queues = adapter->max_rx_queues;
+                adapter->req_rx_add_queues = adapter->max_rx_add_queues;
 
                 adapter->req_mtu = adapter->max_mtu;
         }
@@ -1494,6 +1660,28 @@ static int send_subcrq(struct ibmvnic_adapter *adapter, u64 remote_handle,
         return rc;
 }
 
+static int send_subcrq_indirect(struct ibmvnic_adapter *adapter,
+                                u64 remote_handle, u64 ioba, u64 num_entries)
+{
+        unsigned int ua = adapter->vdev->unit_address;
+        struct device *dev = &adapter->vdev->dev;
+        int rc;
+
+        /* Make sure the hypervisor sees the complete request */
+        mb();
+        rc = plpar_hcall_norets(H_SEND_SUB_CRQ_INDIRECT, ua,
+                                cpu_to_be64(remote_handle),
+                                ioba, num_entries);
+
+        if (rc) {
+                if (rc == H_CLOSED)
+                        dev_warn(dev, "CRQ Queue closed\n");
+                dev_err(dev, "Send (indirect) error (rc=%d)\n", rc);
+        }
+
+        return rc;
+}
+
 static int ibmvnic_send_crq(struct ibmvnic_adapter *adapter,
                             union ibmvnic_crq *crq)
 {
@@ -1589,13 +1777,11 @@ static void send_login(struct ibmvnic_adapter *adapter)
                 goto buf_map_failed;
         }
 
-        rsp_buffer_size =
-            sizeof(struct ibmvnic_login_rsp_buffer) +
-            sizeof(u64) * (adapter->req_tx_queues +
-                           adapter->req_rx_queues *
-                           adapter->req_rx_add_queues + adapter->
-                           req_rx_add_queues) +
-            sizeof(u8) * (IBMVNIC_TX_DESC_VERSIONS);
+        rsp_buffer_size = sizeof(struct ibmvnic_login_rsp_buffer) +
+                          sizeof(u64) * adapter->req_tx_queues +
+                          sizeof(u64) * adapter->req_rx_queues +
+                          sizeof(u64) * adapter->req_rx_queues +
+                          sizeof(u8) * IBMVNIC_TX_DESC_VERSIONS;
 
         login_rsp_buffer = kmalloc(rsp_buffer_size, GFP_ATOMIC);
         if (!login_rsp_buffer)
@@ -1918,6 +2104,10 @@ static void handle_query_ip_offload_rsp(struct ibmvnic_adapter *adapter)
         if (buf->tcp_ipv6_chksum || buf->udp_ipv6_chksum)
                 adapter->netdev->features |= NETIF_F_IPV6_CSUM;
 
+        if ((adapter->netdev->features &
+            (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)))
+                adapter->netdev->features |= NETIF_F_RXCSUM;
+
         memset(&crq, 0, sizeof(crq));
         crq.control_ip_offload.first = IBMVNIC_CRQ_CMD;
         crq.control_ip_offload.cmd = CONTROL_IP_OFFLOAD;
@@ -2210,6 +2400,16 @@ static int handle_login_rsp(union ibmvnic_crq *login_rsp_crq,
         dma_unmap_single(dev, adapter->login_rsp_buf_token,
                          adapter->login_rsp_buf_sz, DMA_BIDIRECTIONAL);
 
+        /* If the number of queues requested can't be allocated by the
+         * server, the login response will return with code 1. We will need
+         * to resend the login buffer with fewer queues requested.
+         */
+        if (login_rsp_crq->generic.rc.code) {
+                adapter->renegotiate = true;
+                complete(&adapter->init_done);
+                return 0;
+        }
+
         netdev_dbg(adapter->netdev, "Login Response Buffer:\n");
         for (i = 0; i < (adapter->login_rsp_buf_sz - 1) / 8 + 1; i++) {
                 netdev_dbg(adapter->netdev, "%016lx\n",
@@ -3437,14 +3637,21 @@ static int ibmvnic_probe(struct vio_dev *dev, const struct vio_device_id *id)
         init_completion(&adapter->init_done);
         wait_for_completion(&adapter->init_done);
 
-        /* needed to pull init_sub_crqs outside of an interrupt context
-         * because it creates IRQ mappings for the subCRQ queues, causing
-         * a kernel warning
-         */
-        init_sub_crqs(adapter, 0);
+        do {
+                adapter->renegotiate = false;
 
-        reinit_completion(&adapter->init_done);
-        wait_for_completion(&adapter->init_done);
+                init_sub_crqs(adapter, 0);
+                reinit_completion(&adapter->init_done);
+                wait_for_completion(&adapter->init_done);
+
+                if (adapter->renegotiate) {
+                        release_sub_crqs(adapter);
+                        send_cap_queries(adapter);
+
+                        reinit_completion(&adapter->init_done);
+                        wait_for_completion(&adapter->init_done);
+                }
+        } while (adapter->renegotiate);
 
         /* if init_sub_crqs is partially successful, retry */
         while (!adapter->tx_scrq || !adapter->rx_scrq) {
diff --git a/drivers/net/ethernet/ibm/ibmvnic.h b/drivers/net/ethernet/ibm/ibmvnic.h
index 1a9993cc79b5..0b66a506a4e4 100644
--- a/drivers/net/ethernet/ibm/ibmvnic.h
+++ b/drivers/net/ethernet/ibm/ibmvnic.h
@@ -879,6 +879,9 @@ struct ibmvnic_tx_buff {
         int pool_index;
         bool last_frag;
         bool used_bounce;
+        union sub_crq indir_arr[6];
+        u8 hdr_data[140];
+        dma_addr_t indir_dma;
 };
 
 struct ibmvnic_tx_pool {
@@ -977,6 +980,7 @@ struct ibmvnic_adapter {
         struct ibmvnic_sub_crq_queue **tx_scrq;
         struct ibmvnic_sub_crq_queue **rx_scrq;
         int requested_caps;
+        bool renegotiate;
 
         /* rx structs */
         struct napi_struct *napi;
diff --git a/drivers/net/ethernet/intel/Kconfig b/drivers/net/ethernet/intel/Kconfig
index 3772f3ac956e..714bd1014ddb 100644
--- a/drivers/net/ethernet/intel/Kconfig
+++ b/drivers/net/ethernet/intel/Kconfig
@@ -25,16 +25,13 @@ config E100
           on the adapter. Look for a label that has a barcode and a number
           in the format 123456-001 (six digits hyphen three digits).
 
-          Use the above information and the Adapter & Driver ID Guide at:
+          Use the above information and the Adapter & Driver ID Guide that
+          can be located at:
 
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
+          <http://support.intel.com>
 
           to identify the adapter.
 
-          For the latest Intel PRO/100 network driver for Linux, see:
-
-          <http://www.intel.com/p/en_US/support/highlights/network/pro100plus>
-
           More specific information on configuring the driver is in
           <file:Documentation/networking/e100.txt>.
 
@@ -47,12 +44,7 @@ config E1000
         ---help---
           This driver supports Intel(R) PRO/1000 gigabit ethernet family of
           adapters.  For more information on how to identify your adapter, go
-          to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -71,12 +63,8 @@ config E1000E
           This driver supports the PCI-Express Intel(R) PRO/1000 gigabit
           ethernet family of adapters. For PCI or PCI-X e1000 adapters,
           use the regular e1000 driver For more information on how to
-          identify your adapter, go to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          identify your adapter, go to the Adapter & Driver ID Guide that
+          can be located at:
 
           <http://support.intel.com>
 
@@ -101,12 +89,7 @@ config IGB
         ---help---
           This driver supports Intel(R) 82575/82576 gigabit ethernet family of
           adapters.  For more information on how to identify your adapter, go
-          to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -142,12 +125,7 @@ config IGBVF
         ---help---
           This driver supports Intel(R) 82576 virtual functions.  For more
           information on how to identify your adapter, go to the Adapter &
-          Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -164,12 +142,7 @@ config IXGB
           This driver supports Intel(R) PRO/10GbE family of adapters for
           PCI-X type cards. For PCI-E type cards, use the "ixgbe" driver
           instead. For more information on how to identify your adapter, go
-          to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -187,12 +160,7 @@ config IXGBE
         ---help---
           This driver supports Intel(R) 10GbE PCI Express family of
           adapters.  For more information on how to identify your adapter, go
-          to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -243,12 +211,7 @@ config IXGBEVF
         ---help---
           This driver supports Intel(R) PCI Express virtual functions for the
           Intel(R) ixgbe driver.  For more information on how to identify your
-          adapter, go to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/sb/CS-008441.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          adapter, go to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -266,12 +229,7 @@ config I40E
         ---help---
           This driver supports Intel(R) Ethernet Controller XL710 Family of
           devices.  For more information on how to identify your adapter, go
-          to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/adapter/pro100/21397.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -326,12 +284,7 @@ config I40EVF
         ---help---
           This driver supports Intel(R) XL710 and X710 virtual functions.
           For more information on how to identify your adapter, go to the
-          Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/sb/CS-008441.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
@@ -347,12 +300,7 @@ config FM10K
         ---help---
           This driver supports Intel(R) FM10000 Ethernet Switch Host
           Interface.  For more information on how to identify your adapter,
-          go to the Adapter & Driver ID Guide at:
-
-          <http://support.intel.com/support/network/sb/CS-008441.htm>
-
-          For general information and support, go to the Intel support
-          website at:
+          go to the Adapter & Driver ID Guide that can be located at:
 
           <http://support.intel.com>
 
diff --git a/drivers/net/ethernet/intel/e1000/e1000.h b/drivers/net/ethernet/intel/e1000/e1000.h
index 98fe5a2cd6e3..d7bdea79e9fa 100644
--- a/drivers/net/ethernet/intel/e1000/e1000.h
+++ b/drivers/net/ethernet/intel/e1000/e1000.h
@@ -358,6 +358,8 @@ struct net_device *e1000_get_hw_dev(struct e1000_hw *hw);
 extern char e1000_driver_name[];
 extern const char e1000_driver_version[];
 
+int e1000_open(struct net_device *netdev);
+int e1000_close(struct net_device *netdev);
 int e1000_up(struct e1000_adapter *adapter);
 void e1000_down(struct e1000_adapter *adapter);
 void e1000_reinit_locked(struct e1000_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
index 83e557c7f279..975eeb885ca2 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
@@ -1553,7 +1553,7 @@ static void e1000_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        e1000_close(netdev);
                 else
                         e1000_reset(adapter);
 
@@ -1582,7 +1582,7 @@ static void e1000_diag_test(struct net_device *netdev,
                 e1000_reset(adapter);
                 clear_bit(__E1000_TESTING, &adapter->flags);
                 if (if_running)
-                        dev_open(netdev);
+                        e1000_open(netdev);
         } else {
                 e_info(hw, "online testing starting\n");
                 /* Online tests */
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 3fc7bde699ba..f42129d09e2c 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -114,8 +114,8 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
 static void e1000_remove(struct pci_dev *pdev);
 static int e1000_alloc_queues(struct e1000_adapter *adapter);
 static int e1000_sw_init(struct e1000_adapter *adapter);
-static int e1000_open(struct net_device *netdev);
-static int e1000_close(struct net_device *netdev);
+int e1000_open(struct net_device *netdev);
+int e1000_close(struct net_device *netdev);
 static void e1000_configure_tx(struct e1000_adapter *adapter);
 static void e1000_configure_rx(struct e1000_adapter *adapter);
 static void e1000_setup_rctl(struct e1000_adapter *adapter);
@@ -1360,7 +1360,7 @@ static int e1000_alloc_queues(struct e1000_adapter *adapter)
  * handler is registered with the OS, the watchdog task is started,
  * and the stack is notified that the interface is ready.
  **/
-static int e1000_open(struct net_device *netdev)
+int e1000_open(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
@@ -1437,7 +1437,7 @@ err_setup_tx:
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int e1000_close(struct net_device *netdev)
+int e1000_close(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
@@ -3106,7 +3106,7 @@ static int e1000_maybe_stop_tx(struct net_device *netdev,
         return __e1000_maybe_stop_tx(netdev, size);
 }
 
-#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1)
+#define TXD_USE_COUNT(S, X) (((S) + ((1 << (X)) - 1)) >> (X))
 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                                     struct net_device *netdev)
 {
@@ -3256,12 +3256,29 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                              nr_frags, mss);
 
         if (count) {
+                /* The descriptors needed is higher than other Intel drivers
+                 * due to a number of workarounds.  The breakdown is below:
+                 * Data descriptors: MAX_SKB_FRAGS + 1
+                 * Context Descriptor: 1
+                 * Keep head from touching tail: 2
+                 * Workarounds: 3
+                 */
+                int desc_needed = MAX_SKB_FRAGS + 7;
+
                 netdev_sent_queue(netdev, skb->len);
                 skb_tx_timestamp(skb);
 
                 e1000_tx_queue(adapter, tx_ring, tx_flags, count);
+
+                /* 82544 potentially requires twice as many data descriptors
+                 * in order to guarantee buffers don't end on evenly-aligned
+                 * dwords
+                 */
+                if (adapter->pcix_82544)
+                        desc_needed += MAX_SKB_FRAGS + 1;
+
                 /* Make sure there is space in the ring for the next send. */
-                e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
+                e1000_maybe_stop_tx(netdev, tx_ring, desc_needed);
 
                 if (!skb->xmit_more ||
                     netif_xmit_stopped(netdev_get_tx_queue(netdev, 0))) {
diff --git a/drivers/net/ethernet/intel/e1000e/e1000.h b/drivers/net/ethernet/intel/e1000e/e1000.h
index 1dc293bad87b..52eb641fc9dc 100644
--- a/drivers/net/ethernet/intel/e1000e/e1000.h
+++ b/drivers/net/ethernet/intel/e1000e/e1000.h
@@ -480,6 +480,8 @@ extern const char e1000e_driver_version[];
 void e1000e_check_options(struct e1000_adapter *adapter);
 void e1000e_set_ethtool_ops(struct net_device *netdev);
 
+int e1000e_open(struct net_device *netdev);
+int e1000e_close(struct net_device *netdev);
 void e1000e_up(struct e1000_adapter *adapter);
 void e1000e_down(struct e1000_adapter *adapter, bool reset);
 void e1000e_reinit_locked(struct e1000_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/e1000e/ethtool.c b/drivers/net/ethernet/intel/e1000e/ethtool.c
index 6cab1f30d41e..1e3973aa707c 100644
--- a/drivers/net/ethernet/intel/e1000e/ethtool.c
+++ b/drivers/net/ethernet/intel/e1000e/ethtool.c
@@ -1816,7 +1816,7 @@ static void e1000_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        e1000e_close(netdev);
 
                 if (e1000_reg_test(adapter, &data[0]))
                         eth_test->flags |= ETH_TEST_FL_FAILED;
@@ -1849,7 +1849,7 @@ static void e1000_diag_test(struct net_device *netdev,
 
                 clear_bit(__E1000_TESTING, &adapter->state);
                 if (if_running)
-                        dev_open(netdev);
+                        e1000e_open(netdev);
         } else {
                 /* Online tests */
 
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 9b4ec13d9161..a7f16c35ebcd 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -4495,7 +4495,7 @@ static int e1000_test_msi(struct e1000_adapter *adapter)
 }
 
 /**
- * e1000_open - Called when a network interface is made active
+ * e1000e_open - Called when a network interface is made active
  * @netdev: network interface device structure
  *
  * Returns 0 on success, negative value on failure
@@ -4506,7 +4506,7 @@ static int e1000_test_msi(struct e1000_adapter *adapter)
  * handler is registered with the OS, the watchdog timer is started,
  * and the stack is notified that the interface is ready.
  **/
-static int e1000_open(struct net_device *netdev)
+int e1000e_open(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
@@ -4604,7 +4604,7 @@ err_setup_tx:
 }
 
 /**
- * e1000_close - Disables a network interface
+ * e1000e_close - Disables a network interface
  * @netdev: network interface device structure
  *
  * Returns 0, this is not allowed to fail
@@ -4614,7 +4614,7 @@ err_setup_tx:
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int e1000_close(struct net_device *netdev)
+int e1000e_close(struct net_device *netdev)
 {
         struct e1000_adapter *adapter = netdev_priv(netdev);
         struct pci_dev *pdev = adapter->pdev;
@@ -6920,8 +6920,8 @@ static int e1000_set_features(struct net_device *netdev,
 }
 
 static const struct net_device_ops e1000e_netdev_ops = {
-        .ndo_open               = e1000_open,
-        .ndo_stop               = e1000_close,
+        .ndo_open               = e1000e_open,
+        .ndo_stop               = e1000e_close,
         .ndo_start_xmit         = e1000_xmit_frame,
         .ndo_get_stats64        = e1000e_get_stats64,
         .ndo_set_rx_mode        = e1000e_set_rx_mode,
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k.h b/drivers/net/ethernet/intel/fm10k/fm10k.h
index b34bb008b104..9c7fafef7cf6 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k.h
+++ b/drivers/net/ethernet/intel/fm10k/fm10k.h
@@ -262,12 +262,12 @@ struct fm10k_intfc {
         unsigned long state;
 
         u32 flags;
-#define FM10K_FLAG_RESET_REQUESTED              (u32)(1 << 0)
-#define FM10K_FLAG_RSS_FIELD_IPV4_UDP           (u32)(1 << 1)
-#define FM10K_FLAG_RSS_FIELD_IPV6_UDP           (u32)(1 << 2)
-#define FM10K_FLAG_RX_TS_ENABLED                (u32)(1 << 3)
-#define FM10K_FLAG_SWPRI_CONFIG                 (u32)(1 << 4)
-#define FM10K_FLAG_DEBUG_STATS                  (u32)(1 << 5)
+#define FM10K_FLAG_RESET_REQUESTED              (u32)(BIT(0))
+#define FM10K_FLAG_RSS_FIELD_IPV4_UDP           (u32)(BIT(1))
+#define FM10K_FLAG_RSS_FIELD_IPV6_UDP           (u32)(BIT(2))
+#define FM10K_FLAG_RX_TS_ENABLED                (u32)(BIT(3))
+#define FM10K_FLAG_SWPRI_CONFIG                 (u32)(BIT(4))
+#define FM10K_FLAG_DEBUG_STATS                  (u32)(BIT(5))
         int xcast_mode;
 
         /* Tx fast path data */
@@ -510,6 +510,8 @@ int fm10k_close(struct net_device *netdev);
 
 /* Ethtool */
 void fm10k_set_ethtool_ops(struct net_device *dev);
+u32 fm10k_get_reta_size(struct net_device *netdev);
+void fm10k_write_reta(struct fm10k_intfc *interface, const u32 *indir);
 
 /* IOV */
 s32 fm10k_iov_event(struct fm10k_intfc *interface);
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c b/drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c
index 2f6a05b57228..a23748777b1b 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_ethtool.c
@@ -153,57 +153,51 @@ static const char fm10k_prv_flags[FM10K_PRV_FLAG_LEN][ETH_GSTRING_LEN] = {
         "debug-statistics",
 };
 
+static void fm10k_add_stat_strings(char **p, const char *prefix,
+                                   const struct fm10k_stats stats[],
+                                   const unsigned int size)
+{
+        unsigned int i;
+
+        for (i = 0; i < size; i++) {
+                snprintf(*p, ETH_GSTRING_LEN, "%s%s",
+                         prefix, stats[i].stat_string);
+                *p += ETH_GSTRING_LEN;
+        }
+}
+
 static void fm10k_get_stat_strings(struct net_device *dev, u8 *data)
 {
         struct fm10k_intfc *interface = netdev_priv(dev);
         struct fm10k_iov_data *iov_data = interface->iov_data;
         char *p = (char *)data;
         unsigned int i;
-        unsigned int j;
 
-        for (i = 0; i < FM10K_NETDEV_STATS_LEN; i++) {
-                memcpy(p, fm10k_gstrings_net_stats[i].stat_string,
-                       ETH_GSTRING_LEN);
-                p += ETH_GSTRING_LEN;
-        }
+        fm10k_add_stat_strings(&p, "", fm10k_gstrings_net_stats,
+                               FM10K_NETDEV_STATS_LEN);
 
-        for (i = 0; i < FM10K_GLOBAL_STATS_LEN; i++) {
-                memcpy(p, fm10k_gstrings_global_stats[i].stat_string,
-                       ETH_GSTRING_LEN);
-                p += ETH_GSTRING_LEN;
-        }
+        fm10k_add_stat_strings(&p, "", fm10k_gstrings_global_stats,
+                               FM10K_GLOBAL_STATS_LEN);
 
-        if (interface->flags & FM10K_FLAG_DEBUG_STATS) {
-                for (i = 0; i < FM10K_DEBUG_STATS_LEN; i++) {
-                        memcpy(p, fm10k_gstrings_debug_stats[i].stat_string,
-                               ETH_GSTRING_LEN);
-                        p += ETH_GSTRING_LEN;
-                }
-        }
+        if (interface->flags & FM10K_FLAG_DEBUG_STATS)
+                fm10k_add_stat_strings(&p, "", fm10k_gstrings_debug_stats,
+                                       FM10K_DEBUG_STATS_LEN);
 
-        for (i = 0; i < FM10K_MBX_STATS_LEN; i++) {
-                memcpy(p, fm10k_gstrings_mbx_stats[i].stat_string,
-                       ETH_GSTRING_LEN);
-                p += ETH_GSTRING_LEN;
-        }
+        fm10k_add_stat_strings(&p, "", fm10k_gstrings_mbx_stats,
+                               FM10K_MBX_STATS_LEN);
 
-        if (interface->hw.mac.type != fm10k_mac_vf) {
-                for (i = 0; i < FM10K_PF_STATS_LEN; i++) {
-                        memcpy(p, fm10k_gstrings_pf_stats[i].stat_string,
-                               ETH_GSTRING_LEN);
-                        p += ETH_GSTRING_LEN;
-                }
-        }
+        if (interface->hw.mac.type != fm10k_mac_vf)
+                fm10k_add_stat_strings(&p, "", fm10k_gstrings_pf_stats,
+                                       FM10K_PF_STATS_LEN);
 
         if ((interface->flags & FM10K_FLAG_DEBUG_STATS) && iov_data) {
                 for (i = 0; i < iov_data->num_vfs; i++) {
-                        for (j = 0; j < FM10K_MBX_STATS_LEN; j++) {
-                                snprintf(p,
-                                         ETH_GSTRING_LEN,
-                                         "vf_%u_%s", i,
-                                         fm10k_gstrings_mbx_stats[j].stat_string);
-                                p += ETH_GSTRING_LEN;
-                        }
+                        char prefix[ETH_GSTRING_LEN];
+
+                        snprintf(prefix, ETH_GSTRING_LEN, "vf_%u_", i);
+                        fm10k_add_stat_strings(&p, prefix,
+                                               fm10k_gstrings_mbx_stats,
+                                               FM10K_MBX_STATS_LEN);
                 }
         }
 
@@ -271,6 +265,41 @@ static int fm10k_get_sset_count(struct net_device *dev, int sset)
         }
 }
 
+static void fm10k_add_ethtool_stats(u64 **data, void *pointer,
+                                    const struct fm10k_stats stats[],
+                                    const unsigned int size)
+{
+        unsigned int i;
+        char *p;
+
+        /* simply skip forward if we were not given a valid pointer */
+        if (!pointer) {
+                *data += size;
+                return;
+        }
+
+        for (i = 0; i < size; i++) {
+                p = (char *)pointer + stats[i].stat_offset;
+
+                switch (stats[i].sizeof_stat) {
+                case sizeof(u64):
+                        *((*data)++) = *(u64 *)p;
+                        break;
+                case sizeof(u32):
+                        *((*data)++) = *(u32 *)p;
+                        break;
+                case sizeof(u16):
+                        *((*data)++) = *(u16 *)p;
+                        break;
+                case sizeof(u8):
+                        *((*data)++) = *(u8 *)p;
+                        break;
+                default:
+                        *((*data)++) = 0;
+                }
+        }
+}
+
 static void fm10k_get_ethtool_stats(struct net_device *netdev,
                                     struct ethtool_stats __always_unused *stats,
                                     u64 *data)
@@ -279,47 +308,29 @@ static void fm10k_get_ethtool_stats(struct net_device *netdev,
         struct fm10k_intfc *interface = netdev_priv(netdev);
         struct fm10k_iov_data *iov_data = interface->iov_data;
         struct net_device_stats *net_stats = &netdev->stats;
-        char *p;
         int i, j;
 
         fm10k_update_stats(interface);
 
-        for (i = 0; i < FM10K_NETDEV_STATS_LEN; i++) {
-                p = (char *)net_stats + fm10k_gstrings_net_stats[i].stat_offset;
-                *(data++) = (fm10k_gstrings_net_stats[i].sizeof_stat ==
-                        sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-        }
+        fm10k_add_ethtool_stats(&data, net_stats, fm10k_gstrings_net_stats,
+                                FM10K_NETDEV_STATS_LEN);
 
-        for (i = 0; i < FM10K_GLOBAL_STATS_LEN; i++) {
-                p = (char *)interface +
-                    fm10k_gstrings_global_stats[i].stat_offset;
-                *(data++) = (fm10k_gstrings_global_stats[i].sizeof_stat ==
-                        sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-        }
+        fm10k_add_ethtool_stats(&data, interface, fm10k_gstrings_global_stats,
+                                FM10K_GLOBAL_STATS_LEN);
 
-        if (interface->flags & FM10K_FLAG_DEBUG_STATS) {
-                for (i = 0; i < FM10K_DEBUG_STATS_LEN; i++) {
-                        p = (char *)interface +
-                                fm10k_gstrings_debug_stats[i].stat_offset;
-                        *(data++) = (fm10k_gstrings_debug_stats[i].sizeof_stat ==
-                                     sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-                }
-        }
+        if (interface->flags & FM10K_FLAG_DEBUG_STATS)
+                fm10k_add_ethtool_stats(&data, interface,
+                                        fm10k_gstrings_debug_stats,
+                                        FM10K_DEBUG_STATS_LEN);
 
-        for (i = 0; i < FM10K_MBX_STATS_LEN; i++) {
-                p = (char *)&interface->hw.mbx +
-                        fm10k_gstrings_mbx_stats[i].stat_offset;
-                *(data++) = (fm10k_gstrings_mbx_stats[i].sizeof_stat ==
-                        sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-        }
+        fm10k_add_ethtool_stats(&data, &interface->hw.mbx,
+                                fm10k_gstrings_mbx_stats,
+                                FM10K_MBX_STATS_LEN);
 
         if (interface->hw.mac.type != fm10k_mac_vf) {
-                for (i = 0; i < FM10K_PF_STATS_LEN; i++) {
-                        p = (char *)interface +
-                            fm10k_gstrings_pf_stats[i].stat_offset;
-                        *(data++) = (fm10k_gstrings_pf_stats[i].sizeof_stat ==
-                                     sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-                }
+                fm10k_add_ethtool_stats(&data, interface,
+                                        fm10k_gstrings_pf_stats,
+                                        FM10K_PF_STATS_LEN);
         }
 
         if ((interface->flags & FM10K_FLAG_DEBUG_STATS) && iov_data) {
@@ -328,18 +339,9 @@ static void fm10k_get_ethtool_stats(struct net_device *netdev,
 
                         vf_info = &iov_data->vf_info[i];
 
-                        /* skip stats if we don't have a vf info */
-                        if (!vf_info) {
-                                data += FM10K_MBX_STATS_LEN;
-                                continue;
-                        }
-
-                        for (j = 0; j < FM10K_MBX_STATS_LEN; j++) {
-                                p = (char *)&vf_info->mbx +
-                                        fm10k_gstrings_mbx_stats[j].stat_offset;
-                                *(data++) = (fm10k_gstrings_mbx_stats[j].sizeof_stat ==
-                                             sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
-                        }
+                        fm10k_add_ethtool_stats(&data, &vf_info->mbx,
+                                                fm10k_gstrings_mbx_stats,
+                                                FM10K_MBX_STATS_LEN);
                 }
         }
 
@@ -425,7 +427,7 @@ static void fm10k_get_regs(struct net_device *netdev,
         u32 *buff = p;
         u16 i;
 
-        regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
+        regs->version = BIT(24) | (hw->revision_id << 16) | hw->device_id;
 
         switch (hw->mac.type) {
         case fm10k_mac_pf:
@@ -935,15 +937,15 @@ static int fm10k_mbx_test(struct fm10k_intfc *interface, u64 *data)
         struct fm10k_mbx_info *mbx = &hw->mbx;
         u32 attr_flag, test_msg[6];
         unsigned long timeout;
-        int err;
+        int err = -EINVAL;
 
         /* For now this is a VF only feature */
         if (hw->mac.type != fm10k_mac_vf)
                 return 0;
 
         /* loop through both nested and unnested attribute types */
-        for (attr_flag = (1 << FM10K_TEST_MSG_UNSET);
-             attr_flag < (1 << (2 * FM10K_TEST_MSG_NESTED));
+        for (attr_flag = BIT(FM10K_TEST_MSG_UNSET);
+             attr_flag < BIT(2 * FM10K_TEST_MSG_NESTED);
              attr_flag += attr_flag) {
                 /* generate message to be tested */
                 fm10k_tlv_msg_test_create(test_msg, attr_flag);
@@ -1005,7 +1007,7 @@ static u32 fm10k_get_priv_flags(struct net_device *netdev)
         u32 priv_flags = 0;
 
         if (interface->flags & FM10K_FLAG_DEBUG_STATS)
-                priv_flags |= 1 << FM10K_PRV_FLAG_DEBUG_STATS;
+                priv_flags |= BIT(FM10K_PRV_FLAG_DEBUG_STATS);
 
         return priv_flags;
 }
@@ -1014,10 +1016,10 @@ static int fm10k_set_priv_flags(struct net_device *netdev, u32 priv_flags)
 {
         struct fm10k_intfc *interface = netdev_priv(netdev);
 
-        if (priv_flags >= (1 << FM10K_PRV_FLAG_LEN))
+        if (priv_flags >= BIT(FM10K_PRV_FLAG_LEN))
                 return -EINVAL;
 
-        if (priv_flags & (1 << FM10K_PRV_FLAG_DEBUG_STATS))
+        if (priv_flags & BIT(FM10K_PRV_FLAG_DEBUG_STATS))
                 interface->flags |= FM10K_FLAG_DEBUG_STATS;
         else
                 interface->flags &= ~FM10K_FLAG_DEBUG_STATS;
@@ -1025,11 +1027,31 @@ static int fm10k_set_priv_flags(struct net_device *netdev, u32 priv_flags)
         return 0;
 }
 
-static u32 fm10k_get_reta_size(struct net_device __always_unused *netdev)
+u32 fm10k_get_reta_size(struct net_device __always_unused *netdev)
 {
         return FM10K_RETA_SIZE * FM10K_RETA_ENTRIES_PER_REG;
 }
 
+void fm10k_write_reta(struct fm10k_intfc *interface, const u32 *indir)
+{
+        struct fm10k_hw *hw = &interface->hw;
+        int i;
+
+        /* record entries to reta table */
+        for (i = 0; i < FM10K_RETA_SIZE; i++, indir += 4) {
+                u32 reta = indir[0] |
+                           (indir[1] << 8) |
+                           (indir[2] << 16) |
+                           (indir[3] << 24);
+
+                if (interface->reta[i] == reta)
+                        continue;
+
+                interface->reta[i] = reta;
+                fm10k_write_reg(hw, FM10K_RETA(0, i), reta);
+        }
+}
+
 static int fm10k_get_reta(struct net_device *netdev, u32 *indir)
 {
         struct fm10k_intfc *interface = netdev_priv(netdev);
@@ -1053,7 +1075,6 @@ static int fm10k_get_reta(struct net_device *netdev, u32 *indir)
 static int fm10k_set_reta(struct net_device *netdev, const u32 *indir)
 {
         struct fm10k_intfc *interface = netdev_priv(netdev);
-        struct fm10k_hw *hw = &interface->hw;
         int i;
         u16 rss_i;
 
@@ -1068,19 +1089,7 @@ static int fm10k_set_reta(struct net_device *netdev, const u32 *indir)
                 return -EINVAL;
         }
 
-        /* record entries to reta table */
-        for (i = 0; i < FM10K_RETA_SIZE; i++, indir += 4) {
-                u32 reta = indir[0] |
-                           (indir[1] << 8) |
-                           (indir[2] << 16) |
-                           (indir[3] << 24);
-
-                if (interface->reta[i] == reta)
-                        continue;
-
-                interface->reta[i] = reta;
-                fm10k_write_reg(hw, FM10K_RETA(0, i), reta);
-        }
+        fm10k_write_reta(interface, indir);
 
         return 0;
 }
@@ -1145,7 +1154,7 @@ static unsigned int fm10k_max_channels(struct net_device *dev)
 
         /* For QoS report channels per traffic class */
         if (tcs > 1)
-                max_combined = 1 << (fls(max_combined / tcs) - 1);
+                max_combined = BIT((fls(max_combined / tcs) - 1));
 
         return max_combined;
 }
@@ -1210,11 +1219,9 @@ static int fm10k_get_ts_info(struct net_device *dev,
         else
                 info->phc_index = -1;
 
-        info->tx_types = (1 << HWTSTAMP_TX_OFF) |
-                         (1 << HWTSTAMP_TX_ON);
+        info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
 
-        info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
-                           (1 << HWTSTAMP_FILTER_ALL);
+        info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) | BIT(HWTSTAMP_FILTER_ALL);
 
         return 0;
 }
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_iov.c b/drivers/net/ethernet/intel/fm10k/fm10k_iov.c
index acfb8b1f88a7..bbf7c4bac303 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_iov.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_iov.c
@@ -50,7 +50,7 @@ s32 fm10k_iov_event(struct fm10k_intfc *interface)
         s64 vflre;
         int i;
 
-        /* if there is no iov_data then there is no mailboxes to process */
+        /* if there is no iov_data then there is no mailbox to process */
         if (!ACCESS_ONCE(interface->iov_data))
                 return 0;
 
@@ -98,7 +98,7 @@ s32 fm10k_iov_mbx(struct fm10k_intfc *interface)
         struct fm10k_iov_data *iov_data;
         int i;
 
-        /* if there is no iov_data then there is no mailboxes to process */
+        /* if there is no iov_data then there is no mailbox to process */
         if (!ACCESS_ONCE(interface->iov_data))
                 return 0;
 
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_main.c b/drivers/net/ethernet/intel/fm10k/fm10k_main.c
index 4de17db3808c..0b465394f88a 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_main.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_main.c
@@ -401,10 +401,10 @@ static inline void fm10k_rx_checksum(struct fm10k_ring *ring,
 }
 
 #define FM10K_RSS_L4_TYPES_MASK \
-        ((1ul << FM10K_RSSTYPE_IPV4_TCP) | \
-         (1ul << FM10K_RSSTYPE_IPV4_UDP) | \
-         (1ul << FM10K_RSSTYPE_IPV6_TCP) | \
-         (1ul << FM10K_RSSTYPE_IPV6_UDP))
+        (BIT(FM10K_RSSTYPE_IPV4_TCP) | \
+         BIT(FM10K_RSSTYPE_IPV4_UDP) | \
+         BIT(FM10K_RSSTYPE_IPV6_TCP) | \
+         BIT(FM10K_RSSTYPE_IPV6_UDP))
 
 static inline void fm10k_rx_hash(struct fm10k_ring *ring,
                                  union fm10k_rx_desc *rx_desc,
@@ -420,7 +420,7 @@ static inline void fm10k_rx_hash(struct fm10k_ring *ring,
                 return;
 
         skb_set_hash(skb, le32_to_cpu(rx_desc->d.rss),
-                     (FM10K_RSS_L4_TYPES_MASK & (1ul << rss_type)) ?
+                     (BIT(rss_type) & FM10K_RSS_L4_TYPES_MASK) ?
                      PKT_HASH_TYPE_L4 : PKT_HASH_TYPE_L3);
 }
 
@@ -1409,7 +1409,7 @@ static void fm10k_update_itr(struct fm10k_ring_container *ring_container)
          * accounts for changes in the ITR due to PCIe link speed.
          */
         itr_round = ACCESS_ONCE(ring_container->itr_scale) + 8;
-        avg_wire_size += (1 << itr_round) - 1;
+        avg_wire_size += BIT(itr_round) - 1;
         avg_wire_size >>= itr_round;
 
         /* write back value and retain adaptive flag */
@@ -1511,17 +1511,17 @@ static bool fm10k_set_qos_queues(struct fm10k_intfc *interface)
         /* set QoS mask and indices */
         f = &interface->ring_feature[RING_F_QOS];
         f->indices = pcs;
-        f->mask = (1 << fls(pcs - 1)) - 1;
+        f->mask = BIT(fls(pcs - 1)) - 1;
 
         /* determine the upper limit for our current DCB mode */
         rss_i = interface->hw.mac.max_queues / pcs;
-        rss_i = 1 << (fls(rss_i) - 1);
+        rss_i = BIT(fls(rss_i) - 1);
 
         /* set RSS mask and indices */
         f = &interface->ring_feature[RING_F_RSS];
         rss_i = min_t(u16, rss_i, f->limit);
         f->indices = rss_i;
-        f->mask = (1 << fls(rss_i - 1)) - 1;
+        f->mask = BIT(fls(rss_i - 1)) - 1;
 
         /* configure pause class to queue mapping */
         for (i = 0; i < pcs; i++)
@@ -1551,7 +1551,7 @@ static bool fm10k_set_rss_queues(struct fm10k_intfc *interface)
 
         /* record indices and power of 2 mask for RSS */
         f->indices = rss_i;
-        f->mask = (1 << fls(rss_i - 1)) - 1;
+        f->mask = BIT(fls(rss_i - 1)) - 1;
 
         interface->num_rx_queues = rss_i;
         interface->num_tx_queues = rss_i;
@@ -1572,17 +1572,29 @@ static bool fm10k_set_rss_queues(struct fm10k_intfc *interface)
  **/
 static void fm10k_set_num_queues(struct fm10k_intfc *interface)
 {
-        /* Start with base case */
-        interface->num_rx_queues = 1;
-        interface->num_tx_queues = 1;
-
+        /* Attempt to setup QoS and RSS first */
         if (fm10k_set_qos_queues(interface))
                 return;
 
+        /* If we don't have QoS, just fallback to only RSS. */
         fm10k_set_rss_queues(interface);
 }
 
 /**
+ * fm10k_reset_num_queues - Reset the number of queues to zero
+ * @interface: board private structure
+ *
+ * This function should be called whenever we need to reset the number of
+ * queues after an error condition.
+ */
+static void fm10k_reset_num_queues(struct fm10k_intfc *interface)
+{
+        interface->num_tx_queues = 0;
+        interface->num_rx_queues = 0;
+        interface->num_q_vectors = 0;
+}
+
+/**
  * fm10k_alloc_q_vector - Allocate memory for a single interrupt vector
  * @interface: board private structure to initialize
  * @v_count: q_vectors allocated on interface, used for ring interleaving
@@ -1765,9 +1777,7 @@ static int fm10k_alloc_q_vectors(struct fm10k_intfc *interface)
         return 0;
 
 err_out:
-        interface->num_tx_queues = 0;
-        interface->num_rx_queues = 0;
-        interface->num_q_vectors = 0;
+        fm10k_reset_num_queues(interface);
 
         while (v_idx--)
                 fm10k_free_q_vector(interface, v_idx);
@@ -1787,9 +1797,7 @@ static void fm10k_free_q_vectors(struct fm10k_intfc *interface)
 {
         int v_idx = interface->num_q_vectors;
 
-        interface->num_tx_queues = 0;
-        interface->num_rx_queues = 0;
-        interface->num_q_vectors = 0;
+        fm10k_reset_num_queues(interface);
 
         while (v_idx--)
                 fm10k_free_q_vector(interface, v_idx);
@@ -1935,7 +1943,8 @@ static void fm10k_assign_rings(struct fm10k_intfc *interface)
 static void fm10k_init_reta(struct fm10k_intfc *interface)
 {
         u16 i, rss_i = interface->ring_feature[RING_F_RSS].indices;
-        u32 reta, base;
+        struct net_device *netdev = interface->netdev;
+        u32 reta, *indir;
 
         /* If the Rx flow indirection table has been configured manually, we
          * need to maintain it when possible.
@@ -1960,21 +1969,16 @@ static void fm10k_init_reta(struct fm10k_intfc *interface)
         }
 
 repopulate_reta:
-        /* Populate the redirection table 4 entries at a time.  To do this
-         * we are generating the results for n and n+2 and then interleaving
-         * those with the results with n+1 and n+3.
-         */
-        for (i = FM10K_RETA_SIZE; i--;) {
-                /* first pass generates n and n+2 */
-                base = ((i * 0x00040004) + 0x00020000) * rss_i;
-                reta = (base & 0x3F803F80) >> 7;
+        indir = kcalloc(fm10k_get_reta_size(netdev),
+                        sizeof(indir[0]), GFP_KERNEL);
 
-                /* second pass generates n+1 and n+3 */
-                base += 0x00010001 * rss_i;
-                reta |= (base & 0x3F803F80) << 1;
+        /* generate redirection table using the default kernel policy */
+        for (i = 0; i < fm10k_get_reta_size(netdev); i++)
+                indir[i] = ethtool_rxfh_indir_default(i, rss_i);
 
-                interface->reta[i] = reta;
-        }
+        fm10k_write_reta(interface, indir);
+
+        kfree(indir);
 }
 
 /**
@@ -1997,14 +2001,15 @@ int fm10k_init_queueing_scheme(struct fm10k_intfc *interface)
         if (err) {
                 dev_err(&interface->pdev->dev,
                         "Unable to initialize MSI-X capability\n");
-                return err;
+                goto err_init_msix;
         }
 
         /* Allocate memory for queues */
         err = fm10k_alloc_q_vectors(interface);
         if (err) {
-                fm10k_reset_msix_capability(interface);
-                return err;
+                dev_err(&interface->pdev->dev,
+                        "Unable to allocate queue vectors\n");
+                goto err_alloc_q_vectors;
         }
 
         /* Map rings to devices, and map devices to physical queues */
@@ -2014,6 +2019,12 @@ int fm10k_init_queueing_scheme(struct fm10k_intfc *interface)
         fm10k_init_reta(interface);
 
         return 0;
+
+err_alloc_q_vectors:
+        fm10k_reset_msix_capability(interface);
+err_init_msix:
+        fm10k_reset_num_queues(interface);
+        return err;
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
index d09a8dd71fc2..1d0f0583222c 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_netdev.c
@@ -440,7 +440,7 @@ static void fm10k_restore_vxlan_port(struct fm10k_intfc *interface)
  * @sa_family: Address family of new port
  * @port: port number used for VXLAN
  *
- * This funciton is called when a new VXLAN interface has added a new port
+ * This function is called when a new VXLAN interface has added a new port
  * number to the range that is currently in use for VXLAN.  The new port
  * number is always added to the tail so that the port number list should
  * match the order in which the ports were allocated.  The head of the list
@@ -484,7 +484,7 @@ insert_tail:
  * @sa_family: Address family of freed port
  * @port: port number used for VXLAN
  *
- * This funciton is called when a new VXLAN interface has freed a port
+ * This function is called when a new VXLAN interface has freed a port
  * number from the range that is currently in use for VXLAN.  The freed
  * port is removed from the list and the new head is used to determine
  * the port number for offloads.
@@ -1429,7 +1429,7 @@ struct net_device *fm10k_alloc_netdev(const struct fm10k_info *info)
 
         /* configure default debug level */
         interface = netdev_priv(dev);
-        interface->msg_enable = (1 << DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
+        interface->msg_enable = BIT(DEFAULT_DEBUG_LEVEL_SHIFT) - 1;
 
         /* configure default features */
         dev->features |= NETIF_F_IP_CSUM |
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
index 4eb7a6fa6b0d..f0992950e228 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
@@ -99,7 +99,7 @@ void fm10k_service_event_schedule(struct fm10k_intfc *interface)
 
 static void fm10k_service_event_complete(struct fm10k_intfc *interface)
 {
-        BUG_ON(!test_bit(__FM10K_SERVICE_SCHED, &interface->state));
+        WARN_ON(!test_bit(__FM10K_SERVICE_SCHED, &interface->state));
 
         /* flush memory to make sure state is correct before next watchog */
         smp_mb__before_atomic();
@@ -579,7 +579,7 @@ static void fm10k_configure_tx_ring(struct fm10k_intfc *interface,
         u64 tdba = ring->dma;
         u32 size = ring->count * sizeof(struct fm10k_tx_desc);
         u32 txint = FM10K_INT_MAP_DISABLE;
-        u32 txdctl = FM10K_TXDCTL_ENABLE | (1 << FM10K_TXDCTL_MAX_TIME_SHIFT);
+        u32 txdctl = BIT(FM10K_TXDCTL_MAX_TIME_SHIFT) | FM10K_TXDCTL_ENABLE;
         u8 reg_idx = ring->reg_idx;
 
         /* disable queue to avoid issues while updating state */
@@ -730,7 +730,7 @@ static void fm10k_configure_rx_ring(struct fm10k_intfc *interface,
         if (interface->pfc_en)
                 rx_pause = interface->pfc_en;
 #endif
-        if (!(rx_pause & (1 << ring->qos_pc)))
+        if (!(rx_pause & BIT(ring->qos_pc)))
                 rxdctl |= FM10K_RXDCTL_DROP_ON_EMPTY;
 
         fm10k_write_reg(hw, FM10K_RXDCTL(reg_idx), rxdctl);
@@ -779,7 +779,7 @@ void fm10k_update_rx_drop_en(struct fm10k_intfc *interface)
                 u32 rxdctl = FM10K_RXDCTL_WRITE_BACK_MIN_DELAY;
                 u8 reg_idx = ring->reg_idx;
 
-                if (!(rx_pause & (1 << ring->qos_pc)))
+                if (!(rx_pause & BIT(ring->qos_pc)))
                         rxdctl |= FM10K_RXDCTL_DROP_ON_EMPTY;
 
                 fm10k_write_reg(hw, FM10K_RXDCTL(reg_idx), rxdctl);
@@ -903,8 +903,8 @@ static irqreturn_t fm10k_msix_mbx_vf(int __always_unused irq, void *data)
 
         /* re-enable mailbox interrupt and indicate 20us delay */
         fm10k_write_reg(hw, FM10K_VFITR(FM10K_MBX_VECTOR),
-                        FM10K_ITR_ENABLE | (FM10K_MBX_INT_DELAY >>
-                                            hw->mac.itr_scale));
+                        (FM10K_MBX_INT_DELAY >> hw->mac.itr_scale) |
+                        FM10K_ITR_ENABLE);
 
         /* service upstream mailbox */
         if (fm10k_mbx_trylock(interface)) {
@@ -1065,7 +1065,7 @@ static void fm10k_reset_drop_on_empty(struct fm10k_intfc *interface, u32 eicr)
         if (maxholdq)
                 fm10k_write_reg(hw, FM10K_MAXHOLDQ(7), maxholdq);
         for (q = 255;;) {
-                if (maxholdq & (1 << 31)) {
+                if (maxholdq & BIT(31)) {
                         if (q < FM10K_MAX_QUEUES_PF) {
                                 interface->rx_overrun_pf++;
                                 fm10k_write_reg(hw, FM10K_RXDCTL(q), rxdctl);
@@ -1135,22 +1135,24 @@ static irqreturn_t fm10k_msix_mbx_pf(int __always_unused irq, void *data)
 
         /* re-enable mailbox interrupt and indicate 20us delay */
         fm10k_write_reg(hw, FM10K_ITR(FM10K_MBX_VECTOR),
-                        FM10K_ITR_ENABLE | (FM10K_MBX_INT_DELAY >>
-                                            hw->mac.itr_scale));
+                        (FM10K_MBX_INT_DELAY >> hw->mac.itr_scale) |
+                        FM10K_ITR_ENABLE);
 
         return IRQ_HANDLED;
 }
 
 void fm10k_mbx_free_irq(struct fm10k_intfc *interface)
 {
-        struct msix_entry *entry = &interface->msix_entries[FM10K_MBX_VECTOR];
         struct fm10k_hw *hw = &interface->hw;
+        struct msix_entry *entry;
         int itr_reg;
 
         /* no mailbox IRQ to free if MSI-X is not enabled */
         if (!interface->msix_entries)
                 return;
 
+        entry = &interface->msix_entries[FM10K_MBX_VECTOR];
+
         /* disconnect the mailbox */
         hw->mbx.ops.disconnect(hw, &hw->mbx);
 
@@ -1253,7 +1255,7 @@ static int fm10k_mbx_request_irq_vf(struct fm10k_intfc *interface)
         int err;
 
         /* Use timer0 for interrupt moderation on the mailbox */
-        u32 itr = FM10K_INT_MAP_TIMER0 | entry->entry;
+        u32 itr = entry->entry | FM10K_INT_MAP_TIMER0;
 
         /* register mailbox handlers */
         err = hw->mbx.ops.register_handlers(&hw->mbx, vf_mbx_data);
@@ -1377,7 +1379,7 @@ static s32 fm10k_1588_msg_pf(struct fm10k_hw *hw, u32 **results,
                 return 0;
         }
 
-        /* if there is no iov_data then there is no mailboxes to process */
+        /* if there is no iov_data then there is no mailbox to process */
         if (!ACCESS_ONCE(interface->iov_data))
                 return FM10K_ERR_PARAM;
 
@@ -1420,8 +1422,8 @@ static int fm10k_mbx_request_irq_pf(struct fm10k_intfc *interface)
         int err;
 
         /* Use timer0 for interrupt moderation on the mailbox */
-        u32 mbx_itr = FM10K_INT_MAP_TIMER0 | entry->entry;
-        u32 other_itr = FM10K_INT_MAP_IMMEDIATE | entry->entry;
+        u32 mbx_itr = entry->entry | FM10K_INT_MAP_TIMER0;
+        u32 other_itr = entry->entry | FM10K_INT_MAP_IMMEDIATE;
 
         /* register mailbox handlers */
         err = hw->mbx.ops.register_handlers(&hw->mbx, pf_mbx_data);
@@ -1654,6 +1656,7 @@ void fm10k_down(struct fm10k_intfc *interface)
 {
         struct net_device *netdev = interface->netdev;
         struct fm10k_hw *hw = &interface->hw;
+        int err;
 
         /* signal that we are down to the interrupt handler and service task */
         set_bit(__FM10K_DOWN, &interface->state);
@@ -1678,7 +1681,9 @@ void fm10k_down(struct fm10k_intfc *interface)
         fm10k_update_stats(interface);
 
         /* Disable DMA engine for Tx/Rx */
-        hw->mac.ops.stop_hw(hw);
+        err = hw->mac.ops.stop_hw(hw);
+        if (err)
+                dev_err(&interface->pdev->dev, "stop_hw failed: %d\n", err);
 
         /* free any buffers still on the rings */
         fm10k_clean_all_tx_rings(interface);
@@ -1776,8 +1781,8 @@ static int fm10k_sw_init(struct fm10k_intfc *interface,
                 netdev->addr_assign_type |= NET_ADDR_RANDOM;
         }
 
-        memcpy(netdev->dev_addr, hw->mac.addr, netdev->addr_len);
-        memcpy(netdev->perm_addr, hw->mac.addr, netdev->addr_len);
+        ether_addr_copy(netdev->dev_addr, hw->mac.addr);
+        ether_addr_copy(netdev->perm_addr, hw->mac.addr);
 
         if (!is_valid_ether_addr(netdev->perm_addr)) {
                 dev_err(&pdev->dev, "Invalid MAC Address\n");
@@ -1793,15 +1798,6 @@ static int fm10k_sw_init(struct fm10k_intfc *interface,
         /* initialize DCBNL interface */
         fm10k_dcbnl_set_ops(netdev);
 
-        /* Initialize service timer and service task */
-        set_bit(__FM10K_SERVICE_DISABLE, &interface->state);
-        setup_timer(&interface->service_timer, &fm10k_service_timer,
-                    (unsigned long)interface);
-        INIT_WORK(&interface->service_task, fm10k_service_task);
-
-        /* kick off service timer now, even when interface is down */
-        mod_timer(&interface->service_timer, (HZ * 2) + jiffies);
-
         /* Intitialize timestamp data */
         fm10k_ts_init(interface);
 
@@ -1987,6 +1983,12 @@ static int fm10k_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (err)
                 goto err_sw_init;
 
+        /* the mbx interrupt might attempt to schedule the service task, so we
+         * must ensure it is disabled since we haven't yet requested the timer
+         * or work item.
+         */
+        set_bit(__FM10K_SERVICE_DISABLE, &interface->state);
+
         err = fm10k_mbx_request_irq(interface);
         if (err)
                 goto err_mbx_interrupt;
@@ -2006,6 +2008,16 @@ static int fm10k_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         /* stop all the transmit queues from transmitting until link is up */
         netif_tx_stop_all_queues(netdev);
 
+        /* Initialize service timer and service task late in order to avoid
+         * cleanup issues.
+         */
+        setup_timer(&interface->service_timer, &fm10k_service_timer,
+                    (unsigned long)interface);
+        INIT_WORK(&interface->service_task, fm10k_service_task);
+
+        /* kick off service timer now, even when interface is down */
+        mod_timer(&interface->service_timer, (HZ * 2) + jiffies);
+
         /* Register PTP interface */
         fm10k_ptp_register(interface);
 
@@ -2262,11 +2274,11 @@ static pci_ers_result_t fm10k_io_error_detected(struct pci_dev *pdev,
         if (netif_running(netdev))
                 fm10k_close(netdev);
 
+        fm10k_mbx_free_irq(interface);
+
         /* free interrupts */
         fm10k_clear_queueing_scheme(interface);
 
-        fm10k_mbx_free_irq(interface);
-
         pci_disable_device(pdev);
 
         /* Request a slot reset. */
@@ -2382,7 +2394,7 @@ static struct pci_driver fm10k_driver = {
 /**
  * fm10k_register_pci_driver - register driver interface
  *
- * This funciton is called on module load in order to register the driver.
+ * This function is called on module load in order to register the driver.
  **/
 int fm10k_register_pci_driver(void)
 {
@@ -2392,7 +2404,7 @@ int fm10k_register_pci_driver(void)
 /**
  * fm10k_unregister_pci_driver - unregister driver interface
  *
- * This funciton is called on module unload in order to remove the driver.
+ * This function is called on module unload in order to remove the driver.
  **/
 void fm10k_unregister_pci_driver(void)
 {
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
index 62ccebc5f728..ecc99f9d2cce 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
@@ -527,8 +527,8 @@ static s32 fm10k_configure_dglort_map_pf(struct fm10k_hw *hw,
                 return FM10K_ERR_PARAM;
 
         /* determine count of VSIs and queues */
-        queue_count = 1 << (dglort->rss_l + dglort->pc_l);
-        vsi_count = 1 << (dglort->vsi_l + dglort->queue_l);
+        queue_count = BIT(dglort->rss_l + dglort->pc_l);
+        vsi_count = BIT(dglort->vsi_l + dglort->queue_l);
         glort = dglort->glort;
         q_idx = dglort->queue_b;
 
@@ -544,8 +544,8 @@ static s32 fm10k_configure_dglort_map_pf(struct fm10k_hw *hw,
         }
 
         /* determine count of PCs and queues */
-        queue_count = 1 << (dglort->queue_l + dglort->rss_l + dglort->vsi_l);
-        pc_count = 1 << dglort->pc_l;
+        queue_count = BIT(dglort->queue_l + dglort->rss_l + dglort->vsi_l);
+        pc_count = BIT(dglort->pc_l);
 
         /* configure PC for Tx queues */
         for (pc = 0; pc < pc_count; pc++) {
@@ -711,8 +711,8 @@ static s32 fm10k_iov_assign_resources_pf(struct fm10k_hw *hw, u16 num_vfs,
                                         FM10K_RXDCTL_WRITE_BACK_MIN_DELAY |
                                         FM10K_RXDCTL_DROP_ON_EMPTY);
                         fm10k_write_reg(hw, FM10K_RXQCTL(vf_q_idx),
-                                        FM10K_RXQCTL_VF |
-                                        (i << FM10K_RXQCTL_VF_SHIFT));
+                                        (i << FM10K_RXQCTL_VF_SHIFT) |
+                                        FM10K_RXQCTL_VF);
 
                         /* map queue pair to VF */
                         fm10k_write_reg(hw, FM10K_TQMAP(qmap_idx), vf_q_idx);
@@ -952,7 +952,7 @@ static s32 fm10k_iov_reset_resources_pf(struct fm10k_hw *hw,
                 return FM10K_ERR_PARAM;
 
         /* clear event notification of VF FLR */
-        fm10k_write_reg(hw, FM10K_PFVFLREC(vf_idx / 32), 1 << (vf_idx % 32));
+        fm10k_write_reg(hw, FM10K_PFVFLREC(vf_idx / 32), BIT(vf_idx % 32));
 
         /* force timeout and then disconnect the mailbox */
         vf_info->mbx.timeout = 0;
@@ -987,7 +987,7 @@ static s32 fm10k_iov_reset_resources_pf(struct fm10k_hw *hw,
         txqctl = ((u32)vf_vid << FM10K_TXQCTL_VID_SHIFT) |
                  (vf_idx << FM10K_TXQCTL_TC_SHIFT) |
                  FM10K_TXQCTL_VF | vf_idx;
-        rxqctl = FM10K_RXQCTL_VF | (vf_idx << FM10K_RXQCTL_VF_SHIFT);
+        rxqctl = (vf_idx << FM10K_RXQCTL_VF_SHIFT) | FM10K_RXQCTL_VF;
 
         /* stop further DMA and reset queue ownership back to VF */
         for (i = vf_q_idx; i < (queues_per_pool + vf_q_idx); i++) {
@@ -1370,7 +1370,7 @@ s32 fm10k_iov_msg_lport_state_pf(struct fm10k_hw *hw, u32 **results,
                 mode = fm10k_iov_supported_xcast_mode_pf(vf_info, mode);
 
                 /* if mode is not currently enabled, enable it */
-                if (!(FM10K_VF_FLAG_ENABLED(vf_info) & (1 << mode)))
+                if (!(FM10K_VF_FLAG_ENABLED(vf_info) & BIT(mode)))
                         fm10k_update_xcast_mode_pf(hw, vf_info->glort, mode);
 
                 /* swap mode back to a bit flag */
@@ -1604,7 +1604,7 @@ static s32 fm10k_request_lport_map_pf(struct fm10k_hw *hw)
  *  @hw: pointer to hardware structure
  *  @switch_ready: pointer to boolean value that will record switch state
  *
- *  This funciton will check the DMA_CTRL2 register and mailbox in order
+ *  This function will check the DMA_CTRL2 register and mailbox in order
  *  to determine if the switch is ready for the PF to begin requesting
  *  addresses and mapping traffic to the local interface.
  **/
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c b/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
index b4945e8abe03..1c1ccade6538 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_ptp.c
@@ -416,7 +416,7 @@ void fm10k_ptp_register(struct fm10k_intfc *interface)
         /* This math is simply the inverse of the math in
          * fm10k_adjust_systime_pf applied to an adjustment value
          * of 2^30 - 1 which is the maximum value of the register:
-         *      max_ppb == ((2^30 - 1) * 5^9) / 2^31
+         *      max_ppb == ((2^30 - 1) * 5^9) / 2^31
          */
         ptp_caps->max_adj       = 976562;
         ptp_caps->adjfreq       = fm10k_ptp_adjfreq;
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_tlv.c b/drivers/net/ethernet/intel/fm10k/fm10k_tlv.c
index ab01bb30752f..b999897e50d8 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_tlv.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_tlv.c
@@ -222,7 +222,7 @@ s32 fm10k_tlv_attr_put_value(u32 *msg, u16 attr_id, s64 value, u32 len)
         attr = &msg[FM10K_TLV_DWORD_LEN(*msg)];
 
         if (len < 4) {
-                attr[1] = (u32)value & ((0x1ul << (8 * len)) - 1);
+                attr[1] = (u32)value & (BIT(8 * len) - 1);
         } else {
                 attr[1] = (u32)value;
                 if (len > 4)
@@ -652,29 +652,29 @@ const struct fm10k_tlv_attr fm10k_tlv_msg_test_attr[] = {
  **/
 static void fm10k_tlv_msg_test_generate_data(u32 *msg, u32 attr_flags)
 {
-        if (attr_flags & (1 << FM10K_TEST_MSG_STRING))
+        if (attr_flags & BIT(FM10K_TEST_MSG_STRING))
                 fm10k_tlv_attr_put_null_string(msg, FM10K_TEST_MSG_STRING,
                                                test_str);
-        if (attr_flags & (1 << FM10K_TEST_MSG_MAC_ADDR))
+        if (attr_flags & BIT(FM10K_TEST_MSG_MAC_ADDR))
                 fm10k_tlv_attr_put_mac_vlan(msg, FM10K_TEST_MSG_MAC_ADDR,
                                             test_mac, test_vlan);
-        if (attr_flags & (1 << FM10K_TEST_MSG_U8))
+        if (attr_flags & BIT(FM10K_TEST_MSG_U8))
                 fm10k_tlv_attr_put_u8(msg, FM10K_TEST_MSG_U8,  test_u8);
-        if (attr_flags & (1 << FM10K_TEST_MSG_U16))
+        if (attr_flags & BIT(FM10K_TEST_MSG_U16))
                 fm10k_tlv_attr_put_u16(msg, FM10K_TEST_MSG_U16, test_u16);
-        if (attr_flags & (1 << FM10K_TEST_MSG_U32))
+        if (attr_flags & BIT(FM10K_TEST_MSG_U32))
                 fm10k_tlv_attr_put_u32(msg, FM10K_TEST_MSG_U32, test_u32);
-        if (attr_flags & (1 << FM10K_TEST_MSG_U64))
+        if (attr_flags & BIT(FM10K_TEST_MSG_U64))
                 fm10k_tlv_attr_put_u64(msg, FM10K_TEST_MSG_U64, test_u64);
-        if (attr_flags & (1 << FM10K_TEST_MSG_S8))
+        if (attr_flags & BIT(FM10K_TEST_MSG_S8))
                 fm10k_tlv_attr_put_s8(msg, FM10K_TEST_MSG_S8,  test_s8);
-        if (attr_flags & (1 << FM10K_TEST_MSG_S16))
+        if (attr_flags & BIT(FM10K_TEST_MSG_S16))
                 fm10k_tlv_attr_put_s16(msg, FM10K_TEST_MSG_S16, test_s16);
-        if (attr_flags & (1 << FM10K_TEST_MSG_S32))
+        if (attr_flags & BIT(FM10K_TEST_MSG_S32))
                 fm10k_tlv_attr_put_s32(msg, FM10K_TEST_MSG_S32, test_s32);
-        if (attr_flags & (1 << FM10K_TEST_MSG_S64))
+        if (attr_flags & BIT(FM10K_TEST_MSG_S64))
                 fm10k_tlv_attr_put_s64(msg, FM10K_TEST_MSG_S64, test_s64);
-        if (attr_flags & (1 << FM10K_TEST_MSG_LE_STRUCT))
+        if (attr_flags & BIT(FM10K_TEST_MSG_LE_STRUCT))
                 fm10k_tlv_attr_put_le_struct(msg, FM10K_TEST_MSG_LE_STRUCT,
                                              test_le, 8);
 }
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_type.h b/drivers/net/ethernet/intel/fm10k/fm10k_type.h
index 854ebb1906bf..5c0533054c5f 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_type.h
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_type.h
@@ -617,10 +617,10 @@ struct fm10k_vf_info {
                                                  */
 };
 
-#define FM10K_VF_FLAG_ALLMULTI_CAPABLE  ((u8)1 << FM10K_XCAST_MODE_ALLMULTI)
-#define FM10K_VF_FLAG_MULTI_CAPABLE     ((u8)1 << FM10K_XCAST_MODE_MULTI)
-#define FM10K_VF_FLAG_PROMISC_CAPABLE   ((u8)1 << FM10K_XCAST_MODE_PROMISC)
-#define FM10K_VF_FLAG_NONE_CAPABLE      ((u8)1 << FM10K_XCAST_MODE_NONE)
+#define FM10K_VF_FLAG_ALLMULTI_CAPABLE  (u8)(BIT(FM10K_XCAST_MODE_ALLMULTI))
+#define FM10K_VF_FLAG_MULTI_CAPABLE     (u8)(BIT(FM10K_XCAST_MODE_MULTI))
+#define FM10K_VF_FLAG_PROMISC_CAPABLE   (u8)(BIT(FM10K_XCAST_MODE_PROMISC))
+#define FM10K_VF_FLAG_NONE_CAPABLE      (u8)(BIT(FM10K_XCAST_MODE_NONE))
 #define FM10K_VF_FLAG_CAPABLE(vf_info)  ((vf_info)->vf_flags & (u8)0xF)
 #define FM10K_VF_FLAG_ENABLED(vf_info)  ((vf_info)->vf_flags >> 4)
 #define FM10K_VF_FLAG_SET_MODE(mode)    ((u8)0x10 << (mode))
diff --git a/drivers/net/ethernet/intel/i40e/Makefile b/drivers/net/ethernet/intel/i40e/Makefile
index b4729ba57c9c..3b3c63e54ed6 100644
--- a/drivers/net/ethernet/intel/i40e/Makefile
+++ b/drivers/net/ethernet/intel/i40e/Makefile
@@ -41,6 +41,7 @@ i40e-objs := i40e_main.o \
         i40e_diag.o     \
         i40e_txrx.o     \
         i40e_ptp.o      \
+        i40e_client.o   \
         i40e_virtchnl_pf.o
 
 i40e-$(CONFIG_I40E_DCB) += i40e_dcb.o i40e_dcb_nl.o
diff --git a/drivers/net/ethernet/intel/i40e/i40e.h b/drivers/net/ethernet/intel/i40e/i40e.h
index 2f6210ae8ba0..d25b3be5ba89 100644
--- a/drivers/net/ethernet/intel/i40e/i40e.h
+++ b/drivers/net/ethernet/intel/i40e/i40e.h
@@ -58,6 +58,7 @@
 #ifdef I40E_FCOE
 #include "i40e_fcoe.h"
 #endif
+#include "i40e_client.h"
 #include "i40e_virtchnl.h"
 #include "i40e_virtchnl_pf.h"
 #include "i40e_txrx.h"
@@ -190,6 +191,7 @@ struct i40e_lump_tracking {
         u16 search_hint;
         u16 list[0];
 #define I40E_PILE_VALID_BIT  0x8000
+#define I40E_IWARP_IRQ_PILE_ID  (I40E_PILE_VALID_BIT - 2)
 };
 
 #define I40E_DEFAULT_ATR_SAMPLE_RATE    20
@@ -242,7 +244,6 @@ struct i40e_fdir_filter {
 #define I40E_DCB_PRIO_TYPE_STRICT       0
 #define I40E_DCB_PRIO_TYPE_ETS          1
 #define I40E_DCB_STRICT_PRIO_CREDITS    127
-#define I40E_MAX_USER_PRIORITY  8
 /* DCB per TC information data structure */
 struct i40e_tc_info {
         u16     qoffset;        /* Queue offset from base queue */
@@ -282,6 +283,8 @@ struct i40e_pf {
 #endif /* I40E_FCOE */
         u16 num_lan_qps;           /* num lan queues this PF has set up */
         u16 num_lan_msix;          /* num queue vectors for the base PF vsi */
+        u16 num_iwarp_msix;        /* num of iwarp vectors for this PF */
+        int iwarp_base_vector;
         int queues_left;           /* queues left unclaimed */
         u16 alloc_rss_size;        /* allocated RSS queues */
         u16 rss_size_max;          /* HW defined max RSS queues */
@@ -329,6 +332,7 @@ struct i40e_pf {
 #define I40E_FLAG_16BYTE_RX_DESC_ENABLED        BIT_ULL(13)
 #define I40E_FLAG_CLEAN_ADMINQ                  BIT_ULL(14)
 #define I40E_FLAG_FILTER_SYNC                   BIT_ULL(15)
+#define I40E_FLAG_SERVICE_CLIENT_REQUESTED      BIT_ULL(16)
 #define I40E_FLAG_PROCESS_MDD_EVENT             BIT_ULL(17)
 #define I40E_FLAG_PROCESS_VFLR_EVENT            BIT_ULL(18)
 #define I40E_FLAG_SRIOV_ENABLED                 BIT_ULL(19)
@@ -571,6 +575,8 @@ struct i40e_vsi {
         struct kobject *kobj;  /* sysfs object */
         bool current_isup;     /* Sync 'link up' logging */
 
+        void *priv;     /* client driver data reference. */
+
         /* VSI specific handlers */
         irqreturn_t (*irq_handler)(int irq, void *data);
 
@@ -728,6 +734,10 @@ void i40e_vsi_setup_queue_map(struct i40e_vsi *vsi,
                               struct i40e_vsi_context *ctxt,
                               u8 enabled_tc, bool is_add);
 #endif
+void i40e_service_event_schedule(struct i40e_pf *pf);
+void i40e_notify_client_of_vf_msg(struct i40e_vsi *vsi, u32 vf_id,
+                                  u8 *msg, u16 len);
+
 int i40e_vsi_control_rings(struct i40e_vsi *vsi, bool enable);
 int i40e_reconfig_rss_queues(struct i40e_pf *pf, int queue_count);
 struct i40e_veb *i40e_veb_setup(struct i40e_pf *pf, u16 flags, u16 uplink_seid,
@@ -750,6 +760,17 @@ static inline void i40e_dbg_pf_exit(struct i40e_pf *pf) {}
 static inline void i40e_dbg_init(void) {}
 static inline void i40e_dbg_exit(void) {}
 #endif /* CONFIG_DEBUG_FS*/
+/* needed by client drivers */
+int i40e_lan_add_device(struct i40e_pf *pf);
+int i40e_lan_del_device(struct i40e_pf *pf);
+void i40e_client_subtask(struct i40e_pf *pf);
+void i40e_notify_client_of_l2_param_changes(struct i40e_vsi *vsi);
+void i40e_notify_client_of_netdev_open(struct i40e_vsi *vsi);
+void i40e_notify_client_of_netdev_close(struct i40e_vsi *vsi, bool reset);
+void i40e_notify_client_of_vf_enable(struct i40e_pf *pf, u32 num_vfs);
+void i40e_notify_client_of_vf_reset(struct i40e_pf *pf, u32 vf_id);
+int i40e_vf_client_capable(struct i40e_pf *pf, u32 vf_id,
+                           enum i40e_client_type type);
 /**
  * i40e_irq_dynamic_enable - Enable default interrupt generation settings
  * @vsi: pointer to a vsi
@@ -789,6 +810,7 @@ int i40e_vlan_rx_kill_vid(struct net_device *netdev,
                           __always_unused __be16 proto, u16 vid);
 #endif
 int i40e_open(struct net_device *netdev);
+int i40e_close(struct net_device *netdev);
 int i40e_vsi_open(struct i40e_vsi *vsi);
 void i40e_vlan_stripping_disable(struct i40e_vsi *vsi);
 int i40e_vsi_add_vlan(struct i40e_vsi *vsi, s16 vid);
@@ -801,7 +823,6 @@ bool i40e_is_vsi_in_vlan(struct i40e_vsi *vsi);
 struct i40e_mac_filter *i40e_find_mac(struct i40e_vsi *vsi, u8 *macaddr,
                                       bool is_vf, bool is_netdev);
 #ifdef I40E_FCOE
-int i40e_close(struct net_device *netdev);
 int __i40e_setup_tc(struct net_device *netdev, u32 handle, __be16 proto,
                     struct tc_to_netdev *tc);
 void i40e_netpoll(struct net_device *netdev);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq.c b/drivers/net/ethernet/intel/i40e/i40e_adminq.c
index df8e2fd6a649..43bb4139d896 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq.c
@@ -33,16 +33,6 @@
 static void i40e_resume_aq(struct i40e_hw *hw);
 
 /**
- * i40e_is_nvm_update_op - return true if this is an NVM update operation
- * @desc: API request descriptor
- **/
-static inline bool i40e_is_nvm_update_op(struct i40e_aq_desc *desc)
-{
-        return (desc->opcode == cpu_to_le16(i40e_aqc_opc_nvm_erase)) ||
-                (desc->opcode == cpu_to_le16(i40e_aqc_opc_nvm_update));
-}
-
-/**
  *  i40e_adminq_init_regs - Initialize AdminQ registers
  *  @hw: pointer to the hardware structure
  *
@@ -624,7 +614,7 @@ i40e_status i40e_init_adminq(struct i40e_hw *hw)
 
         /* pre-emptive resource lock release */
         i40e_aq_release_resource(hw, I40E_NVM_RESOURCE_ID, 0, NULL);
-        hw->aq.nvm_release_on_done = false;
+        hw->nvm_release_on_done = false;
         hw->nvmupd_state = I40E_NVMUPD_STATE_INIT;
 
         ret_code = i40e_aq_set_hmc_resource_profile(hw,
@@ -1023,26 +1013,7 @@ i40e_status i40e_clean_arq_element(struct i40e_hw *hw,
         hw->aq.arq.next_to_clean = ntc;
         hw->aq.arq.next_to_use = ntu;
 
-        if (i40e_is_nvm_update_op(&e->desc)) {
-                if (hw->aq.nvm_release_on_done) {
-                        i40e_release_nvm(hw);
-                        hw->aq.nvm_release_on_done = false;
-                }
-
-                switch (hw->nvmupd_state) {
-                case I40E_NVMUPD_STATE_INIT_WAIT:
-                        hw->nvmupd_state = I40E_NVMUPD_STATE_INIT;
-                        break;
-
-                case I40E_NVMUPD_STATE_WRITE_WAIT:
-                        hw->nvmupd_state = I40E_NVMUPD_STATE_WRITING;
-                        break;
-
-                default:
-                        break;
-                }
-        }
-
+        i40e_nvmupd_check_wait_event(hw, le16_to_cpu(e->desc.opcode));
 clean_arq_element_out:
         /* Set pending if needed, unlock and return */
         if (pending)
diff --git a/drivers/net/ethernet/intel/i40e/i40e_adminq.h b/drivers/net/ethernet/intel/i40e/i40e_adminq.h
index 12fbbddea299..d92aad38afdc 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_adminq.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_adminq.h
@@ -97,7 +97,6 @@ struct i40e_adminq_info {
         u32 fw_build;                   /* firmware build number */
         u16 api_maj_ver;                /* api major version */
         u16 api_min_ver;                /* api minor version */
-        bool nvm_release_on_done;
 
         struct mutex asq_mutex; /* Send queue lock */
         struct mutex arq_mutex; /* Receive queue lock */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_client.c b/drivers/net/ethernet/intel/i40e/i40e_client.c
new file mode 100644
index 000000000000..0e6ac841321c
--- /dev/null
+++ b/drivers/net/ethernet/intel/i40e/i40e_client.c
@@ -0,0 +1,1012 @@
+/*******************************************************************************
+ *
+ * Intel Ethernet Controller XL710 Family Linux Driver
+ * Copyright(c) 2013 - 2015 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ ******************************************************************************/
+
+#include <linux/list.h>
+#include <linux/errno.h>
+
+#include "i40e.h"
+#include "i40e_prototype.h"
+#include "i40e_client.h"
+
+static const char i40e_client_interface_version_str[] = I40E_CLIENT_VERSION_STR;
+
+static LIST_HEAD(i40e_devices);
+static DEFINE_MUTEX(i40e_device_mutex);
+
+static LIST_HEAD(i40e_clients);
+static DEFINE_MUTEX(i40e_client_mutex);
+
+static LIST_HEAD(i40e_client_instances);
+static DEFINE_MUTEX(i40e_client_instance_mutex);
+
+static int i40e_client_virtchnl_send(struct i40e_info *ldev,
+                                     struct i40e_client *client,
+                                     u32 vf_id, u8 *msg, u16 len);
+
+static int i40e_client_setup_qvlist(struct i40e_info *ldev,
+                                    struct i40e_client *client,
+                                    struct i40e_qvlist_info *qvlist_info);
+
+static void i40e_client_request_reset(struct i40e_info *ldev,
+                                      struct i40e_client *client,
+                                      u32 reset_level);
+
+static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev,
+                                       struct i40e_client *client,
+                                       bool is_vf, u32 vf_id,
+                                       u32 flag, u32 valid_flag);
+
+static struct i40e_ops i40e_lan_ops = {
+        .virtchnl_send = i40e_client_virtchnl_send,
+        .setup_qvlist = i40e_client_setup_qvlist,
+        .request_reset = i40e_client_request_reset,
+        .update_vsi_ctxt = i40e_client_update_vsi_ctxt,
+};
+
+/**
+ * i40e_client_type_to_vsi_type - convert client type to vsi type
+ * @client_type: the i40e_client type
+ *
+ * returns the related vsi type value
+ **/
+static
+enum i40e_vsi_type i40e_client_type_to_vsi_type(enum i40e_client_type type)
+{
+        switch (type) {
+        case I40E_CLIENT_IWARP:
+                return I40E_VSI_IWARP;
+
+        case I40E_CLIENT_VMDQ2:
+                return I40E_VSI_VMDQ2;
+
+        default:
+                pr_err("i40e: Client type unknown\n");
+                return I40E_VSI_TYPE_UNKNOWN;
+        }
+}
+
+/**
+ * i40e_client_get_params - Get the params that can change at runtime
+ * @vsi: the VSI with the message
+ * @param: clinet param struct
+ *
+ **/
+static
+int i40e_client_get_params(struct i40e_vsi *vsi, struct i40e_params *params)
+{
+        struct i40e_dcbx_config *dcb_cfg = &vsi->back->hw.local_dcbx_config;
+        int i = 0;
+
+        for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
+                u8 tc = dcb_cfg->etscfg.prioritytable[i];
+                u16 qs_handle;
+
+                /* If TC is not enabled for VSI use TC0 for UP */
+                if (!(vsi->tc_config.enabled_tc & BIT(tc)))
+                        tc = 0;
+
+                qs_handle = le16_to_cpu(vsi->info.qs_handle[tc]);
+                params->qos.prio_qos[i].tc = tc;
+                params->qos.prio_qos[i].qs_handle = qs_handle;
+                if (qs_handle == I40E_AQ_VSI_QS_HANDLE_INVALID) {
+                        dev_err(&vsi->back->pdev->dev, "Invalid queue set handle for TC = %d, vsi id = %d\n",
+                                tc, vsi->id);
+                        return -EINVAL;
+                }
+        }
+
+        params->mtu = vsi->netdev->mtu;
+        return 0;
+}
+
+/**
+ * i40e_notify_client_of_vf_msg - call the client vf message callback
+ * @vsi: the VSI with the message
+ * @vf_id: the absolute VF id that sent the message
+ * @msg: message buffer
+ * @len: length of the message
+ *
+ * If there is a client to this VSI, call the client
+ **/
+void
+i40e_notify_client_of_vf_msg(struct i40e_vsi *vsi, u32 vf_id, u8 *msg, u16 len)
+{
+        struct i40e_client_instance *cdev;
+
+        if (!vsi)
+                return;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.pf == vsi->back) {
+                        if (!cdev->client ||
+                            !cdev->client->ops ||
+                            !cdev->client->ops->virtchnl_receive) {
+                                dev_dbg(&vsi->back->pdev->dev,
+                                        "Cannot locate client instance virtual channel receive routine\n");
+                                continue;
+                        }
+                        cdev->client->ops->virtchnl_receive(&cdev->lan_info,
+                                                            cdev->client,
+                                                            vf_id, msg, len);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_notify_client_of_l2_param_changes - call the client notify callback
+ * @vsi: the VSI with l2 param changes
+ *
+ * If there is a client to this VSI, call the client
+ **/
+void i40e_notify_client_of_l2_param_changes(struct i40e_vsi *vsi)
+{
+        struct i40e_client_instance *cdev;
+        struct i40e_params params;
+
+        if (!vsi)
+                return;
+        memset(&params, 0, sizeof(params));
+        i40e_client_get_params(vsi, &params);
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.pf == vsi->back) {
+                        if (!cdev->client ||
+                            !cdev->client->ops ||
+                            !cdev->client->ops->l2_param_change) {
+                                dev_dbg(&vsi->back->pdev->dev,
+                                        "Cannot locate client instance l2_param_change routine\n");
+                                continue;
+                        }
+                        cdev->lan_info.params = params;
+                        cdev->client->ops->l2_param_change(&cdev->lan_info,
+                                                           cdev->client,
+                                                           &params);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_notify_client_of_netdev_open - call the client open callback
+ * @vsi: the VSI with netdev opened
+ *
+ * If there is a client to this netdev, call the client with open
+ **/
+void i40e_notify_client_of_netdev_open(struct i40e_vsi *vsi)
+{
+        struct i40e_client_instance *cdev;
+
+        if (!vsi)
+                return;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.netdev == vsi->netdev) {
+                        if (!cdev->client ||
+                            !cdev->client->ops || !cdev->client->ops->open) {
+                                dev_dbg(&vsi->back->pdev->dev,
+                                        "Cannot locate client instance open routine\n");
+                                continue;
+                        }
+                        cdev->client->ops->open(&cdev->lan_info, cdev->client);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_client_release_qvlist
+ * @ldev: pointer to L2 context.
+ *
+ **/
+static void i40e_client_release_qvlist(struct i40e_info *ldev)
+{
+        struct i40e_qvlist_info *qvlist_info = ldev->qvlist_info;
+        u32 i;
+
+        if (!ldev->qvlist_info)
+                return;
+
+        for (i = 0; i < qvlist_info->num_vectors; i++) {
+                struct i40e_pf *pf = ldev->pf;
+                struct i40e_qv_info *qv_info;
+                u32 reg_idx;
+
+                qv_info = &qvlist_info->qv_info[i];
+                if (!qv_info)
+                        continue;
+                reg_idx = I40E_PFINT_LNKLSTN(qv_info->v_idx - 1);
+                wr32(&pf->hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK);
+        }
+        kfree(ldev->qvlist_info);
+        ldev->qvlist_info = NULL;
+}
+
+/**
+ * i40e_notify_client_of_netdev_close - call the client close callback
+ * @vsi: the VSI with netdev closed
+ * @reset: true when close called due to a reset pending
+ *
+ * If there is a client to this netdev, call the client with close
+ **/
+void i40e_notify_client_of_netdev_close(struct i40e_vsi *vsi, bool reset)
+{
+        struct i40e_client_instance *cdev;
+
+        if (!vsi)
+                return;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.netdev == vsi->netdev) {
+                        if (!cdev->client ||
+                            !cdev->client->ops || !cdev->client->ops->close) {
+                                dev_dbg(&vsi->back->pdev->dev,
+                                        "Cannot locate client instance close routine\n");
+                                continue;
+                        }
+                        cdev->client->ops->close(&cdev->lan_info, cdev->client,
+                                                 reset);
+                        i40e_client_release_qvlist(&cdev->lan_info);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_notify_client_of_vf_reset - call the client vf reset callback
+ * @pf: PF device pointer
+ * @vf_id: asolute id of VF being reset
+ *
+ * If there is a client attached to this PF, notify when a VF is reset
+ **/
+void i40e_notify_client_of_vf_reset(struct i40e_pf *pf, u32 vf_id)
+{
+        struct i40e_client_instance *cdev;
+
+        if (!pf)
+                return;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.pf == pf) {
+                        if (!cdev->client ||
+                            !cdev->client->ops ||
+                            !cdev->client->ops->vf_reset) {
+                                dev_dbg(&pf->pdev->dev,
+                                        "Cannot locate client instance VF reset routine\n");
+                                continue;
+                        }
+                        cdev->client->ops->vf_reset(&cdev->lan_info,
+                                                    cdev->client, vf_id);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_notify_client_of_vf_enable - call the client vf notification callback
+ * @pf: PF device pointer
+ * @num_vfs: the number of VFs currently enabled, 0 for disable
+ *
+ * If there is a client attached to this PF, call its VF notification routine
+ **/
+void i40e_notify_client_of_vf_enable(struct i40e_pf *pf, u32 num_vfs)
+{
+        struct i40e_client_instance *cdev;
+
+        if (!pf)
+                return;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.pf == pf) {
+                        if (!cdev->client ||
+                            !cdev->client->ops ||
+                            !cdev->client->ops->vf_enable) {
+                                dev_dbg(&pf->pdev->dev,
+                                        "Cannot locate client instance VF enable routine\n");
+                                continue;
+                        }
+                        cdev->client->ops->vf_enable(&cdev->lan_info,
+                                                     cdev->client, num_vfs);
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+}
+
+/**
+ * i40e_vf_client_capable - ask the client if it likes the specified VF
+ * @pf: PF device pointer
+ * @vf_id: the VF in question
+ *
+ * If there is a client of the specified type attached to this PF, call
+ * its vf_capable routine
+ **/
+int i40e_vf_client_capable(struct i40e_pf *pf, u32 vf_id,
+                           enum i40e_client_type type)
+{
+        struct i40e_client_instance *cdev;
+        int capable = false;
+
+        if (!pf)
+                return false;
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if (cdev->lan_info.pf == pf) {
+                        if (!cdev->client ||
+                            !cdev->client->ops ||
+                            !cdev->client->ops->vf_capable ||
+                            !(cdev->client->type == type)) {
+                                dev_dbg(&pf->pdev->dev,
+                                        "Cannot locate client instance VF capability routine\n");
+                                continue;
+                        }
+                        capable = cdev->client->ops->vf_capable(&cdev->lan_info,
+                                                                cdev->client,
+                                                                vf_id);
+                        break;
+                }
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+        return capable;
+}
+
+/**
+ * i40e_vsi_lookup - finds a matching VSI from the PF list starting at start_vsi
+ * @pf: board private structure
+ * @type: vsi type
+ * @start_vsi: a VSI pointer from where to start the search
+ *
+ * Returns non NULL on success or NULL for failure
+ **/
+struct i40e_vsi *i40e_vsi_lookup(struct i40e_pf *pf,
+                                 enum i40e_vsi_type type,
+                                 struct i40e_vsi *start_vsi)
+{
+        struct i40e_vsi *vsi;
+        int i = 0;
+
+        if (start_vsi) {
+                for (i = 0; i < pf->num_alloc_vsi; i++) {
+                        vsi = pf->vsi[i];
+                        if (vsi == start_vsi)
+                                break;
+                }
+        }
+        for (; i < pf->num_alloc_vsi; i++) {
+                vsi = pf->vsi[i];
+                if (vsi && vsi->type == type)
+                        return vsi;
+        }
+
+        return NULL;
+}
+
+/**
+ * i40e_client_add_instance - add a client instance struct to the instance list
+ * @pf: pointer to the board struct
+ * @client: pointer to a client struct in the client list.
+ *
+ * Returns cdev ptr on success, NULL on failure
+ **/
+static
+struct i40e_client_instance *i40e_client_add_instance(struct i40e_pf *pf,
+                                                      struct i40e_client *client)
+{
+        struct i40e_client_instance *cdev;
+        struct netdev_hw_addr *mac = NULL;
+        struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
+
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry(cdev, &i40e_client_instances, list) {
+                if ((cdev->lan_info.pf == pf) && (cdev->client == client)) {
+                        cdev = NULL;
+                        goto out;
+                }
+        }
+        cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
+        if (!cdev)
+                goto out;
+
+        cdev->lan_info.pf = (void *)pf;
+        cdev->lan_info.netdev = vsi->netdev;
+        cdev->lan_info.pcidev = pf->pdev;
+        cdev->lan_info.fid = pf->hw.pf_id;
+        cdev->lan_info.ftype = I40E_CLIENT_FTYPE_PF;
+        cdev->lan_info.hw_addr = pf->hw.hw_addr;
+        cdev->lan_info.ops = &i40e_lan_ops;
+        cdev->lan_info.version.major = I40E_CLIENT_VERSION_MAJOR;
+        cdev->lan_info.version.minor = I40E_CLIENT_VERSION_MINOR;
+        cdev->lan_info.version.build = I40E_CLIENT_VERSION_BUILD;
+        cdev->lan_info.fw_maj_ver = pf->hw.aq.fw_maj_ver;
+        cdev->lan_info.fw_min_ver = pf->hw.aq.fw_min_ver;
+        cdev->lan_info.fw_build = pf->hw.aq.fw_build;
+        set_bit(__I40E_CLIENT_INSTANCE_NONE, &cdev->state);
+
+        if (i40e_client_get_params(vsi, &cdev->lan_info.params)) {
+                kfree(cdev);
+                cdev = NULL;
+                goto out;
+        }
+
+        cdev->lan_info.msix_count = pf->num_iwarp_msix;
+        cdev->lan_info.msix_entries = &pf->msix_entries[pf->iwarp_base_vector];
+
+        mac = list_first_entry(&cdev->lan_info.netdev->dev_addrs.list,
+                               struct netdev_hw_addr, list);
+        if (mac)
+                ether_addr_copy(cdev->lan_info.lanmac, mac->addr);
+        else
+                dev_err(&pf->pdev->dev, "MAC address list is empty!\n");
+
+        cdev->client = client;
+        INIT_LIST_HEAD(&cdev->list);
+        list_add(&cdev->list, &i40e_client_instances);
+out:
+        mutex_unlock(&i40e_client_instance_mutex);
+        return cdev;
+}
+
+/**
+ * i40e_client_del_instance - removes a client instance from the list
+ * @pf: pointer to the board struct
+ *
+ * Returns 0 on success or non-0 on error
+ **/
+static
+int i40e_client_del_instance(struct i40e_pf *pf, struct i40e_client *client)
+{
+        struct i40e_client_instance *cdev, *tmp;
+        int ret = -ENODEV;
+
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry_safe(cdev, tmp, &i40e_client_instances, list) {
+                if ((cdev->lan_info.pf != pf) || (cdev->client != client))
+                        continue;
+
+                dev_info(&pf->pdev->dev, "Deleted instance of Client %s, of dev %d bus=0x%02x func=0x%02x)\n",
+                         client->name, pf->hw.pf_id,
+                         pf->hw.bus.device, pf->hw.bus.func);
+                list_del(&cdev->list);
+                kfree(cdev);
+                ret = 0;
+                break;
+        }
+        mutex_unlock(&i40e_client_instance_mutex);
+        return ret;
+}
+
+/**
+ * i40e_client_subtask - client maintenance work
+ * @pf: board private structure
+ **/
+void i40e_client_subtask(struct i40e_pf *pf)
+{
+        struct i40e_client_instance *cdev;
+        struct i40e_client *client;
+        int ret = 0;
+
+        if (!(pf->flags & I40E_FLAG_SERVICE_CLIENT_REQUESTED))
+                return;
+        pf->flags &= ~I40E_FLAG_SERVICE_CLIENT_REQUESTED;
+
+        /* If we're down or resetting, just bail */
+        if (test_bit(__I40E_DOWN, &pf->state) ||
+            test_bit(__I40E_CONFIG_BUSY, &pf->state))
+                return;
+
+        /* Check client state and instantiate client if client registered */
+        mutex_lock(&i40e_client_mutex);
+        list_for_each_entry(client, &i40e_clients, list) {
+                /* first check client is registered */
+                if (!test_bit(__I40E_CLIENT_REGISTERED, &client->state))
+                        continue;
+
+                /* Do we also need the LAN VSI to be up, to create instance */
+                if (!(client->flags & I40E_CLIENT_FLAGS_LAUNCH_ON_PROBE)) {
+                        /* check if L2 VSI is up, if not we are not ready */
+                        if (test_bit(__I40E_DOWN, &pf->vsi[pf->lan_vsi]->state))
+                                continue;
+                }
+
+                /* Add the client instance to the instance list */
+                cdev = i40e_client_add_instance(pf, client);
+                if (!cdev)
+                        continue;
+
+                /* Also up the ref_cnt of no. of instances of this client */
+                atomic_inc(&client->ref_cnt);
+                dev_info(&pf->pdev->dev, "Added instance of Client %s to PF%d bus=0x%02x func=0x%02x\n",
+                         client->name, pf->hw.pf_id,
+                         pf->hw.bus.device, pf->hw.bus.func);
+
+                /* Send an Open request to the client */
+                atomic_inc(&cdev->ref_cnt);
+                if (client->ops && client->ops->open)
+                        ret = client->ops->open(&cdev->lan_info, client);
+                atomic_dec(&cdev->ref_cnt);
+                if (!ret) {
+                        set_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
+                } else {
+                        /* remove client instance */
+                        i40e_client_del_instance(pf, client);
+                        atomic_dec(&client->ref_cnt);
+                        continue;
+                }
+        }
+        mutex_unlock(&i40e_client_mutex);
+}
+
+/**
+ * i40e_lan_add_device - add a lan device struct to the list of lan devices
+ * @pf: pointer to the board struct
+ *
+ * Returns 0 on success or none 0 on error
+ **/
+int i40e_lan_add_device(struct i40e_pf *pf)
+{
+        struct i40e_device *ldev;
+        int ret = 0;
+
+        mutex_lock(&i40e_device_mutex);
+        list_for_each_entry(ldev, &i40e_devices, list) {
+                if (ldev->pf == pf) {
+                        ret = -EEXIST;
+                        goto out;
+                }
+        }
+        ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
+        if (!ldev) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ldev->pf = pf;
+        INIT_LIST_HEAD(&ldev->list);
+        list_add(&ldev->list, &i40e_devices);
+        dev_info(&pf->pdev->dev, "Added LAN device PF%d bus=0x%02x func=0x%02x\n",
+                 pf->hw.pf_id, pf->hw.bus.device, pf->hw.bus.func);
+
+        /* Since in some cases register may have happened before a device gets
+         * added, we can schedule a subtask to go initiate the clients.
+         */
+        pf->flags |= I40E_FLAG_SERVICE_CLIENT_REQUESTED;
+        i40e_service_event_schedule(pf);
+
+out:
+        mutex_unlock(&i40e_device_mutex);
+        return ret;
+}
+
+/**
+ * i40e_lan_del_device - removes a lan device from the device list
+ * @pf: pointer to the board struct
+ *
+ * Returns 0 on success or non-0 on error
+ **/
+int i40e_lan_del_device(struct i40e_pf *pf)
+{
+        struct i40e_device *ldev, *tmp;
+        int ret = -ENODEV;
+
+        mutex_lock(&i40e_device_mutex);
+        list_for_each_entry_safe(ldev, tmp, &i40e_devices, list) {
+                if (ldev->pf == pf) {
+                        dev_info(&pf->pdev->dev, "Deleted LAN device PF%d bus=0x%02x func=0x%02x\n",
+                                 pf->hw.pf_id, pf->hw.bus.device,
+                                 pf->hw.bus.func);
+                        list_del(&ldev->list);
+                        kfree(ldev);
+                        ret = 0;
+                        break;
+                }
+        }
+
+        mutex_unlock(&i40e_device_mutex);
+        return ret;
+}
+
+/**
+ * i40e_client_release - release client specific resources
+ * @client: pointer to the registered client
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_client_release(struct i40e_client *client)
+{
+        struct i40e_client_instance *cdev, *tmp;
+        struct i40e_pf *pf = NULL;
+        int ret = 0;
+
+        LIST_HEAD(cdevs_tmp);
+
+        mutex_lock(&i40e_client_instance_mutex);
+        list_for_each_entry_safe(cdev, tmp, &i40e_client_instances, list) {
+                if (strncmp(cdev->client->name, client->name,
+                            I40E_CLIENT_STR_LENGTH))
+                        continue;
+                if (test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
+                        if (atomic_read(&cdev->ref_cnt) > 0) {
+                                ret = I40E_ERR_NOT_READY;
+                                goto out;
+                        }
+                        pf = (struct i40e_pf *)cdev->lan_info.pf;
+                        if (client->ops && client->ops->close)
+                                client->ops->close(&cdev->lan_info, client,
+                                                   false);
+                        i40e_client_release_qvlist(&cdev->lan_info);
+                        clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
+
+                        dev_warn(&pf->pdev->dev,
+                                 "Client %s instance for PF id %d closed\n",
+                                 client->name, pf->hw.pf_id);
+                }
+                /* delete the client instance from the list */
+                list_del(&cdev->list);
+                list_add(&cdev->list, &cdevs_tmp);
+                atomic_dec(&client->ref_cnt);
+                dev_info(&pf->pdev->dev, "Deleted client instance of Client %s\n",
+                         client->name);
+        }
+out:
+        mutex_unlock(&i40e_client_instance_mutex);
+
+        /* free the client device and release its vsi */
+        list_for_each_entry_safe(cdev, tmp, &cdevs_tmp, list) {
+                kfree(cdev);
+        }
+        return ret;
+}
+
+/**
+ * i40e_client_prepare - prepare client specific resources
+ * @client: pointer to the registered client
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_client_prepare(struct i40e_client *client)
+{
+        struct i40e_device *ldev;
+        struct i40e_pf *pf;
+        int ret = 0;
+
+        mutex_lock(&i40e_device_mutex);
+        list_for_each_entry(ldev, &i40e_devices, list) {
+                pf = ldev->pf;
+                /* Start the client subtask */
+                pf->flags |= I40E_FLAG_SERVICE_CLIENT_REQUESTED;
+                i40e_service_event_schedule(pf);
+        }
+        mutex_unlock(&i40e_device_mutex);
+        return ret;
+}
+
+/**
+ * i40e_client_virtchnl_send - TBD
+ * @ldev: pointer to L2 context
+ * @client: Client pointer
+ * @vf_id: absolute VF identifier
+ * @msg: message buffer
+ * @len: length of message buffer
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_client_virtchnl_send(struct i40e_info *ldev,
+                                     struct i40e_client *client,
+                                     u32 vf_id, u8 *msg, u16 len)
+{
+        struct i40e_pf *pf = ldev->pf;
+        struct i40e_hw *hw = &pf->hw;
+        i40e_status err;
+
+        err = i40e_aq_send_msg_to_vf(hw, vf_id, I40E_VIRTCHNL_OP_IWARP,
+                                     0, msg, len, NULL);
+        if (err)
+                dev_err(&pf->pdev->dev, "Unable to send iWarp message to VF, error %d, aq status %d\n",
+                        err, hw->aq.asq_last_status);
+
+        return err;
+}
+
+/**
+ * i40e_client_setup_qvlist
+ * @ldev: pointer to L2 context.
+ * @client: Client pointer.
+ * @qv_info: queue and vector list
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_client_setup_qvlist(struct i40e_info *ldev,
+                                    struct i40e_client *client,
+                                    struct i40e_qvlist_info *qvlist_info)
+{
+        struct i40e_pf *pf = ldev->pf;
+        struct i40e_hw *hw = &pf->hw;
+        struct i40e_qv_info *qv_info;
+        u32 v_idx, i, reg_idx, reg;
+        u32 size;
+
+        size = sizeof(struct i40e_qvlist_info) +
+               (sizeof(struct i40e_qv_info) * (qvlist_info->num_vectors - 1));
+        ldev->qvlist_info = kzalloc(size, GFP_KERNEL);
+        ldev->qvlist_info->num_vectors = qvlist_info->num_vectors;
+
+        for (i = 0; i < qvlist_info->num_vectors; i++) {
+                qv_info = &qvlist_info->qv_info[i];
+                if (!qv_info)
+                        continue;
+                v_idx = qv_info->v_idx;
+
+                /* Validate vector id belongs to this client */
+                if ((v_idx >= (pf->iwarp_base_vector + pf->num_iwarp_msix)) ||
+                    (v_idx < pf->iwarp_base_vector))
+                        goto err;
+
+                ldev->qvlist_info->qv_info[i] = *qv_info;
+                reg_idx = I40E_PFINT_LNKLSTN(v_idx - 1);
+
+                if (qv_info->ceq_idx == I40E_QUEUE_INVALID_IDX) {
+                        /* Special case - No CEQ mapped on this vector */
+                        wr32(hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK);
+                } else {
+                        reg = (qv_info->ceq_idx &
+                               I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) |
+                               (I40E_QUEUE_TYPE_PE_CEQ <<
+                               I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
+                        wr32(hw, reg_idx, reg);
+
+                        reg = (I40E_PFINT_CEQCTL_CAUSE_ENA_MASK |
+                               (v_idx << I40E_PFINT_CEQCTL_MSIX_INDX_SHIFT) |
+                               (qv_info->itr_idx <<
+                                I40E_PFINT_CEQCTL_ITR_INDX_SHIFT) |
+                               (I40E_QUEUE_END_OF_LIST <<
+                                I40E_PFINT_CEQCTL_NEXTQ_INDX_SHIFT));
+                        wr32(hw, I40E_PFINT_CEQCTL(qv_info->ceq_idx), reg);
+                }
+                if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
+                        reg = (I40E_PFINT_AEQCTL_CAUSE_ENA_MASK |
+                               (v_idx << I40E_PFINT_AEQCTL_MSIX_INDX_SHIFT) |
+                               (qv_info->itr_idx <<
+                                I40E_PFINT_AEQCTL_ITR_INDX_SHIFT));
+
+                        wr32(hw, I40E_PFINT_AEQCTL, reg);
+                }
+        }
+
+        return 0;
+err:
+        kfree(ldev->qvlist_info);
+        ldev->qvlist_info = NULL;
+        return -EINVAL;
+}
+
+/**
+ * i40e_client_request_reset
+ * @ldev: pointer to L2 context.
+ * @client: Client pointer.
+ * @level: reset level
+ **/
+static void i40e_client_request_reset(struct i40e_info *ldev,
+                                      struct i40e_client *client,
+                                      u32 reset_level)
+{
+        struct i40e_pf *pf = ldev->pf;
+
+        switch (reset_level) {
+        case I40E_CLIENT_RESET_LEVEL_PF:
+                set_bit(__I40E_PF_RESET_REQUESTED, &pf->state);
+                break;
+        case I40E_CLIENT_RESET_LEVEL_CORE:
+                set_bit(__I40E_PF_RESET_REQUESTED, &pf->state);
+                break;
+        default:
+                dev_warn(&pf->pdev->dev,
+                         "Client %s instance for PF id %d request an unsupported reset: %d.\n",
+                         client->name, pf->hw.pf_id, reset_level);
+                break;
+        }
+
+        i40e_service_event_schedule(pf);
+}
+
+/**
+ * i40e_client_update_vsi_ctxt
+ * @ldev: pointer to L2 context.
+ * @client: Client pointer.
+ * @is_vf: if this for the VF
+ * @vf_id: if is_vf true this carries the vf_id
+ * @flag: Any device level setting that needs to be done for PE
+ * @valid_flag: Bits in this match up and enable changing of flag bits
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev,
+                                       struct i40e_client *client,
+                                       bool is_vf, u32 vf_id,
+                                       u32 flag, u32 valid_flag)
+{
+        struct i40e_pf *pf = ldev->pf;
+        struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
+        struct i40e_vsi_context ctxt;
+        bool update = true;
+        i40e_status err;
+
+        /* TODO: for now do not allow setting VF's VSI setting */
+        if (is_vf)
+                return -EINVAL;
+
+        ctxt.seid = pf->main_vsi_seid;
+        ctxt.pf_num = pf->hw.pf_id;
+        err = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL);
+        ctxt.flags = I40E_AQ_VSI_TYPE_PF;
+        if (err) {
+                dev_info(&pf->pdev->dev,
+                         "couldn't get PF vsi config, err %s aq_err %s\n",
+                         i40e_stat_str(&pf->hw, err),
+                         i40e_aq_str(&pf->hw,
+                                     pf->hw.aq.asq_last_status));
+                return -ENOENT;
+        }
+
+        if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
+            (flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
+                ctxt.info.valid_sections =
+                        cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
+                ctxt.info.queueing_opt_flags |= I40E_AQ_VSI_QUE_OPT_TCP_ENA;
+        } else if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
+                  !(flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
+                ctxt.info.valid_sections =
+                        cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
+                ctxt.info.queueing_opt_flags &= ~I40E_AQ_VSI_QUE_OPT_TCP_ENA;
+        } else {
+                update = false;
+                dev_warn(&pf->pdev->dev,
+                         "Client %s instance for PF id %d request an unsupported Config: %x.\n",
+                         client->name, pf->hw.pf_id, flag);
+        }
+
+        if (update) {
+                err = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
+                if (err) {
+                        dev_info(&pf->pdev->dev,
+                                 "update VSI ctxt for PE failed, err %s aq_err %s\n",
+                                 i40e_stat_str(&pf->hw, err),
+                                 i40e_aq_str(&pf->hw,
+                                             pf->hw.aq.asq_last_status));
+                }
+        }
+        return err;
+}
+
+/**
+ * i40e_register_client - Register a i40e client driver with the L2 driver
+ * @client: pointer to the i40e_client struct
+ *
+ * Returns 0 on success or non-0 on error
+ **/
+int i40e_register_client(struct i40e_client *client)
+{
+        int ret = 0;
+        enum i40e_vsi_type vsi_type;
+
+        if (!client) {
+                ret = -EIO;
+                goto out;
+        }
+
+        if (strlen(client->name) == 0) {
+                pr_info("i40e: Failed to register client with no name\n");
+                ret = -EIO;
+                goto out;
+        }
+
+        mutex_lock(&i40e_client_mutex);
+        if (i40e_client_is_registered(client)) {
+                pr_info("i40e: Client %s has already been registered!\n",
+                        client->name);
+                mutex_unlock(&i40e_client_mutex);
+                ret = -EEXIST;
+                goto out;
+        }
+
+        if ((client->version.major != I40E_CLIENT_VERSION_MAJOR) ||
+            (client->version.minor != I40E_CLIENT_VERSION_MINOR)) {
+                pr_info("i40e: Failed to register client %s due to mismatched client interface version\n",
+                        client->name);
+                pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n",
+                        client->version.major, client->version.minor,
+                        client->version.build,
+                        i40e_client_interface_version_str);
+                mutex_unlock(&i40e_client_mutex);
+                ret = -EIO;
+                goto out;
+        }
+
+        vsi_type = i40e_client_type_to_vsi_type(client->type);
+        if (vsi_type == I40E_VSI_TYPE_UNKNOWN) {
+                pr_info("i40e: Failed to register client %s due to unknown client type %d\n",
+                        client->name, client->type);
+                mutex_unlock(&i40e_client_mutex);
+                ret = -EIO;
+                goto out;
+        }
+        list_add(&client->list, &i40e_clients);
+        set_bit(__I40E_CLIENT_REGISTERED, &client->state);
+        mutex_unlock(&i40e_client_mutex);
+
+        if (i40e_client_prepare(client)) {
+                ret = -EIO;
+                goto out;
+        }
+
+        pr_info("i40e: Registered client %s with return code %d\n",
+                client->name, ret);
+out:
+        return ret;
+}
+EXPORT_SYMBOL(i40e_register_client);
+
+/**
+ * i40e_unregister_client - Unregister a i40e client driver with the L2 driver
+ * @client: pointer to the i40e_client struct
+ *
+ * Returns 0 on success or non-0 on error
+ **/
+int i40e_unregister_client(struct i40e_client *client)
+{
+        int ret = 0;
+
+        /* When a unregister request comes through we would have to send
+         * a close for each of the client instances that were opened.
+         * client_release function is called to handle this.
+         */
+        if (!client || i40e_client_release(client)) {
+                ret = -EIO;
+                goto out;
+        }
+
+        /* TODO: check if device is in reset, or if that matters? */
+        mutex_lock(&i40e_client_mutex);
+        if (!i40e_client_is_registered(client)) {
+                pr_info("i40e: Client %s has not been registered\n",
+                        client->name);
+                mutex_unlock(&i40e_client_mutex);
+                ret = -ENODEV;
+                goto out;
+        }
+        if (atomic_read(&client->ref_cnt) == 0) {
+                clear_bit(__I40E_CLIENT_REGISTERED, &client->state);
+                list_del(&client->list);
+                pr_info("i40e: Unregistered client %s with return code %d\n",
+                        client->name, ret);
+        } else {
+                ret = I40E_ERR_NOT_READY;
+                pr_err("i40e: Client %s failed unregister - client has open instances\n",
+                       client->name);
+        }
+
+        mutex_unlock(&i40e_client_mutex);
+out:
+        return ret;
+}
+EXPORT_SYMBOL(i40e_unregister_client);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_client.h b/drivers/net/ethernet/intel/i40e/i40e_client.h
new file mode 100644
index 000000000000..bf6b453d93a1
--- /dev/null
+++ b/drivers/net/ethernet/intel/i40e/i40e_client.h
@@ -0,0 +1,232 @@
+/*******************************************************************************
+ *
+ * Intel Ethernet Controller XL710 Family Linux Driver
+ * Copyright(c) 2013 - 2015 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ *
+ ******************************************************************************/
+
+#ifndef _I40E_CLIENT_H_
+#define _I40E_CLIENT_H_
+
+#define I40E_CLIENT_STR_LENGTH 10
+
+/* Client interface version should be updated anytime there is a change in the
+ * existing APIs or data structures.
+ */
+#define I40E_CLIENT_VERSION_MAJOR 0
+#define I40E_CLIENT_VERSION_MINOR 01
+#define I40E_CLIENT_VERSION_BUILD 00
+#define I40E_CLIENT_VERSION_STR     \
+        XSTRINGIFY(I40E_CLIENT_VERSION_MAJOR) "." \
+        XSTRINGIFY(I40E_CLIENT_VERSION_MINOR) "." \
+        XSTRINGIFY(I40E_CLIENT_VERSION_BUILD)
+
+struct i40e_client_version {
+        u8 major;
+        u8 minor;
+        u8 build;
+        u8 rsvd;
+};
+
+enum i40e_client_state {
+        __I40E_CLIENT_NULL,
+        __I40E_CLIENT_REGISTERED
+};
+
+enum i40e_client_instance_state {
+        __I40E_CLIENT_INSTANCE_NONE,
+        __I40E_CLIENT_INSTANCE_OPENED,
+};
+
+enum i40e_client_type {
+        I40E_CLIENT_IWARP,
+        I40E_CLIENT_VMDQ2
+};
+
+struct i40e_ops;
+struct i40e_client;
+
+/* HW does not define a type value for AEQ; only for RX/TX and CEQ.
+ * In order for us to keep the interface simple, SW will define a
+ * unique type value for AEQ.
+ */
+#define I40E_QUEUE_TYPE_PE_AEQ  0x80
+#define I40E_QUEUE_INVALID_IDX  0xFFFF
+
+struct i40e_qv_info {
+        u32 v_idx; /* msix_vector */
+        u16 ceq_idx;
+        u16 aeq_idx;
+        u8 itr_idx;
+};
+
+struct i40e_qvlist_info {
+        u32 num_vectors;
+        struct i40e_qv_info qv_info[1];
+};
+
+#define I40E_CLIENT_MSIX_ALL 0xFFFFFFFF
+
+/* set of LAN parameters useful for clients managed by LAN */
+
+/* Struct to hold per priority info */
+struct i40e_prio_qos_params {
+        u16 qs_handle; /* qs handle for prio */
+        u8 tc; /* TC mapped to prio */
+        u8 reserved;
+};
+
+#define I40E_CLIENT_MAX_USER_PRIORITY        8
+/* Struct to hold Client QoS */
+struct i40e_qos_params {
+        struct i40e_prio_qos_params prio_qos[I40E_CLIENT_MAX_USER_PRIORITY];
+};
+
+struct i40e_params {
+        struct i40e_qos_params qos;
+        u16 mtu;
+};
+
+/* Structure to hold Lan device info for a client device */
+struct i40e_info {
+        struct i40e_client_version version;
+        u8 lanmac[6];
+        struct net_device *netdev;
+        struct pci_dev *pcidev;
+        u8 __iomem *hw_addr;
+        u8 fid; /* function id, PF id or VF id */
+#define I40E_CLIENT_FTYPE_PF 0
+#define I40E_CLIENT_FTYPE_VF 1
+        u8 ftype; /* function type, PF or VF */
+        void *pf;
+
+        /* All L2 params that could change during the life span of the PF
+         * and needs to be communicated to the client when they change
+         */
+        struct i40e_qvlist_info *qvlist_info;
+        struct i40e_params params;
+        struct i40e_ops *ops;
+
+        u16 msix_count;  /* number of msix vectors*/
+        /* Array down below will be dynamically allocated based on msix_count */
+        struct msix_entry *msix_entries;
+        u16 itr_index; /* Which ITR index the PE driver is suppose to use */
+        u16 fw_maj_ver;                 /* firmware major version */
+        u16 fw_min_ver;                 /* firmware minor version */
+        u32 fw_build;                   /* firmware build number */
+};
+
+#define I40E_CLIENT_RESET_LEVEL_PF   1
+#define I40E_CLIENT_RESET_LEVEL_CORE 2
+#define I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE  BIT(1)
+
+struct i40e_ops {
+        /* setup_q_vector_list enables queues with a particular vector */
+        int (*setup_qvlist)(struct i40e_info *ldev, struct i40e_client *client,
+                            struct i40e_qvlist_info *qv_info);
+
+        int (*virtchnl_send)(struct i40e_info *ldev, struct i40e_client *client,
+                             u32 vf_id, u8 *msg, u16 len);
+
+        /* If the PE Engine is unresponsive, RDMA driver can request a reset.
+         * The level helps determine the level of reset being requested.
+         */
+        void (*request_reset)(struct i40e_info *ldev,
+                              struct i40e_client *client, u32 level);
+
+        /* API for the RDMA driver to set certain VSI flags that control
+         * PE Engine.
+         */
+        int (*update_vsi_ctxt)(struct i40e_info *ldev,
+                               struct i40e_client *client,
+                               bool is_vf, u32 vf_id,
+                               u32 flag, u32 valid_flag);
+};
+
+struct i40e_client_ops {
+        /* Should be called from register_client() or whenever PF is ready
+         * to create a specific client instance.
+         */
+        int (*open)(struct i40e_info *ldev, struct i40e_client *client);
+
+        /* Should be called when netdev is unavailable or when unregister
+         * call comes in. If the close is happenening due to a reset being
+         * triggered set the reset bit to true.
+         */
+        void (*close)(struct i40e_info *ldev, struct i40e_client *client,
+                      bool reset);
+
+        /* called when some l2 managed parameters changes - mtu */
+        void (*l2_param_change)(struct i40e_info *ldev,
+                                struct i40e_client *client,
+                                struct i40e_params *params);
+
+        int (*virtchnl_receive)(struct i40e_info *ldev,
+                                struct i40e_client *client, u32 vf_id,
+                                u8 *msg, u16 len);
+
+        /* called when a VF is reset by the PF */
+        void (*vf_reset)(struct i40e_info *ldev,
+                         struct i40e_client *client, u32 vf_id);
+
+        /* called when the number of VFs changes */
+        void (*vf_enable)(struct i40e_info *ldev,
+                          struct i40e_client *client, u32 num_vfs);
+
+        /* returns true if VF is capable of specified offload */
+        int (*vf_capable)(struct i40e_info *ldev,
+                          struct i40e_client *client, u32 vf_id);
+};
+
+/* Client device */
+struct i40e_client_instance {
+        struct list_head list;
+        struct i40e_info lan_info;
+        struct i40e_client *client;
+        unsigned long  state;
+        /* A count of all the in-progress calls to the client */
+        atomic_t ref_cnt;
+};
+
+struct i40e_client {
+        struct list_head list;          /* list of registered clients */
+        char name[I40E_CLIENT_STR_LENGTH];
+        struct i40e_client_version version;
+        unsigned long state;            /* client state */
+        atomic_t ref_cnt;  /* Count of all the client devices of this kind */
+        u32 flags;
+#define I40E_CLIENT_FLAGS_LAUNCH_ON_PROBE       BIT(0)
+#define I40E_TX_FLAGS_NOTIFY_OTHER_EVENTS       BIT(2)
+        enum i40e_client_type type;
+        struct i40e_client_ops *ops;    /* client ops provided by the client */
+};
+
+static inline bool i40e_client_is_registered(struct i40e_client *client)
+{
+        return test_bit(__I40E_CLIENT_REGISTERED, &client->state);
+}
+
+/* used by clients */
+int i40e_register_client(struct i40e_client *client);
+int i40e_unregister_client(struct i40e_client *client);
+
+#endif /* _I40E_CLIENT_H_ */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_common.c b/drivers/net/ethernet/intel/i40e/i40e_common.c
index 4596294c2ab1..f3c1d8890cbb 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_common.c
@@ -60,6 +60,7 @@ static i40e_status i40e_set_mac_type(struct i40e_hw *hw)
                 case I40E_DEV_ID_SFP_X722:
                 case I40E_DEV_ID_1G_BASE_T_X722:
                 case I40E_DEV_ID_10G_BASE_T_X722:
+                case I40E_DEV_ID_SFP_I_X722:
                         hw->mac.type = I40E_MAC_X722;
                         break;
                 default:
@@ -1901,13 +1902,13 @@ i40e_status i40e_aq_set_phy_int_mask(struct i40e_hw *hw,
  *
  * Reset the external PHY.
  **/
-enum i40e_status_code i40e_aq_set_phy_debug(struct i40e_hw *hw, u8 cmd_flags,
-                                        struct i40e_asq_cmd_details *cmd_details)
+i40e_status i40e_aq_set_phy_debug(struct i40e_hw *hw, u8 cmd_flags,
+                                  struct i40e_asq_cmd_details *cmd_details)
 {
         struct i40e_aq_desc desc;
         struct i40e_aqc_set_phy_debug *cmd =
                 (struct i40e_aqc_set_phy_debug *)&desc.params.raw;
-        enum i40e_status_code status;
+        i40e_status status;
 
         i40e_fill_default_direct_cmd_desc(&desc,
                                           i40e_aqc_opc_set_phy_debug);
@@ -2157,6 +2158,9 @@ i40e_status i40e_aq_update_vsi_params(struct i40e_hw *hw,
         struct i40e_aq_desc desc;
         struct i40e_aqc_add_get_update_vsi *cmd =
                 (struct i40e_aqc_add_get_update_vsi *)&desc.params.raw;
+        struct i40e_aqc_add_get_update_vsi_completion *resp =
+                (struct i40e_aqc_add_get_update_vsi_completion *)
+                &desc.params.raw;
         i40e_status status;
 
         i40e_fill_default_direct_cmd_desc(&desc,
@@ -2168,6 +2172,9 @@ i40e_status i40e_aq_update_vsi_params(struct i40e_hw *hw,
         status = i40e_asq_send_command(hw, &desc, &vsi_ctx->info,
                                     sizeof(vsi_ctx->info), cmd_details);
 
+        vsi_ctx->vsis_allocated = le16_to_cpu(resp->vsi_used);
+        vsi_ctx->vsis_unallocated = le16_to_cpu(resp->vsi_free);
+
         return status;
 }
 
@@ -3073,6 +3080,9 @@ static void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
                         break;
                 case I40E_AQ_CAP_ID_MSIX:
                         p->num_msix_vectors = number;
+                        i40e_debug(hw, I40E_DEBUG_INIT,
+                                   "HW Capability: MSIX vector count = %d\n",
+                                   p->num_msix_vectors);
                         break;
                 case I40E_AQ_CAP_ID_VF_MSIX:
                         p->num_msix_vectors_vf = number;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
index 0c97733d253c..83dccf1792e7 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_debugfs.c
@@ -147,9 +147,8 @@ static void i40e_dbg_dump_vsi_seid(struct i40e_pf *pf, int seid)
                 dev_info(&pf->pdev->dev, "        vlan_features = 0x%08lx\n",
                          (unsigned long int)nd->vlan_features);
         }
-        if (vsi->active_vlans)
-                dev_info(&pf->pdev->dev,
-                         "    vlgrp: & = %p\n", vsi->active_vlans);
+        dev_info(&pf->pdev->dev,
+                 "    vlgrp: & = %p\n", vsi->active_vlans);
         dev_info(&pf->pdev->dev,
                  "    state = %li flags = 0x%08lx, netdev_registered = %i, current_netdev_flags = 0x%04x\n",
                  vsi->state, vsi->flags,
diff --git a/drivers/net/ethernet/intel/i40e/i40e_devids.h b/drivers/net/ethernet/intel/i40e/i40e_devids.h
index 99257fcd1ef4..dd4457d29e98 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_devids.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_devids.h
@@ -44,6 +44,7 @@
 #define I40E_DEV_ID_SFP_X722            0x37D0
 #define I40E_DEV_ID_1G_BASE_T_X722      0x37D1
 #define I40E_DEV_ID_10G_BASE_T_X722     0x37D2
+#define I40E_DEV_ID_SFP_I_X722          0x37D3
 
 #define i40e_is_40G_device(d)           ((d) == I40E_DEV_ID_QSFP_A  || \
                                          (d) == I40E_DEV_ID_QSFP_B  || \
diff --git a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
index 784b1659457a..8a83d4514812 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
@@ -313,6 +313,13 @@ static void i40e_get_settings_link_up(struct i40e_hw *hw,
                         ecmd->advertising |= ADVERTISED_10000baseT_Full;
                 if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
                         ecmd->advertising |= ADVERTISED_1000baseT_Full;
+                /* adding 100baseT support for 10GBASET_PHY */
+                if (pf->flags & I40E_FLAG_HAVE_10GBASET_PHY) {
+                        ecmd->supported |= SUPPORTED_100baseT_Full;
+                        ecmd->advertising |= ADVERTISED_100baseT_Full |
+                                             ADVERTISED_1000baseT_Full |
+                                             ADVERTISED_10000baseT_Full;
+                }
                 break;
         case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
                 ecmd->supported = SUPPORTED_Autoneg |
@@ -325,6 +332,15 @@ static void i40e_get_settings_link_up(struct i40e_hw *hw,
                                   SUPPORTED_100baseT_Full;
                 if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
                         ecmd->advertising |= ADVERTISED_100baseT_Full;
+                /* firmware detects 10G phy as 100M phy at 100M speed */
+                if (pf->flags & I40E_FLAG_HAVE_10GBASET_PHY) {
+                        ecmd->supported |= SUPPORTED_10000baseT_Full |
+                                           SUPPORTED_1000baseT_Full;
+                        ecmd->advertising |= ADVERTISED_Autoneg |
+                                             ADVERTISED_100baseT_Full |
+                                             ADVERTISED_1000baseT_Full |
+                                             ADVERTISED_10000baseT_Full;
+                }
                 break;
         case I40E_PHY_TYPE_10GBASE_CR1_CU:
         case I40E_PHY_TYPE_10GBASE_CR1:
@@ -1714,7 +1730,7 @@ static void i40e_diag_test(struct net_device *netdev,
                 /* If the device is online then take it offline */
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        i40e_close(netdev);
                 else
                         /* This reset does not affect link - if it is
                          * changed to a type of reset that does affect
@@ -1743,7 +1759,7 @@ static void i40e_diag_test(struct net_device *netdev,
                 i40e_do_reset(pf, BIT(__I40E_PF_RESET_REQUESTED));
 
                 if (if_running)
-                        dev_open(netdev);
+                        i40e_open(netdev);
         } else {
                 /* Online tests */
                 netif_info(pf, drv, netdev, "online testing starting\n");
diff --git a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
index 8ad162c16f61..58e6c1570335 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
  *
  * Intel Ethernet Controller XL710 Family Linux Driver
- * Copyright(c) 2013 - 2015 Intel Corporation.
+ * Copyright(c) 2013 - 2016 Intel Corporation.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -38,16 +38,6 @@
 #include "i40e_fcoe.h"
 
 /**
- * i40e_rx_is_fcoe - returns true if the rx packet type is FCoE
- * @ptype: the packet type field from rx descriptor write-back
- **/
-static inline bool i40e_rx_is_fcoe(u16 ptype)
-{
-        return (ptype >= I40E_RX_PTYPE_L2_FCOE_PAY3) &&
-               (ptype <= I40E_RX_PTYPE_L2_FCOE_VFT_FCOTHER);
-}
-
-/**
  * i40e_fcoe_sof_is_class2 - returns true if this is a FC Class 2 SOF
  * @sof: the FCoE start of frame delimiter
  **/
@@ -1371,7 +1361,7 @@ static netdev_tx_t i40e_fcoe_xmit_frame(struct sk_buff *skb,
         if (i40e_chk_linearize(skb, count)) {
                 if (__skb_linearize(skb))
                         goto out_drop;
-                count = TXD_USE_COUNT(skb->len);
+                count = i40e_txd_use_count(skb->len);
                 tx_ring->tx_stats.tx_linearize++;
         }
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 70d9605a0d9e..0b071cea305d 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -45,8 +45,8 @@ static const char i40e_driver_string[] =
 #define DRV_KERN "-k"
 
 #define DRV_VERSION_MAJOR 1
-#define DRV_VERSION_MINOR 4
-#define DRV_VERSION_BUILD 25
+#define DRV_VERSION_MINOR 5
+#define DRV_VERSION_BUILD 5
 #define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
              __stringify(DRV_VERSION_MINOR) "." \
              __stringify(DRV_VERSION_BUILD)    DRV_KERN
@@ -90,6 +90,7 @@ static const struct pci_device_id i40e_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_X722), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_X722), 0},
+        {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_I_X722), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2_A), 0},
         /* required last entry */
@@ -289,7 +290,7 @@ struct i40e_vsi *i40e_find_vsi_from_id(struct i40e_pf *pf, u16 id)
  *
  * If not already scheduled, this puts the task into the work queue
  **/
-static void i40e_service_event_schedule(struct i40e_pf *pf)
+void i40e_service_event_schedule(struct i40e_pf *pf)
 {
         if (!test_bit(__I40E_DOWN, &pf->state) &&
             !test_bit(__I40E_RESET_RECOVERY_PENDING, &pf->state) &&
@@ -2230,7 +2231,7 @@ static int i40e_change_mtu(struct net_device *netdev, int new_mtu)
         netdev->mtu = new_mtu;
         if (netif_running(netdev))
                 i40e_vsi_reinit_locked(vsi);
-
+        i40e_notify_client_of_l2_param_changes(vsi);
         return 0;
 }
 
@@ -4164,11 +4165,14 @@ static void i40e_clear_interrupt_scheme(struct i40e_pf *pf)
         int i;
 
         i40e_stop_misc_vector(pf);
-        if (pf->flags & I40E_FLAG_MSIX_ENABLED) {
+        if (pf->flags & I40E_FLAG_MSIX_ENABLED && pf->msix_entries) {
                 synchronize_irq(pf->msix_entries[0].vector);
                 free_irq(pf->msix_entries[0].vector, pf);
         }
 
+        i40e_put_lump(pf->irq_pile, pf->iwarp_base_vector,
+                      I40E_IWARP_IRQ_PILE_ID);
+
         i40e_put_lump(pf->irq_pile, 0, I40E_PILE_VALID_BIT-1);
         for (i = 0; i < pf->num_alloc_vsi; i++)
                 if (pf->vsi[i])
@@ -4212,12 +4216,17 @@ static void i40e_napi_disable_all(struct i40e_vsi *vsi)
  **/
 static void i40e_vsi_close(struct i40e_vsi *vsi)
 {
+        bool reset = false;
+
         if (!test_and_set_bit(__I40E_DOWN, &vsi->state))
                 i40e_down(vsi);
         i40e_vsi_free_irq(vsi);
         i40e_vsi_free_tx_resources(vsi);
         i40e_vsi_free_rx_resources(vsi);
         vsi->current_netdev_flags = 0;
+        if (test_bit(__I40E_RESET_RECOVERY_PENDING, &vsi->back->state))
+                reset = true;
+        i40e_notify_client_of_netdev_close(vsi, reset);
 }
 
 /**
@@ -4850,6 +4859,12 @@ static int i40e_vsi_config_tc(struct i40e_vsi *vsi, u8 enabled_tc)
         ctxt.info = vsi->info;
         i40e_vsi_setup_queue_map(vsi, &ctxt, enabled_tc, false);
 
+        if (vsi->back->flags & I40E_FLAG_IWARP_ENABLED) {
+                ctxt.info.valid_sections |=
+                                cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
+                ctxt.info.queueing_opt_flags |= I40E_AQ_VSI_QUE_OPT_TCP_ENA;
+        }
+
         /* Update the VSI after updating the VSI queue-mapping information */
         ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
         if (ret) {
@@ -4993,6 +5008,7 @@ static void i40e_dcb_reconfigure(struct i40e_pf *pf)
                         if (pf->vsi[v]->netdev)
                                 i40e_dcbnl_set_all(pf->vsi[v]);
                 }
+                i40e_notify_client_of_l2_param_changes(pf->vsi[v]);
         }
 }
 
@@ -5191,6 +5207,11 @@ static int i40e_up_complete(struct i40e_vsi *vsi)
                 }
                 i40e_fdir_filter_restore(vsi);
         }
+
+        /* On the next run of the service_task, notify any clients of the new
+         * opened netdev
+         */
+        pf->flags |= I40E_FLAG_SERVICE_CLIENT_REQUESTED;
         i40e_service_event_schedule(pf);
 
         return 0;
@@ -5379,6 +5400,8 @@ int i40e_open(struct net_device *netdev)
                 geneve_get_rx_port(netdev);
 #endif
 
+        i40e_notify_client_of_netdev_open(vsi);
+
         return 0;
 }
 
@@ -5487,11 +5510,7 @@ static void i40e_fdir_filter_exit(struct i40e_pf *pf)
  *
  * Returns 0, this is not allowed to fail
  **/
-#ifdef I40E_FCOE
 int i40e_close(struct net_device *netdev)
-#else
-static int i40e_close(struct net_device *netdev)
-#endif
 {
         struct i40e_netdev_priv *np = netdev_priv(netdev);
         struct i40e_vsi *vsi = np->vsi;
@@ -5516,8 +5535,6 @@ void i40e_do_reset(struct i40e_pf *pf, u32 reset_flags)
 
         WARN_ON(in_interrupt());
 
-        if (i40e_check_asq_alive(&pf->hw))
-                i40e_vc_notify_reset(pf);
 
         /* do the biggest reset indicated */
         if (reset_flags & BIT_ULL(__I40E_GLOBAL_RESET_REQUESTED)) {
@@ -6043,6 +6060,7 @@ static void i40e_vsi_link_event(struct i40e_vsi *vsi, bool link_up)
         case I40E_VSI_SRIOV:
         case I40E_VSI_VMDQ2:
         case I40E_VSI_CTRL:
+        case I40E_VSI_IWARP:
         case I40E_VSI_MIRROR:
         default:
                 /* there is no notification for other VSIs */
@@ -6354,7 +6372,7 @@ static void i40e_clean_adminq_subtask(struct i40e_pf *pf)
                         break;
                 default:
                         dev_info(&pf->pdev->dev,
-                                 "ARQ Error: Unknown event 0x%04x received\n",
+                                 "ARQ: Unknown event 0x%04x ignored\n",
                                  opcode);
                         break;
                 }
@@ -6719,6 +6737,8 @@ static void i40e_prep_for_reset(struct i40e_pf *pf)
         clear_bit(__I40E_RESET_INTR_RECEIVED, &pf->state);
         if (test_and_set_bit(__I40E_RESET_RECOVERY_PENDING, &pf->state))
                 return;
+        if (i40e_check_asq_alive(&pf->hw))
+                i40e_vc_notify_reset(pf);
 
         dev_dbg(&pf->pdev->dev, "Tearing down internal switch for reset\n");
 
@@ -6839,6 +6859,7 @@ static void i40e_reset_and_rebuild(struct i40e_pf *pf, bool reinit)
          */
         ret = i40e_aq_set_phy_int_mask(&pf->hw,
                                        ~(I40E_AQ_EVENT_LINK_UPDOWN |
+                                         I40E_AQ_EVENT_MEDIA_NA |
                                          I40E_AQ_EVENT_MODULE_QUAL_FAIL), NULL);
         if (ret)
                 dev_info(&pf->pdev->dev, "set phy mask fail, err %s aq_err %s\n",
@@ -7148,6 +7169,7 @@ static void i40e_service_task(struct work_struct *work)
         i40e_vc_process_vflr_event(pf);
         i40e_watchdog_subtask(pf);
         i40e_fdir_reinit_subtask(pf);
+        i40e_client_subtask(pf);
         i40e_sync_filters_subtask(pf);
         i40e_sync_udp_filters_subtask(pf);
         i40e_clean_adminq_subtask(pf);
@@ -7550,6 +7572,7 @@ static int i40e_init_msix(struct i40e_pf *pf)
         int vectors_left;
         int v_budget, i;
         int v_actual;
+        int iwarp_requested = 0;
 
         if (!(pf->flags & I40E_FLAG_MSIX_ENABLED))
                 return -ENODEV;
@@ -7563,6 +7586,7 @@ static int i40e_init_msix(struct i40e_pf *pf)
          *              is governed by number of cpus in the system.
          *      - assumes symmetric Tx/Rx pairing
          *   - The number of VMDq pairs
+         *   - The CPU count within the NUMA node if iWARP is enabled
 #ifdef I40E_FCOE
          *   - The number of FCOE qps.
 #endif
@@ -7609,6 +7633,16 @@ static int i40e_init_msix(struct i40e_pf *pf)
         }
 
 #endif
+        /* can we reserve enough for iWARP? */
+        if (pf->flags & I40E_FLAG_IWARP_ENABLED) {
+                if (!vectors_left)
+                        pf->num_iwarp_msix = 0;
+                else if (vectors_left < pf->num_iwarp_msix)
+                        pf->num_iwarp_msix = 1;
+                v_budget += pf->num_iwarp_msix;
+                vectors_left -= pf->num_iwarp_msix;
+        }
+
         /* any vectors left over go for VMDq support */
         if (pf->flags & I40E_FLAG_VMDQ_ENABLED) {
                 int vmdq_vecs_wanted = pf->num_vmdq_vsis * pf->num_vmdq_qps;
@@ -7643,6 +7677,8 @@ static int i40e_init_msix(struct i40e_pf *pf)
                  * of these features based on the policy and at the end disable
                  * the features that did not get any vectors.
                  */
+                iwarp_requested = pf->num_iwarp_msix;
+                pf->num_iwarp_msix = 0;
 #ifdef I40E_FCOE
                 pf->num_fcoe_qps = 0;
                 pf->num_fcoe_msix = 0;
@@ -7681,17 +7717,33 @@ static int i40e_init_msix(struct i40e_pf *pf)
                         pf->num_lan_msix = 1;
                         break;
                 case 3:
+                        if (pf->flags & I40E_FLAG_IWARP_ENABLED) {
+                                pf->num_lan_msix = 1;
+                                pf->num_iwarp_msix = 1;
+                        } else {
+                                pf->num_lan_msix = 2;
+                        }
 #ifdef I40E_FCOE
                         /* give one vector to FCoE */
                         if (pf->flags & I40E_FLAG_FCOE_ENABLED) {
                                 pf->num_lan_msix = 1;
                                 pf->num_fcoe_msix = 1;
                         }
-#else
-                        pf->num_lan_msix = 2;
 #endif
                         break;
                 default:
+                        if (pf->flags & I40E_FLAG_IWARP_ENABLED) {
+                                pf->num_iwarp_msix = min_t(int, (vec / 3),
+                                                 iwarp_requested);
+                                pf->num_vmdq_vsis = min_t(int, (vec / 3),
+                                                  I40E_DEFAULT_NUM_VMDQ_VSI);
+                        } else {
+                                pf->num_vmdq_vsis = min_t(int, (vec / 2),
+                                                  I40E_DEFAULT_NUM_VMDQ_VSI);
+                        }
+                        pf->num_lan_msix = min_t(int,
+                               (vec - (pf->num_iwarp_msix + pf->num_vmdq_vsis)),
+                                                              pf->num_lan_msix);
 #ifdef I40E_FCOE
                         /* give one vector to FCoE */
                         if (pf->flags & I40E_FLAG_FCOE_ENABLED) {
@@ -7699,8 +7751,6 @@ static int i40e_init_msix(struct i40e_pf *pf)
                                 vec--;
                         }
 #endif
-                        /* give the rest to the PF */
-                        pf->num_lan_msix = min_t(int, vec, pf->num_lan_qps);
                         break;
                 }
         }
@@ -7710,6 +7760,12 @@ static int i40e_init_msix(struct i40e_pf *pf)
                 dev_info(&pf->pdev->dev, "VMDq disabled, not enough MSI-X vectors\n");
                 pf->flags &= ~I40E_FLAG_VMDQ_ENABLED;
         }
+
+        if ((pf->flags & I40E_FLAG_IWARP_ENABLED) &&
+            (pf->num_iwarp_msix == 0)) {
+                dev_info(&pf->pdev->dev, "IWARP disabled, not enough MSI-X vectors\n");
+                pf->flags &= ~I40E_FLAG_IWARP_ENABLED;
+        }
 #ifdef I40E_FCOE
 
         if ((pf->flags & I40E_FLAG_FCOE_ENABLED) && (pf->num_fcoe_msix == 0)) {
@@ -7801,6 +7857,7 @@ static int i40e_init_interrupt_scheme(struct i40e_pf *pf)
                 vectors = i40e_init_msix(pf);
                 if (vectors < 0) {
                         pf->flags &= ~(I40E_FLAG_MSIX_ENABLED   |
+                                       I40E_FLAG_IWARP_ENABLED  |
 #ifdef I40E_FCOE
                                        I40E_FLAG_FCOE_ENABLED   |
 #endif
@@ -8381,7 +8438,6 @@ static int i40e_sw_init(struct i40e_pf *pf)
 
         pf->msg_enable = netif_msg_init(I40E_DEFAULT_MSG_ENABLE,
                                 (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK));
-        pf->hw.debug_mask = pf->msg_enable | I40E_DEBUG_DIAG;
         if (debug != -1 && debug != I40E_DEFAULT_MSG_ENABLE) {
                 if (I40E_DEBUG_USER & debug)
                         pf->hw.debug_mask = debug;
@@ -8392,7 +8448,6 @@ static int i40e_sw_init(struct i40e_pf *pf)
         /* Set default capability flags */
         pf->flags = I40E_FLAG_RX_CSUM_ENABLED |
                     I40E_FLAG_MSI_ENABLED     |
-                    I40E_FLAG_LINK_POLLING_ENABLED |
                     I40E_FLAG_MSIX_ENABLED;
 
         if (iommu_present(&pci_bus_type))
@@ -8474,6 +8529,12 @@ static int i40e_sw_init(struct i40e_pf *pf)
                 pf->num_vmdq_qps = i40e_default_queues_per_vmdq(pf);
         }
 
+        if (pf->hw.func_caps.iwarp) {
+                pf->flags |= I40E_FLAG_IWARP_ENABLED;
+                /* IWARP needs one extra vector for CQP just like MISC.*/
+                pf->num_iwarp_msix = (int)num_online_cpus() + 1;
+        }
+
 #ifdef I40E_FCOE
         i40e_init_pf_fcoe(pf);
 
@@ -8494,6 +8555,7 @@ static int i40e_sw_init(struct i40e_pf *pf)
                              I40E_FLAG_OUTER_UDP_CSUM_CAPABLE |
                              I40E_FLAG_WB_ON_ITR_CAPABLE |
                              I40E_FLAG_MULTIPLE_TCP_UDP_RSS_PCTYPE |
+                             I40E_FLAG_NO_PCI_LINK_CHECK |
                              I40E_FLAG_100M_SGMII_CAPABLE |
                              I40E_FLAG_USE_SET_LLDP_MIB |
                              I40E_FLAG_GENEVE_OFFLOAD_CAPABLE;
@@ -9008,6 +9070,7 @@ static const struct net_device_ops i40e_netdev_ops = {
         .ndo_get_vf_config      = i40e_ndo_get_vf_config,
         .ndo_set_vf_link_state  = i40e_ndo_set_vf_link_state,
         .ndo_set_vf_spoofchk    = i40e_ndo_set_vf_spoofchk,
+        .ndo_set_vf_trust       = i40e_ndo_set_vf_trust,
 #if IS_ENABLED(CONFIG_VXLAN)
         .ndo_add_vxlan_port     = i40e_add_vxlan_port,
         .ndo_del_vxlan_port     = i40e_del_vxlan_port,
@@ -9097,6 +9160,12 @@ static int i40e_config_netdev(struct i40e_vsi *vsi)
                                         I40E_VLAN_ANY, false, true);
                         spin_unlock_bh(&vsi->mac_filter_list_lock);
                 }
+        } else if ((pf->hw.aq.api_maj_ver > 1) ||
+                   ((pf->hw.aq.api_maj_ver == 1) &&
+                    (pf->hw.aq.api_min_ver > 4))) {
+                /* Supported in FW API version higher than 1.4 */
+                pf->flags |= I40E_FLAG_GENEVE_OFFLOAD_CAPABLE;
+                pf->auto_disable_flags = I40E_FLAG_HW_ATR_EVICT_CAPABLE;
         } else {
                 /* relate the VSI_VMDQ name to the VSI_MAIN name */
                 snprintf(netdev->name, IFNAMSIZ, "%sv%%d",
@@ -9328,6 +9397,13 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
                                 cpu_to_le16(I40E_AQ_VSI_SW_ID_FLAG_ALLOW_LB);
                 }
 
+                if (vsi->back->flags & I40E_FLAG_IWARP_ENABLED) {
+                        ctxt.info.valid_sections |=
+                                cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
+                        ctxt.info.queueing_opt_flags |=
+                                                I40E_AQ_VSI_QUE_OPT_TCP_ENA;
+                }
+
                 ctxt.info.valid_sections |= cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID);
                 ctxt.info.port_vlan_flags |= I40E_AQ_VSI_PVLAN_MODE_ALL;
                 if (pf->vf[vsi->vf_id].spoofchk) {
@@ -9351,6 +9427,10 @@ static int i40e_add_vsi(struct i40e_vsi *vsi)
                 break;
 
 #endif /* I40E_FCOE */
+        case I40E_VSI_IWARP:
+                /* send down message to iWARP */
+                break;
+
         default:
                 return -ENODEV;
         }
@@ -10467,6 +10547,7 @@ static void i40e_determine_queue_usage(struct i40e_pf *pf)
 
                 /* make sure all the fancies are disabled */
                 pf->flags &= ~(I40E_FLAG_RSS_ENABLED    |
+                               I40E_FLAG_IWARP_ENABLED  |
 #ifdef I40E_FCOE
                                I40E_FLAG_FCOE_ENABLED   |
 #endif
@@ -10484,6 +10565,7 @@ static void i40e_determine_queue_usage(struct i40e_pf *pf)
                 queues_left -= pf->num_lan_qps;
 
                 pf->flags &= ~(I40E_FLAG_RSS_ENABLED    |
+                               I40E_FLAG_IWARP_ENABLED  |
 #ifdef I40E_FCOE
                                I40E_FLAG_FCOE_ENABLED   |
 #endif
@@ -10748,6 +10830,12 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         hw->bus.func = PCI_FUNC(pdev->devfn);
         pf->instance = pfs_found;
 
+        /* set up the locks for the AQ, do this only once in probe
+         * and destroy them only once in remove
+         */
+        mutex_init(&hw->aq.asq_mutex);
+        mutex_init(&hw->aq.arq_mutex);
+
         if (debug != -1) {
                 pf->msg_enable = pf->hw.debug_mask;
                 pf->msg_enable = debug;
@@ -10793,12 +10881,6 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         /* set up a default setting for link flow control */
         pf->hw.fc.requested_mode = I40E_FC_NONE;
 
-        /* set up the locks for the AQ, do this only once in probe
-         * and destroy them only once in remove
-         */
-        mutex_init(&hw->aq.asq_mutex);
-        mutex_init(&hw->aq.arq_mutex);
-
         err = i40e_init_adminq(hw);
         if (err) {
                 if (err == I40E_ERR_FIRMWARE_API_VERSION)
@@ -10990,6 +11072,7 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
          */
         err = i40e_aq_set_phy_int_mask(&pf->hw,
                                        ~(I40E_AQ_EVENT_LINK_UPDOWN |
+                                         I40E_AQ_EVENT_MEDIA_NA |
                                          I40E_AQ_EVENT_MODULE_QUAL_FAIL), NULL);
         if (err)
                 dev_info(&pf->pdev->dev, "set phy mask fail, err %s aq_err %s\n",
@@ -11059,7 +11142,17 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
 #endif /* CONFIG_PCI_IOV */
 
-        pfs_found++;
+        if (pf->flags & I40E_FLAG_IWARP_ENABLED) {
+                pf->iwarp_base_vector = i40e_get_lump(pf, pf->irq_pile,
+                                                      pf->num_iwarp_msix,
+                                                      I40E_IWARP_IRQ_PILE_ID);
+                if (pf->iwarp_base_vector < 0) {
+                        dev_info(&pdev->dev,
+                                 "failed to get tracking for %d vectors for IWARP err=%d\n",
+                                 pf->num_iwarp_msix, pf->iwarp_base_vector);
+                        pf->flags &= ~I40E_FLAG_IWARP_ENABLED;
+                }
+        }
 
         i40e_dbg_pf_init(pf);
 
@@ -11070,6 +11163,12 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         mod_timer(&pf->service_timer,
                   round_jiffies(jiffies + pf->service_timer_period));
 
+        /* add this PF to client device list and launch a client service task */
+        err = i40e_lan_add_device(pf);
+        if (err)
+                dev_info(&pdev->dev, "Failed to add PF to client API service list: %d\n",
+                         err);
+
 #ifdef I40E_FCOE
         /* create FCoE interface */
         i40e_fcoe_vsi_setup(pf);
@@ -11175,7 +11274,6 @@ err_init_lan_hmc:
         kfree(pf->qp_pile);
 err_sw_init:
 err_adminq_setup:
-        (void)i40e_shutdown_adminq(hw);
 err_pf_reset:
         iounmap(hw->hw_addr);
 err_ioremap:
@@ -11217,8 +11315,10 @@ static void i40e_remove(struct pci_dev *pdev)
         /* no more scheduling of any task */
         set_bit(__I40E_SUSPENDED, &pf->state);
         set_bit(__I40E_DOWN, &pf->state);
-        del_timer_sync(&pf->service_timer);
-        cancel_work_sync(&pf->service_task);
+        if (pf->service_timer.data)
+                del_timer_sync(&pf->service_timer);
+        if (pf->service_task.func)
+                cancel_work_sync(&pf->service_task);
 
         if (pf->flags & I40E_FLAG_SRIOV_ENABLED) {
                 i40e_free_vfs(pf);
@@ -11245,6 +11345,13 @@ static void i40e_remove(struct pci_dev *pdev)
         if (pf->vsi[pf->lan_vsi])
                 i40e_vsi_release(pf->vsi[pf->lan_vsi]);
 
+        /* remove attached clients */
+        ret_code = i40e_lan_del_device(pf);
+        if (ret_code) {
+                dev_warn(&pdev->dev, "Failed to delete client device: %d\n",
+                         ret_code);
+        }
+
         /* shutdown and destroy the HMC */
         if (hw->hmc.hmc_obj) {
                 ret_code = i40e_shutdown_lan_hmc(hw);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_nvm.c b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
index 5730f8091e1b..f2cea3d25de3 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_nvm.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
@@ -696,7 +696,7 @@ i40e_status i40e_nvmupd_command(struct i40e_hw *hw,
         i40e_debug(hw, I40E_DEBUG_NVM, "%s state %d nvm_release_on_hold %d cmd 0x%08x config 0x%08x offset 0x%08x data_size 0x%08x\n",
                    i40e_nvm_update_state_str[upd_cmd],
                    hw->nvmupd_state,
-                   hw->aq.nvm_release_on_done,
+                   hw->nvm_release_on_done,
                    cmd->command, cmd->config, cmd->offset, cmd->data_size);
 
         if (upd_cmd == I40E_NVMUPD_INVALID) {
@@ -799,7 +799,7 @@ static i40e_status i40e_nvmupd_state_init(struct i40e_hw *hw,
                         if (status) {
                                 i40e_release_nvm(hw);
                         } else {
-                                hw->aq.nvm_release_on_done = true;
+                                hw->nvm_release_on_done = true;
                                 hw->nvmupd_state = I40E_NVMUPD_STATE_INIT_WAIT;
                         }
                 }
@@ -815,7 +815,7 @@ static i40e_status i40e_nvmupd_state_init(struct i40e_hw *hw,
                         if (status) {
                                 i40e_release_nvm(hw);
                         } else {
-                                hw->aq.nvm_release_on_done = true;
+                                hw->nvm_release_on_done = true;
                                 hw->nvmupd_state = I40E_NVMUPD_STATE_INIT_WAIT;
                         }
                 }
@@ -849,7 +849,7 @@ static i40e_status i40e_nvmupd_state_init(struct i40e_hw *hw,
                                    -EIO;
                                 i40e_release_nvm(hw);
                         } else {
-                                hw->aq.nvm_release_on_done = true;
+                                hw->nvm_release_on_done = true;
                                 hw->nvmupd_state = I40E_NVMUPD_STATE_INIT_WAIT;
                         }
                 }
@@ -953,7 +953,7 @@ retry:
                                    -EIO;
                         hw->nvmupd_state = I40E_NVMUPD_STATE_INIT;
                 } else {
-                        hw->aq.nvm_release_on_done = true;
+                        hw->nvm_release_on_done = true;
                         hw->nvmupd_state = I40E_NVMUPD_STATE_INIT_WAIT;
                 }
                 break;
@@ -980,7 +980,7 @@ retry:
                                    -EIO;
                         hw->nvmupd_state = I40E_NVMUPD_STATE_INIT;
                 } else {
-                        hw->aq.nvm_release_on_done = true;
+                        hw->nvm_release_on_done = true;
                         hw->nvmupd_state = I40E_NVMUPD_STATE_INIT_WAIT;
                 }
                 break;
@@ -1030,6 +1030,37 @@ retry:
 }
 
 /**
+ * i40e_nvmupd_check_wait_event - handle NVM update operation events
+ * @hw: pointer to the hardware structure
+ * @opcode: the event that just happened
+ **/
+void i40e_nvmupd_check_wait_event(struct i40e_hw *hw, u16 opcode)
+{
+        if (opcode == i40e_aqc_opc_nvm_erase ||
+            opcode == i40e_aqc_opc_nvm_update) {
+                i40e_debug(hw, I40E_DEBUG_NVM,
+                           "NVMUPD: clearing wait on opcode 0x%04x\n", opcode);
+                if (hw->nvm_release_on_done) {
+                        i40e_release_nvm(hw);
+                        hw->nvm_release_on_done = false;
+                }
+
+                switch (hw->nvmupd_state) {
+                case I40E_NVMUPD_STATE_INIT_WAIT:
+                        hw->nvmupd_state = I40E_NVMUPD_STATE_INIT;
+                        break;
+
+                case I40E_NVMUPD_STATE_WRITE_WAIT:
+                        hw->nvmupd_state = I40E_NVMUPD_STATE_WRITING;
+                        break;
+
+                default:
+                        break;
+                }
+        }
+}
+
+/**
  * i40e_nvmupd_validate_command - Validate given command
  * @hw: pointer to hardware structure
  * @cmd: pointer to nvm update command buffer
diff --git a/drivers/net/ethernet/intel/i40e/i40e_prototype.h b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
index d51eee5bf79a..134035f53f2c 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_prototype.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_prototype.h
@@ -308,6 +308,7 @@ i40e_status i40e_validate_nvm_checksum(struct i40e_hw *hw,
 i40e_status i40e_nvmupd_command(struct i40e_hw *hw,
                                 struct i40e_nvm_access *cmd,
                                 u8 *bytes, int *);
+void i40e_nvmupd_check_wait_event(struct i40e_hw *hw, u16 opcode);
 void i40e_set_pci_config_data(struct i40e_hw *hw, u16 link_status);
 
 extern struct i40e_rx_ptype_decoded i40e_ptype_lookup[];
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index 084d0ab316b7..29ffed27e5a9 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -636,19 +636,21 @@ u32 i40e_get_tx_pending(struct i40e_ring *ring, bool in_sw)
 
 /**
  * i40e_clean_tx_irq - Reclaim resources after transmit completes
- * @tx_ring:  tx ring to clean
- * @budget:   how many cleans we're allowed
+ * @vsi: the VSI we care about
+ * @tx_ring: Tx ring to clean
+ * @napi_budget: Used to determine if we are in netpoll
  *
  * Returns true if there's any budget left (e.g. the clean is finished)
  **/
-static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
+static bool i40e_clean_tx_irq(struct i40e_vsi *vsi,
+                              struct i40e_ring *tx_ring, int napi_budget)
 {
         u16 i = tx_ring->next_to_clean;
         struct i40e_tx_buffer *tx_buf;
         struct i40e_tx_desc *tx_head;
         struct i40e_tx_desc *tx_desc;
-        unsigned int total_packets = 0;
-        unsigned int total_bytes = 0;
+        unsigned int total_bytes = 0, total_packets = 0;
+        unsigned int budget = vsi->work_limit;
 
         tx_buf = &tx_ring->tx_bi[i];
         tx_desc = I40E_TX_DESC(tx_ring, i);
@@ -678,7 +680,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
                 total_packets += tx_buf->gso_segs;
 
                 /* free the skb */
-                dev_consume_skb_any(tx_buf->skb);
+                napi_consume_skb(tx_buf->skb, napi_budget);
 
                 /* unmap skb header data */
                 dma_unmap_single(tx_ring->dev,
@@ -749,7 +751,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
 
                 if (budget &&
                     ((j / (WB_STRIDE + 1)) == 0) && (j != 0) &&
-                    !test_bit(__I40E_DOWN, &tx_ring->vsi->state) &&
+                    !test_bit(__I40E_DOWN, &vsi->state) &&
                     (I40E_DESC_UNUSED(tx_ring) != tx_ring->count))
                         tx_ring->arm_wb = true;
         }
@@ -767,7 +769,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
                 smp_mb();
                 if (__netif_subqueue_stopped(tx_ring->netdev,
                                              tx_ring->queue_index) &&
-                   !test_bit(__I40E_DOWN, &tx_ring->vsi->state)) {
+                   !test_bit(__I40E_DOWN, &vsi->state)) {
                         netif_wake_subqueue(tx_ring->netdev,
                                             tx_ring->queue_index);
                         ++tx_ring->tx_stats.restart_queue;
@@ -1701,7 +1703,9 @@ static int i40e_clean_rx_irq_ps(struct i40e_ring *rx_ring, const int budget)
                          ? le16_to_cpu(rx_desc->wb.qword0.lo_dword.l2tag1)
                          : 0;
 #ifdef I40E_FCOE
-                if (!i40e_fcoe_handle_offload(rx_ring, rx_desc, skb)) {
+                if (unlikely(
+                    i40e_rx_is_fcoe(rx_ptype) &&
+                    !i40e_fcoe_handle_offload(rx_ring, rx_desc, skb))) {
                         dev_kfree_skb_any(skb);
                         continue;
                 }
@@ -1832,7 +1836,9 @@ static int i40e_clean_rx_irq_1buf(struct i40e_ring *rx_ring, int budget)
                          ? le16_to_cpu(rx_desc->wb.qword0.lo_dword.l2tag1)
                          : 0;
 #ifdef I40E_FCOE
-                if (!i40e_fcoe_handle_offload(rx_ring, rx_desc, skb)) {
+                if (unlikely(
+                    i40e_rx_is_fcoe(rx_ptype) &&
+                    !i40e_fcoe_handle_offload(rx_ring, rx_desc, skb))) {
                         dev_kfree_skb_any(skb);
                         continue;
                 }
@@ -1975,9 +1981,11 @@ int i40e_napi_poll(struct napi_struct *napi, int budget)
          * budget and be more aggressive about cleaning up the Tx descriptors.
          */
         i40e_for_each_ring(ring, q_vector->tx) {
-                clean_complete = clean_complete &&
-                                 i40e_clean_tx_irq(ring, vsi->work_limit);
-                arm_wb = arm_wb || ring->arm_wb;
+                if (!i40e_clean_tx_irq(vsi, ring, budget)) {
+                        clean_complete = false;
+                        continue;
+                }
+                arm_wb |= ring->arm_wb;
                 ring->arm_wb = false;
         }
 
@@ -1999,8 +2007,9 @@ int i40e_napi_poll(struct napi_struct *napi, int budget)
                         cleaned = i40e_clean_rx_irq_1buf(ring, budget_per_ring);
 
                 work_done += cleaned;
-                /* if we didn't clean as many as budgeted, we must be done */
-                clean_complete = clean_complete && (budget_per_ring > cleaned);
+                /* if we clean as many as budgeted, we must not be done */
+                if (cleaned >= budget_per_ring)
+                        clean_complete = false;
         }
 
         /* If work not completed, return budget and polling will return */
@@ -2247,15 +2256,13 @@ out:
 
 /**
  * i40e_tso - set up the tso context descriptor
- * @tx_ring:  ptr to the ring to send
  * @skb:      ptr to the skb we're sending
  * @hdr_len:  ptr to the size of the packet header
  * @cd_type_cmd_tso_mss: Quad Word 1
  *
  * Returns 0 if no TSO can happen, 1 if tso is going, or error
  **/
-static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
-                    u8 *hdr_len, u64 *cd_type_cmd_tso_mss)
+static int i40e_tso(struct sk_buff *skb, u8 *hdr_len, u64 *cd_type_cmd_tso_mss)
 {
         u64 cd_cmd, cd_tso_len, cd_mss;
         union {
@@ -2299,9 +2306,8 @@ static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
                         l4_offset = l4.hdr - skb->data;
 
                         /* remove payload length from outer checksum */
-                        paylen = (__force u16)l4.udp->check;
-                        paylen += ntohs(1) * (u16)~(skb->len - l4_offset);
-                        l4.udp->check = ~csum_fold((__force __wsum)paylen);
+                        paylen = skb->len - l4_offset;
+                        csum_replace_by_diff(&l4.udp->check, htonl(paylen));
                 }
 
                 /* reset pointers to inner headers */
@@ -2321,9 +2327,8 @@ static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
         l4_offset = l4.hdr - skb->data;
 
         /* remove payload length from inner checksum */
-        paylen = (__force u16)l4.tcp->check;
-        paylen += ntohs(1) * (u16)~(skb->len - l4_offset);
-        l4.tcp->check = ~csum_fold((__force __wsum)paylen);
+        paylen = skb->len - l4_offset;
+        csum_replace_by_diff(&l4.tcp->check, htonl(paylen));
 
         /* compute length of segmentation header */
         *hdr_len = (l4.tcp->doff * 4) + l4_offset;
@@ -2405,7 +2410,7 @@ static int i40e_tx_enable_csum(struct sk_buff *skb, u32 *tx_flags,
                 unsigned char *hdr;
         } l4;
         unsigned char *exthdr;
-        u32 offset, cmd = 0, tunnel = 0;
+        u32 offset, cmd = 0;
         __be16 frag_off;
         u8 l4_proto = 0;
 
@@ -2419,6 +2424,7 @@ static int i40e_tx_enable_csum(struct sk_buff *skb, u32 *tx_flags,
         offset = ((ip.hdr - skb->data) / 2) << I40E_TX_DESC_LENGTH_MACLEN_SHIFT;
 
         if (skb->encapsulation) {
+                u32 tunnel = 0;
                 /* define outer network header type */
                 if (*tx_flags & I40E_TX_FLAGS_IPV4) {
                         tunnel |= (*tx_flags & I40E_TX_FLAGS_TSO) ?
@@ -2717,6 +2723,8 @@ static inline void i40e_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
         tx_bi = first;
 
         for (frag = &skb_shinfo(skb)->frags[0];; frag++) {
+                unsigned int max_data = I40E_MAX_DATA_PER_TXD_ALIGNED;
+
                 if (dma_mapping_error(tx_ring->dev, dma))
                         goto dma_error;
 
@@ -2724,12 +2732,14 @@ static inline void i40e_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
                 dma_unmap_len_set(tx_bi, len, size);
                 dma_unmap_addr_set(tx_bi, dma, dma);
 
+                /* align size to end of page */
+                max_data += -dma & (I40E_MAX_READ_REQ_SIZE - 1);
                 tx_desc->buffer_addr = cpu_to_le64(dma);
 
                 while (unlikely(size > I40E_MAX_DATA_PER_TXD)) {
                         tx_desc->cmd_type_offset_bsz =
                                 build_ctob(td_cmd, td_offset,
-                                           I40E_MAX_DATA_PER_TXD, td_tag);
+                                           max_data, td_tag);
 
                         tx_desc++;
                         i++;
@@ -2740,9 +2750,10 @@ static inline void i40e_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
                                 i = 0;
                         }
 
-                        dma += I40E_MAX_DATA_PER_TXD;
-                        size -= I40E_MAX_DATA_PER_TXD;
+                        dma += max_data;
+                        size -= max_data;
 
+                        max_data = I40E_MAX_DATA_PER_TXD_ALIGNED;
                         tx_desc->buffer_addr = cpu_to_le64(dma);
                 }
 
@@ -2892,7 +2903,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         if (i40e_chk_linearize(skb, count)) {
                 if (__skb_linearize(skb))
                         goto out_drop;
-                count = TXD_USE_COUNT(skb->len);
+                count = i40e_txd_use_count(skb->len);
                 tx_ring->tx_stats.tx_linearize++;
         }
 
@@ -2923,7 +2934,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         else if (protocol == htons(ETH_P_IPV6))
                 tx_flags |= I40E_TX_FLAGS_IPV6;
 
-        tso = i40e_tso(tx_ring, skb, &hdr_len, &cd_type_cmd_tso_mss);
+        tso = i40e_tso(skb, &hdr_len, &cd_type_cmd_tso_mss);
 
         if (tso < 0)
                 goto out_drop;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.h b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
index cdd5dc00aec5..77ccdde56c0c 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
@@ -146,10 +146,39 @@ enum i40e_dyn_idx_t {
 
 #define I40E_MAX_BUFFER_TXD     8
 #define I40E_MIN_TX_LEN         17
-#define I40E_MAX_DATA_PER_TXD   8192
+
+/* The size limit for a transmit buffer in a descriptor is (16K - 1).
+ * In order to align with the read requests we will align the value to
+ * the nearest 4K which represents our maximum read request size.
+ */
+#define I40E_MAX_READ_REQ_SIZE          4096
+#define I40E_MAX_DATA_PER_TXD           (16 * 1024 - 1)
+#define I40E_MAX_DATA_PER_TXD_ALIGNED \
+        (I40E_MAX_DATA_PER_TXD & ~(I40E_MAX_READ_REQ_SIZE - 1))
+
+/* This ugly bit of math is equivalent to DIV_ROUNDUP(size, X) where X is
+ * the value I40E_MAX_DATA_PER_TXD_ALIGNED.  It is needed due to the fact
+ * that 12K is not a power of 2 and division is expensive.  It is used to
+ * approximate the number of descriptors used per linear buffer.  Note
+ * that this will overestimate in some cases as it doesn't account for the
+ * fact that we will add up to 4K - 1 in aligning the 12K buffer, however
+ * the error should not impact things much as large buffers usually mean
+ * we will use fewer descriptors then there are frags in an skb.
+ */
+static inline unsigned int i40e_txd_use_count(unsigned int size)
+{
+        const unsigned int max = I40E_MAX_DATA_PER_TXD_ALIGNED;
+        const unsigned int reciprocal = ((1ull << 32) - 1 + (max / 2)) / max;
+        unsigned int adjust = ~(u32)0;
+
+        /* if we rounded up on the reciprocal pull down the adjustment */
+        if ((max * reciprocal) > adjust)
+                adjust = ~(u32)(reciprocal - 1);
+
+        return (u32)((((u64)size * reciprocal) + adjust) >> 32);
+}
 
 /* Tx Descriptors needed, worst case */
-#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), I40E_MAX_DATA_PER_TXD)
 #define DESC_NEEDED (MAX_SKB_FRAGS + 4)
 #define I40E_MIN_DESC_PENDING   4
 
@@ -377,7 +406,7 @@ static inline int i40e_xmit_descriptor_count(struct sk_buff *skb)
         int count = 0, size = skb_headlen(skb);
 
         for (;;) {
-                count += TXD_USE_COUNT(size);
+                count += i40e_txd_use_count(size);
 
                 if (!nr_frags--)
                         break;
@@ -419,4 +448,14 @@ static inline bool i40e_chk_linearize(struct sk_buff *skb, int count)
 
         return __i40e_chk_linearize(skb);
 }
+
+/**
+ * i40e_rx_is_fcoe - returns true if the Rx packet type is FCoE
+ * @ptype: the packet type field from Rx descriptor write-back
+ **/
+static inline bool i40e_rx_is_fcoe(u16 ptype)
+{
+        return (ptype >= I40E_RX_PTYPE_L2_FCOE_PAY3) &&
+               (ptype <= I40E_RX_PTYPE_L2_FCOE_VFT_FCOTHER);
+}
 #endif /* _I40E_TXRX_H_ */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_type.h b/drivers/net/ethernet/intel/i40e/i40e_type.h
index 0a0baf71041b..793036b259e5 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_type.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_type.h
@@ -78,7 +78,7 @@ enum i40e_debug_mask {
         I40E_DEBUG_DCB                  = 0x00000400,
         I40E_DEBUG_DIAG                 = 0x00000800,
         I40E_DEBUG_FD                   = 0x00001000,
-
+        I40E_DEBUG_IWARP                = 0x00F00000,
         I40E_DEBUG_AQ_MESSAGE           = 0x01000000,
         I40E_DEBUG_AQ_DESCRIPTOR        = 0x02000000,
         I40E_DEBUG_AQ_DESC_BUFFER       = 0x04000000,
@@ -160,6 +160,7 @@ enum i40e_vsi_type {
         I40E_VSI_MIRROR = 5,
         I40E_VSI_SRIOV  = 6,
         I40E_VSI_FDIR   = 7,
+        I40E_VSI_IWARP  = 8,
         I40E_VSI_TYPE_UNKNOWN
 };
 
@@ -548,6 +549,7 @@ struct i40e_hw {
         enum i40e_nvmupd_state nvmupd_state;
         struct i40e_aq_desc nvm_wb_desc;
         struct i40e_virt_mem nvm_buff;
+        bool nvm_release_on_done;
 
         /* HMC info */
         struct i40e_hmc_info hmc; /* HMC info struct */
@@ -1532,4 +1534,37 @@ struct i40e_lldp_variables {
 
 /* RSS Hash Table Size */
 #define I40E_PFQF_CTL_0_HASHLUTSIZE_512 0x00010000
+
+/* INPUT SET MASK for RSS, flow director, and flexible payload */
+#define I40E_L3_SRC_SHIFT               47
+#define I40E_L3_SRC_MASK                (0x3ULL << I40E_L3_SRC_SHIFT)
+#define I40E_L3_V6_SRC_SHIFT            43
+#define I40E_L3_V6_SRC_MASK             (0xFFULL << I40E_L3_V6_SRC_SHIFT)
+#define I40E_L3_DST_SHIFT               35
+#define I40E_L3_DST_MASK                (0x3ULL << I40E_L3_DST_SHIFT)
+#define I40E_L3_V6_DST_SHIFT            35
+#define I40E_L3_V6_DST_MASK             (0xFFULL << I40E_L3_V6_DST_SHIFT)
+#define I40E_L4_SRC_SHIFT               34
+#define I40E_L4_SRC_MASK                (0x1ULL << I40E_L4_SRC_SHIFT)
+#define I40E_L4_DST_SHIFT               33
+#define I40E_L4_DST_MASK                (0x1ULL << I40E_L4_DST_SHIFT)
+#define I40E_VERIFY_TAG_SHIFT           31
+#define I40E_VERIFY_TAG_MASK            (0x3ULL << I40E_VERIFY_TAG_SHIFT)
+
+#define I40E_FLEX_50_SHIFT              13
+#define I40E_FLEX_50_MASK               (0x1ULL << I40E_FLEX_50_SHIFT)
+#define I40E_FLEX_51_SHIFT              12
+#define I40E_FLEX_51_MASK               (0x1ULL << I40E_FLEX_51_SHIFT)
+#define I40E_FLEX_52_SHIFT              11
+#define I40E_FLEX_52_MASK               (0x1ULL << I40E_FLEX_52_SHIFT)
+#define I40E_FLEX_53_SHIFT              10
+#define I40E_FLEX_53_MASK               (0x1ULL << I40E_FLEX_53_SHIFT)
+#define I40E_FLEX_54_SHIFT              9
+#define I40E_FLEX_54_MASK               (0x1ULL << I40E_FLEX_54_SHIFT)
+#define I40E_FLEX_55_SHIFT              8
+#define I40E_FLEX_55_MASK               (0x1ULL << I40E_FLEX_55_SHIFT)
+#define I40E_FLEX_56_SHIFT              7
+#define I40E_FLEX_56_MASK               (0x1ULL << I40E_FLEX_56_SHIFT)
+#define I40E_FLEX_57_SHIFT              6
+#define I40E_FLEX_57_MASK               (0x1ULL << I40E_FLEX_57_SHIFT)
 #endif /* _I40E_TYPE_H_ */
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl.h b/drivers/net/ethernet/intel/i40e/i40e_virtchnl.h
index 3226946bf3d4..c92a3bdee229 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl.h
@@ -80,7 +80,15 @@ enum i40e_virtchnl_ops {
         I40E_VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14,
         I40E_VIRTCHNL_OP_GET_STATS = 15,
         I40E_VIRTCHNL_OP_FCOE = 16,
-        I40E_VIRTCHNL_OP_EVENT = 17,
+        I40E_VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */
+        I40E_VIRTCHNL_OP_IWARP = 20,
+        I40E_VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP = 21,
+        I40E_VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP = 22,
+        I40E_VIRTCHNL_OP_CONFIG_RSS_KEY = 23,
+        I40E_VIRTCHNL_OP_CONFIG_RSS_LUT = 24,
+        I40E_VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25,
+        I40E_VIRTCHNL_OP_SET_RSS_HENA = 26,
+
 };
 
 /* Virtual channel message descriptor. This overlays the admin queue
@@ -154,6 +162,7 @@ struct i40e_virtchnl_vsi_resource {
 #define I40E_VIRTCHNL_VF_OFFLOAD_VLAN           0x00010000
 #define I40E_VIRTCHNL_VF_OFFLOAD_RX_POLLING     0x00020000
 #define I40E_VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2  0x00040000
+#define I40E_VIRTCHNL_VF_OFFLOAD_RSS_PF         0X00080000
 
 struct i40e_virtchnl_vf_resource {
         u16 num_vsis;
@@ -162,8 +171,8 @@ struct i40e_virtchnl_vf_resource {
         u16 max_mtu;
 
         u32 vf_offload_flags;
-        u32 max_fcoe_contexts;
-        u32 max_fcoe_filters;
+        u32 rss_key_size;
+        u32 rss_lut_size;
 
         struct i40e_virtchnl_vsi_resource vsi_res[1];
 };
@@ -322,6 +331,39 @@ struct i40e_virtchnl_promisc_info {
  * PF replies with struct i40e_eth_stats in an external buffer.
  */
 
+/* I40E_VIRTCHNL_OP_CONFIG_RSS_KEY
+ * I40E_VIRTCHNL_OP_CONFIG_RSS_LUT
+ * VF sends these messages to configure RSS. Only supported if both PF
+ * and VF drivers set the I40E_VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
+ * configuration negotiation. If this is the case, then the RSS fields in
+ * the VF resource struct are valid.
+ * Both the key and LUT are initialized to 0 by the PF, meaning that
+ * RSS is effectively disabled until set up by the VF.
+ */
+struct i40e_virtchnl_rss_key {
+        u16 vsi_id;
+        u16 key_len;
+        u8 key[1];         /* RSS hash key, packed bytes */
+};
+
+struct i40e_virtchnl_rss_lut {
+        u16 vsi_id;
+        u16 lut_entries;
+        u8 lut[1];        /* RSS lookup table*/
+};
+
+/* I40E_VIRTCHNL_OP_GET_RSS_HENA_CAPS
+ * I40E_VIRTCHNL_OP_SET_RSS_HENA
+ * VF sends these messages to get and set the hash filter enable bits for RSS.
+ * By default, the PF sets these to all possible traffic types that the
+ * hardware supports. The VF can query this value if it wants to change the
+ * traffic types that are hashed by the hardware.
+ * Traffic types are defined in the i40e_filter_pctype enum in i40e_type.h
+ */
+struct i40e_virtchnl_rss_hena {
+        u64 hena;
+};
+
 /* I40E_VIRTCHNL_OP_EVENT
  * PF sends this message to inform the VF driver of events that may affect it.
  * No direct response is expected from the VF, though it may generate other
@@ -348,6 +390,37 @@ struct i40e_virtchnl_pf_event {
         int severity;
 };
 
+/* I40E_VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP
+ * VF uses this message to request PF to map IWARP vectors to IWARP queues.
+ * The request for this originates from the VF IWARP driver through
+ * a client interface between VF LAN and VF IWARP driver.
+ * A vector could have an AEQ and CEQ attached to it although
+ * there is a single AEQ per VF IWARP instance in which case
+ * most vectors will have an INVALID_IDX for aeq and valid idx for ceq.
+ * There will never be a case where there will be multiple CEQs attached
+ * to a single vector.
+ * PF configures interrupt mapping and returns status.
+ */
+
+/* HW does not define a type value for AEQ; only for RX/TX and CEQ.
+ * In order for us to keep the interface simple, SW will define a
+ * unique type value for AEQ.
+*/
+#define I40E_QUEUE_TYPE_PE_AEQ  0x80
+#define I40E_QUEUE_INVALID_IDX  0xFFFF
+
+struct i40e_virtchnl_iwarp_qv_info {
+        u32 v_idx; /* msix_vector */
+        u16 ceq_idx;
+        u16 aeq_idx;
+        u8 itr_idx;
+};
+
+struct i40e_virtchnl_iwarp_qvlist_info {
+        u32 num_vectors;
+        struct i40e_virtchnl_iwarp_qv_info qv_info[1];
+};
+
 /* VF reset states - these are written into the RSTAT register:
  * I40E_VFGEN_RSTAT1 on the PF
  * I40E_VFGEN_RSTAT on the VF
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
index acd2693a4e97..30f8cbe6b54b 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c
@@ -63,7 +63,7 @@ static void i40e_vc_vf_broadcast(struct i40e_pf *pf,
 }
 
 /**
- * i40e_vc_notify_link_state
+ * i40e_vc_notify_vf_link_state
  * @vf: pointer to the VF structure
  *
  * send a link status message to a single VF
@@ -352,6 +352,136 @@ irq_list_done:
 }
 
 /**
+ * i40e_release_iwarp_qvlist
+ * @vf: pointer to the VF.
+ *
+ **/
+static void i40e_release_iwarp_qvlist(struct i40e_vf *vf)
+{
+        struct i40e_pf *pf = vf->pf;
+        struct i40e_virtchnl_iwarp_qvlist_info *qvlist_info = vf->qvlist_info;
+        u32 msix_vf;
+        u32 i;
+
+        if (!vf->qvlist_info)
+                return;
+
+        msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
+        for (i = 0; i < qvlist_info->num_vectors; i++) {
+                struct i40e_virtchnl_iwarp_qv_info *qv_info;
+                u32 next_q_index, next_q_type;
+                struct i40e_hw *hw = &pf->hw;
+                u32 v_idx, reg_idx, reg;
+
+                qv_info = &qvlist_info->qv_info[i];
+                if (!qv_info)
+                        continue;
+                v_idx = qv_info->v_idx;
+                if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
+                        /* Figure out the queue after CEQ and make that the
+                         * first queue.
+                         */
+                        reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
+                        reg = rd32(hw, I40E_VPINT_CEQCTL(reg_idx));
+                        next_q_index = (reg & I40E_VPINT_CEQCTL_NEXTQ_INDX_MASK)
+                                        >> I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT;
+                        next_q_type = (reg & I40E_VPINT_CEQCTL_NEXTQ_TYPE_MASK)
+                                        >> I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT;
+
+                        reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
+                        reg = (next_q_index &
+                               I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
+                               (next_q_type <<
+                               I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
+
+                        wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
+                }
+        }
+        kfree(vf->qvlist_info);
+        vf->qvlist_info = NULL;
+}
+
+/**
+ * i40e_config_iwarp_qvlist
+ * @vf: pointer to the VF info
+ * @qvlist_info: queue and vector list
+ *
+ * Return 0 on success or < 0 on error
+ **/
+static int i40e_config_iwarp_qvlist(struct i40e_vf *vf,
+                                    struct i40e_virtchnl_iwarp_qvlist_info *qvlist_info)
+{
+        struct i40e_pf *pf = vf->pf;
+        struct i40e_hw *hw = &pf->hw;
+        struct i40e_virtchnl_iwarp_qv_info *qv_info;
+        u32 v_idx, i, reg_idx, reg;
+        u32 next_q_idx, next_q_type;
+        u32 msix_vf, size;
+
+        size = sizeof(struct i40e_virtchnl_iwarp_qvlist_info) +
+               (sizeof(struct i40e_virtchnl_iwarp_qv_info) *
+                                                (qvlist_info->num_vectors - 1));
+        vf->qvlist_info = kzalloc(size, GFP_KERNEL);
+        vf->qvlist_info->num_vectors = qvlist_info->num_vectors;
+
+        msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
+        for (i = 0; i < qvlist_info->num_vectors; i++) {
+                qv_info = &qvlist_info->qv_info[i];
+                if (!qv_info)
+                        continue;
+                v_idx = qv_info->v_idx;
+
+                /* Validate vector id belongs to this vf */
+                if (!i40e_vc_isvalid_vector_id(vf, v_idx))
+                        goto err;
+
+                vf->qvlist_info->qv_info[i] = *qv_info;
+
+                reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
+                /* We might be sharing the interrupt, so get the first queue
+                 * index and type, push it down the list by adding the new
+                 * queue on top. Also link it with the new queue in CEQCTL.
+                 */
+                reg = rd32(hw, I40E_VPINT_LNKLSTN(reg_idx));
+                next_q_idx = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) >>
+                                I40E_VPINT_LNKLSTN_FIRSTQ_INDX_SHIFT);
+                next_q_type = ((reg & I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK) >>
+                                I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
+
+                if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
+                        reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
+                        reg = (I40E_VPINT_CEQCTL_CAUSE_ENA_MASK |
+                        (v_idx << I40E_VPINT_CEQCTL_MSIX_INDX_SHIFT) |
+                        (qv_info->itr_idx << I40E_VPINT_CEQCTL_ITR_INDX_SHIFT) |
+                        (next_q_type << I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT) |
+                        (next_q_idx << I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT));
+                        wr32(hw, I40E_VPINT_CEQCTL(reg_idx), reg);
+
+                        reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
+                        reg = (qv_info->ceq_idx &
+                               I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
+                               (I40E_QUEUE_TYPE_PE_CEQ <<
+                               I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
+                        wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
+                }
+
+                if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
+                        reg = (I40E_VPINT_AEQCTL_CAUSE_ENA_MASK |
+                        (v_idx << I40E_VPINT_AEQCTL_MSIX_INDX_SHIFT) |
+                        (qv_info->itr_idx << I40E_VPINT_AEQCTL_ITR_INDX_SHIFT));
+
+                        wr32(hw, I40E_VPINT_AEQCTL(vf->vf_id), reg);
+                }
+        }
+
+        return 0;
+err:
+        kfree(vf->qvlist_info);
+        vf->qvlist_info = NULL;
+        return -EINVAL;
+}
+
+/**
  * i40e_config_vsi_tx_queue
  * @vf: pointer to the VF info
  * @vsi_id: id of VSI as provided by the FW
@@ -787,9 +917,9 @@ void i40e_reset_vf(struct i40e_vf *vf, bool flr)
 {
         struct i40e_pf *pf = vf->pf;
         struct i40e_hw *hw = &pf->hw;
+        u32 reg, reg_idx, bit_idx;
         bool rsd = false;
         int i;
-        u32 reg;
 
         if (test_and_set_bit(__I40E_VF_DISABLE, &pf->state))
                 return;
@@ -807,6 +937,11 @@ void i40e_reset_vf(struct i40e_vf *vf, bool flr)
                 wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
                 i40e_flush(hw);
         }
+        /* clear the VFLR bit in GLGEN_VFLRSTAT */
+        reg_idx = (hw->func_caps.vf_base_id + vf->vf_id) / 32;
+        bit_idx = (hw->func_caps.vf_base_id + vf->vf_id) % 32;
+        wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
+        i40e_flush(hw);
 
         if (i40e_quiesce_vf_pci(vf))
                 dev_err(&pf->pdev->dev, "VF %d PCI transactions stuck\n",
@@ -850,12 +985,15 @@ complete_reset:
         /* reallocate VF resources to reset the VSI state */
         i40e_free_vf_res(vf);
         if (!i40e_alloc_vf_res(vf)) {
+                int abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
                 i40e_enable_vf_mappings(vf);
                 set_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
                 clear_bit(I40E_VF_STAT_DISABLED, &vf->vf_states);
+                i40e_notify_client_of_vf_reset(pf, abs_vf_id);
         }
         /* tell the VF the reset is done */
         wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), I40E_VFR_VFACTIVE);
+
         i40e_flush(hw);
         clear_bit(__I40E_VF_DISABLE, &pf->state);
 }
@@ -877,11 +1015,7 @@ void i40e_free_vfs(struct i40e_pf *pf)
         while (test_and_set_bit(__I40E_VF_DISABLE, &pf->state))
                 usleep_range(1000, 2000);
 
-        for (i = 0; i < pf->num_alloc_vfs; i++)
-                if (test_bit(I40E_VF_STAT_INIT, &pf->vf[i].vf_states))
-                        i40e_vsi_control_rings(pf->vsi[pf->vf[i].lan_vsi_idx],
-                                               false);
-
+        i40e_notify_client_of_vf_enable(pf, 0);
         for (i = 0; i < pf->num_alloc_vfs; i++)
                 if (test_bit(I40E_VF_STAT_INIT, &pf->vf[i].vf_states))
                         i40e_vsi_control_rings(pf->vsi[pf->vf[i].lan_vsi_idx],
@@ -953,6 +1087,7 @@ int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs)
                         goto err_iov;
                 }
         }
+        i40e_notify_client_of_vf_enable(pf, num_alloc_vfs);
         /* allocate memory */
         vfs = kcalloc(num_alloc_vfs, sizeof(struct i40e_vf), GFP_KERNEL);
         if (!vfs) {
@@ -1098,8 +1233,8 @@ static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode,
         /* single place to detect unsuccessful return values */
         if (v_retval) {
                 vf->num_invalid_msgs++;
-                dev_err(&pf->pdev->dev, "VF %d failed opcode %d, error: %d\n",
-                        vf->vf_id, v_opcode, v_retval);
+                dev_info(&pf->pdev->dev, "VF %d failed opcode %d, retval: %d\n",
+                         vf->vf_id, v_opcode, v_retval);
                 if (vf->num_invalid_msgs >
                     I40E_DEFAULT_NUM_INVALID_MSGS_ALLOWED) {
                         dev_err(&pf->pdev->dev,
@@ -1117,9 +1252,9 @@ static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode,
         aq_ret = i40e_aq_send_msg_to_vf(hw, abs_vf_id,  v_opcode, v_retval,
                                         msg, msglen, NULL);
         if (aq_ret) {
-                dev_err(&pf->pdev->dev,
-                        "Unable to send the message to VF %d aq_err %d\n",
-                        vf->vf_id, pf->hw.aq.asq_last_status);
+                dev_info(&pf->pdev->dev,
+                         "Unable to send the message to VF %d aq_err %d\n",
+                         vf->vf_id, pf->hw.aq.asq_last_status);
                 return -EIO;
         }
 
@@ -1177,8 +1312,8 @@ static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
         struct i40e_pf *pf = vf->pf;
         i40e_status aq_ret = 0;
         struct i40e_vsi *vsi;
-        int i = 0, len = 0;
         int num_vsis = 1;
+        int len = 0;
         int ret;
 
         if (!test_bit(I40E_VF_STAT_INIT, &vf->vf_states)) {
@@ -1206,6 +1341,13 @@ static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
         vsi = pf->vsi[vf->lan_vsi_idx];
         if (!vsi->info.pvid)
                 vfres->vf_offload_flags |= I40E_VIRTCHNL_VF_OFFLOAD_VLAN;
+
+        if (i40e_vf_client_capable(pf, vf->vf_id, I40E_CLIENT_IWARP) &&
+            (vf->driver_caps & I40E_VIRTCHNL_VF_OFFLOAD_IWARP)) {
+                vfres->vf_offload_flags |= I40E_VIRTCHNL_VF_OFFLOAD_IWARP;
+                set_bit(I40E_VF_STAT_IWARPENA, &vf->vf_states);
+        }
+
         if (pf->flags & I40E_FLAG_RSS_AQ_CAPABLE) {
                 if (vf->driver_caps & I40E_VIRTCHNL_VF_OFFLOAD_RSS_AQ)
                         vfres->vf_offload_flags |=
@@ -1220,8 +1362,16 @@ static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
                                 I40E_VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2;
         }
 
-        if (vf->driver_caps & I40E_VIRTCHNL_VF_OFFLOAD_RX_POLLING)
+        if (vf->driver_caps & I40E_VIRTCHNL_VF_OFFLOAD_RX_POLLING) {
+                if (pf->flags & I40E_FLAG_MFP_ENABLED) {
+                        dev_err(&pf->pdev->dev,
+                                "VF %d requested polling mode: this feature is supported only when the device is running in single function per port (SFP) mode\n",
+                                 vf->vf_id);
+                        ret = I40E_ERR_PARAM;
+                        goto err;
+                }
                 vfres->vf_offload_flags |= I40E_VIRTCHNL_VF_OFFLOAD_RX_POLLING;
+        }
 
         if (pf->flags & I40E_FLAG_WB_ON_ITR_CAPABLE) {
                 if (vf->driver_caps & I40E_VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
@@ -1233,15 +1383,14 @@ static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
         vfres->num_queue_pairs = vf->num_queue_pairs;
         vfres->max_vectors = pf->hw.func_caps.num_msix_vectors_vf;
         if (vf->lan_vsi_idx) {
-                vfres->vsi_res[i].vsi_id = vf->lan_vsi_id;
-                vfres->vsi_res[i].vsi_type = I40E_VSI_SRIOV;
-                vfres->vsi_res[i].num_queue_pairs = vsi->alloc_queue_pairs;
+                vfres->vsi_res[0].vsi_id = vf->lan_vsi_id;
+                vfres->vsi_res[0].vsi_type = I40E_VSI_SRIOV;
+                vfres->vsi_res[0].num_queue_pairs = vsi->alloc_queue_pairs;
                 /* VFs only use TC 0 */
-                vfres->vsi_res[i].qset_handle
+                vfres->vsi_res[0].qset_handle
                                           = le16_to_cpu(vsi->info.qs_handle[0]);
-                ether_addr_copy(vfres->vsi_res[i].default_mac_addr,
+                ether_addr_copy(vfres->vsi_res[0].default_mac_addr,
                                 vf->default_lan_addr.addr);
-                i++;
         }
         set_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states);
 
@@ -1827,6 +1976,72 @@ error_param:
 }
 
 /**
+ * i40e_vc_iwarp_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ * @msglen: msg length
+ *
+ * called from the VF for the iwarp msgs
+ **/
+static int i40e_vc_iwarp_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
+{
+        struct i40e_pf *pf = vf->pf;
+        int abs_vf_id = vf->vf_id + pf->hw.func_caps.vf_base_id;
+        i40e_status aq_ret = 0;
+
+        if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
+            !test_bit(I40E_VF_STAT_IWARPENA, &vf->vf_states)) {
+                aq_ret = I40E_ERR_PARAM;
+                goto error_param;
+        }
+
+        i40e_notify_client_of_vf_msg(pf->vsi[pf->lan_vsi], abs_vf_id,
+                                     msg, msglen);
+
+error_param:
+        /* send the response to the VF */
+        return i40e_vc_send_resp_to_vf(vf, I40E_VIRTCHNL_OP_IWARP,
+                                       aq_ret);
+}
+
+/**
+ * i40e_vc_iwarp_qvmap_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ * @msglen: msg length
+ * @config: config qvmap or release it
+ *
+ * called from the VF for the iwarp msgs
+ **/
+static int i40e_vc_iwarp_qvmap_msg(struct i40e_vf *vf, u8 *msg, u16 msglen,
+                                   bool config)
+{
+        struct i40e_virtchnl_iwarp_qvlist_info *qvlist_info =
+                                (struct i40e_virtchnl_iwarp_qvlist_info *)msg;
+        i40e_status aq_ret = 0;
+
+        if (!test_bit(I40E_VF_STAT_ACTIVE, &vf->vf_states) ||
+            !test_bit(I40E_VF_STAT_IWARPENA, &vf->vf_states)) {
+                aq_ret = I40E_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (config) {
+                if (i40e_config_iwarp_qvlist(vf, qvlist_info))
+                        aq_ret = I40E_ERR_PARAM;
+        } else {
+                i40e_release_iwarp_qvlist(vf);
+        }
+
+error_param:
+        /* send the response to the VF */
+        return i40e_vc_send_resp_to_vf(vf,
+                               config ? I40E_VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP :
+                               I40E_VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP,
+                               aq_ret);
+}
+
+/**
  * i40e_vc_validate_vf_msg
  * @vf: pointer to the VF info
  * @msg: pointer to the msg buffer
@@ -1921,6 +2136,32 @@ static int i40e_vc_validate_vf_msg(struct i40e_vf *vf, u32 v_opcode,
         case I40E_VIRTCHNL_OP_GET_STATS:
                 valid_len = sizeof(struct i40e_virtchnl_queue_select);
                 break;
+        case I40E_VIRTCHNL_OP_IWARP:
+                /* These messages are opaque to us and will be validated in
+                 * the RDMA client code. We just need to check for nonzero
+                 * length. The firmware will enforce max length restrictions.
+                 */
+                if (msglen)
+                        valid_len = msglen;
+                else
+                        err_msg_format = true;
+                break;
+        case I40E_VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP:
+                valid_len = 0;
+                break;
+        case I40E_VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
+                valid_len = sizeof(struct i40e_virtchnl_iwarp_qvlist_info);
+                if (msglen >= valid_len) {
+                        struct i40e_virtchnl_iwarp_qvlist_info *qv =
+                                (struct i40e_virtchnl_iwarp_qvlist_info *)msg;
+                        if (qv->num_vectors == 0) {
+                                err_msg_format = true;
+                                break;
+                        }
+                        valid_len += ((qv->num_vectors - 1) *
+                                sizeof(struct i40e_virtchnl_iwarp_qv_info));
+                }
+                break;
         /* These are always errors coming from the VF. */
         case I40E_VIRTCHNL_OP_EVENT:
         case I40E_VIRTCHNL_OP_UNKNOWN:
@@ -2010,6 +2251,15 @@ int i40e_vc_process_vf_msg(struct i40e_pf *pf, u16 vf_id, u32 v_opcode,
         case I40E_VIRTCHNL_OP_GET_STATS:
                 ret = i40e_vc_get_stats_msg(vf, msg, msglen);
                 break;
+        case I40E_VIRTCHNL_OP_IWARP:
+                ret = i40e_vc_iwarp_msg(vf, msg, msglen);
+                break;
+        case I40E_VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
+                ret = i40e_vc_iwarp_qvmap_msg(vf, msg, msglen, true);
+                break;
+        case I40E_VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP:
+                ret = i40e_vc_iwarp_qvmap_msg(vf, msg, msglen, false);
+                break;
         case I40E_VIRTCHNL_OP_UNKNOWN:
         default:
                 dev_err(&pf->pdev->dev, "Unsupported opcode %d from VF %d\n",
@@ -2055,13 +2305,9 @@ int i40e_vc_process_vflr_event(struct i40e_pf *pf)
                 /* read GLGEN_VFLRSTAT register to find out the flr VFs */
                 vf = &pf->vf[vf_id];
                 reg = rd32(hw, I40E_GLGEN_VFLRSTAT(reg_idx));
-                if (reg & BIT(bit_idx)) {
-                        /* clear the bit in GLGEN_VFLRSTAT */
-                        wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
-
-                        if (!test_bit(__I40E_DOWN, &pf->state))
-                                i40e_reset_vf(vf, true);
-                }
+                if (reg & BIT(bit_idx))
+                        /* i40e_reset_vf will clear the bit in GLGEN_VFLRSTAT */
+                        i40e_reset_vf(vf, true);
         }
 
         return 0;
@@ -2525,3 +2771,45 @@ int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable)
 out:
         return ret;
 }
+
+/**
+ * i40e_ndo_set_vf_trust
+ * @netdev: network interface device structure of the pf
+ * @vf_id: VF identifier
+ * @setting: trust setting
+ *
+ * Enable or disable VF trust setting
+ **/
+int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting)
+{
+        struct i40e_netdev_priv *np = netdev_priv(netdev);
+        struct i40e_pf *pf = np->vsi->back;
+        struct i40e_vf *vf;
+        int ret = 0;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        if (pf->flags & I40E_FLAG_MFP_ENABLED) {
+                dev_err(&pf->pdev->dev, "Trusted VF not supported in MFP mode.\n");
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+
+        if (!vf)
+                return -EINVAL;
+        if (setting == vf->trusted)
+                goto out;
+
+        vf->trusted = setting;
+        i40e_vc_notify_vf_reset(vf);
+        i40e_reset_vf(vf, false);
+        dev_info(&pf->pdev->dev, "VF %u is now %strusted\n",
+                 vf_id, setting ? "" : "un");
+out:
+        return ret;
+}
diff --git a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h
index e74642a0c42e..838cbd2299a4 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h
@@ -58,6 +58,7 @@ enum i40e_queue_ctrl {
 enum i40e_vf_states {
         I40E_VF_STAT_INIT = 0,
         I40E_VF_STAT_ACTIVE,
+        I40E_VF_STAT_IWARPENA,
         I40E_VF_STAT_FCOEENA,
         I40E_VF_STAT_DISABLED,
 };
@@ -66,6 +67,7 @@ enum i40e_vf_states {
 enum i40e_vf_capabilities {
         I40E_VIRTCHNL_VF_CAP_PRIVILEGE = 0,
         I40E_VIRTCHNL_VF_CAP_L2,
+        I40E_VIRTCHNL_VF_CAP_IWARP,
 };
 
 /* VF information structure */
@@ -86,6 +88,7 @@ struct i40e_vf {
         struct i40e_virtchnl_ether_addr default_fcoe_addr;
         u16 port_vlan_id;
         bool pf_set_mac;        /* The VMM admin set the VF MAC address */
+        bool trusted;
 
         /* VSI indices - actual VSI pointers are maintained in the PF structure
          * When assigned, these will be non-zero, because VSI 0 is always
@@ -106,6 +109,8 @@ struct i40e_vf {
         bool link_forced;
         bool link_up;           /* only valid if VF link is forced */
         bool spoofchk;
+        /* RDMA Client */
+        struct i40e_virtchnl_iwarp_qvlist_info *qvlist_info;
 };
 
 void i40e_free_vfs(struct i40e_pf *pf);
@@ -123,6 +128,7 @@ int i40e_ndo_set_vf_port_vlan(struct net_device *netdev,
                               int vf_id, u16 vlan_id, u8 qos);
 int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
                        int max_tx_rate);
+int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting);
 int i40e_ndo_get_vf_config(struct net_device *netdev,
                            int vf_id, struct ifla_vf_info *ivi);
 int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link);
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_adminq.h b/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
index a3eae5d9a2bd..1f9b3b5d946d 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_adminq.h
@@ -97,7 +97,6 @@ struct i40e_adminq_info {
         u32 fw_build;                   /* firmware build number */
         u16 api_maj_ver;                /* api major version */
         u16 api_min_ver;                /* api minor version */
-        bool nvm_release_on_done;
 
         struct mutex asq_mutex; /* Send queue lock */
         struct mutex arq_mutex; /* Receive queue lock */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_common.c b/drivers/net/ethernet/intel/i40evf/i40e_common.c
index 771ac6ad8cda..4db0c0326185 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_common.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_common.c
@@ -58,6 +58,7 @@ i40e_status i40e_set_mac_type(struct i40e_hw *hw)
                 case I40E_DEV_ID_SFP_X722:
                 case I40E_DEV_ID_1G_BASE_T_X722:
                 case I40E_DEV_ID_10G_BASE_T_X722:
+                case I40E_DEV_ID_SFP_I_X722:
                         hw->mac.type = I40E_MAC_X722;
                         break;
                 case I40E_DEV_ID_X722_VF:
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_devids.h b/drivers/net/ethernet/intel/i40evf/i40e_devids.h
index ca8b58c3d1f5..70235706915e 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_devids.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_devids.h
@@ -44,6 +44,7 @@
 #define I40E_DEV_ID_SFP_X722            0x37D0
 #define I40E_DEV_ID_1G_BASE_T_X722      0x37D1
 #define I40E_DEV_ID_10G_BASE_T_X722     0x37D2
+#define I40E_DEV_ID_SFP_I_X722          0x37D3
 #define I40E_DEV_ID_X722_VF             0x37CD
 #define I40E_DEV_ID_X722_VF_HV          0x37D9
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index ebcc25c05796..0c912a4999db 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -155,19 +155,21 @@ u32 i40evf_get_tx_pending(struct i40e_ring *ring, bool in_sw)
 
 /**
  * i40e_clean_tx_irq - Reclaim resources after transmit completes
- * @tx_ring:  tx ring to clean
- * @budget:   how many cleans we're allowed
+ * @vsi: the VSI we care about
+ * @tx_ring: Tx ring to clean
+ * @napi_budget: Used to determine if we are in netpoll
  *
  * Returns true if there's any budget left (e.g. the clean is finished)
  **/
-static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
+static bool i40e_clean_tx_irq(struct i40e_vsi *vsi,
+                              struct i40e_ring *tx_ring, int napi_budget)
 {
         u16 i = tx_ring->next_to_clean;
         struct i40e_tx_buffer *tx_buf;
         struct i40e_tx_desc *tx_head;
         struct i40e_tx_desc *tx_desc;
-        unsigned int total_packets = 0;
-        unsigned int total_bytes = 0;
+        unsigned int total_bytes = 0, total_packets = 0;
+        unsigned int budget = vsi->work_limit;
 
         tx_buf = &tx_ring->tx_bi[i];
         tx_desc = I40E_TX_DESC(tx_ring, i);
@@ -197,7 +199,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
                 total_packets += tx_buf->gso_segs;
 
                 /* free the skb */
-                dev_kfree_skb_any(tx_buf->skb);
+                napi_consume_skb(tx_buf->skb, napi_budget);
 
                 /* unmap skb header data */
                 dma_unmap_single(tx_ring->dev,
@@ -267,7 +269,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
 
                 if (budget &&
                     ((j / (WB_STRIDE + 1)) == 0) && (j > 0) &&
-                    !test_bit(__I40E_DOWN, &tx_ring->vsi->state) &&
+                    !test_bit(__I40E_DOWN, &vsi->state) &&
                     (I40E_DESC_UNUSED(tx_ring) != tx_ring->count))
                         tx_ring->arm_wb = true;
         }
@@ -285,7 +287,7 @@ static bool i40e_clean_tx_irq(struct i40e_ring *tx_ring, int budget)
                 smp_mb();
                 if (__netif_subqueue_stopped(tx_ring->netdev,
                                              tx_ring->queue_index) &&
-                   !test_bit(__I40E_DOWN, &tx_ring->vsi->state)) {
+                   !test_bit(__I40E_DOWN, &vsi->state)) {
                         netif_wake_subqueue(tx_ring->netdev,
                                             tx_ring->queue_index);
                         ++tx_ring->tx_stats.restart_queue;
@@ -1158,7 +1160,9 @@ static int i40e_clean_rx_irq_ps(struct i40e_ring *rx_ring, const int budget)
                          ? le16_to_cpu(rx_desc->wb.qword0.lo_dword.l2tag1)
                          : 0;
 #ifdef I40E_FCOE
-                if (!i40e_fcoe_handle_offload(rx_ring, rx_desc, skb)) {
+                if (unlikely(
+                    i40e_rx_is_fcoe(rx_ptype) &&
+                    !i40e_fcoe_handle_offload(rx_ring, rx_desc, skb))) {
                         dev_kfree_skb_any(skb);
                         continue;
                 }
@@ -1411,9 +1415,11 @@ int i40evf_napi_poll(struct napi_struct *napi, int budget)
          * budget and be more aggressive about cleaning up the Tx descriptors.
          */
         i40e_for_each_ring(ring, q_vector->tx) {
-                clean_complete = clean_complete &&
-                                 i40e_clean_tx_irq(ring, vsi->work_limit);
-                arm_wb = arm_wb || ring->arm_wb;
+                if (!i40e_clean_tx_irq(vsi, ring, budget)) {
+                        clean_complete = false;
+                        continue;
+                }
+                arm_wb |= ring->arm_wb;
                 ring->arm_wb = false;
         }
 
@@ -1435,8 +1441,9 @@ int i40evf_napi_poll(struct napi_struct *napi, int budget)
                         cleaned = i40e_clean_rx_irq_1buf(ring, budget_per_ring);
 
                 work_done += cleaned;
-                /* if we didn't clean as many as budgeted, we must be done */
-                clean_complete = clean_complete && (budget_per_ring > cleaned);
+                /* if we clean as many as budgeted, we must not be done */
+                if (cleaned >= budget_per_ring)
+                        clean_complete = false;
         }
 
         /* If work not completed, return budget and polling will return */
@@ -1514,15 +1521,13 @@ out:
 
 /**
  * i40e_tso - set up the tso context descriptor
- * @tx_ring:  ptr to the ring to send
  * @skb:      ptr to the skb we're sending
  * @hdr_len:  ptr to the size of the packet header
  * @cd_type_cmd_tso_mss: Quad Word 1
  *
  * Returns 0 if no TSO can happen, 1 if tso is going, or error
  **/
-static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
-                    u8 *hdr_len, u64 *cd_type_cmd_tso_mss)
+static int i40e_tso(struct sk_buff *skb, u8 *hdr_len, u64 *cd_type_cmd_tso_mss)
 {
         u64 cd_cmd, cd_tso_len, cd_mss;
         union {
@@ -1566,9 +1571,8 @@ static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
                         l4_offset = l4.hdr - skb->data;
 
                         /* remove payload length from outer checksum */
-                        paylen = (__force u16)l4.udp->check;
-                        paylen += ntohs(1) * (u16)~(skb->len - l4_offset);
-                        l4.udp->check = ~csum_fold((__force __wsum)paylen);
+                        paylen = skb->len - l4_offset;
+                        csum_replace_by_diff(&l4.udp->check, htonl(paylen));
                 }
 
                 /* reset pointers to inner headers */
@@ -1588,9 +1592,8 @@ static int i40e_tso(struct i40e_ring *tx_ring, struct sk_buff *skb,
         l4_offset = l4.hdr - skb->data;
 
         /* remove payload length from inner checksum */
-        paylen = (__force u16)l4.tcp->check;
-        paylen += ntohs(1) * (u16)~(skb->len - l4_offset);
-        l4.tcp->check = ~csum_fold((__force __wsum)paylen);
+        paylen = skb->len - l4_offset;
+        csum_replace_by_diff(&l4.tcp->check, htonl(paylen));
 
         /* compute length of segmentation header */
         *hdr_len = (l4.tcp->doff * 4) + l4_offset;
@@ -1630,7 +1633,7 @@ static int i40e_tx_enable_csum(struct sk_buff *skb, u32 *tx_flags,
                 unsigned char *hdr;
         } l4;
         unsigned char *exthdr;
-        u32 offset, cmd = 0, tunnel = 0;
+        u32 offset, cmd = 0;
         __be16 frag_off;
         u8 l4_proto = 0;
 
@@ -1644,6 +1647,7 @@ static int i40e_tx_enable_csum(struct sk_buff *skb, u32 *tx_flags,
         offset = ((ip.hdr - skb->data) / 2) << I40E_TX_DESC_LENGTH_MACLEN_SHIFT;
 
         if (skb->encapsulation) {
+                u32 tunnel = 0;
                 /* define outer network header type */
                 if (*tx_flags & I40E_TX_FLAGS_IPV4) {
                         tunnel |= (*tx_flags & I40E_TX_FLAGS_TSO) ?
@@ -1936,6 +1940,8 @@ static inline void i40evf_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
         tx_bi = first;
 
         for (frag = &skb_shinfo(skb)->frags[0];; frag++) {
+                unsigned int max_data = I40E_MAX_DATA_PER_TXD_ALIGNED;
+
                 if (dma_mapping_error(tx_ring->dev, dma))
                         goto dma_error;
 
@@ -1943,12 +1949,14 @@ static inline void i40evf_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
                 dma_unmap_len_set(tx_bi, len, size);
                 dma_unmap_addr_set(tx_bi, dma, dma);
 
+                /* align size to end of page */
+                max_data += -dma & (I40E_MAX_READ_REQ_SIZE - 1);
                 tx_desc->buffer_addr = cpu_to_le64(dma);
 
                 while (unlikely(size > I40E_MAX_DATA_PER_TXD)) {
                         tx_desc->cmd_type_offset_bsz =
                                 build_ctob(td_cmd, td_offset,
-                                           I40E_MAX_DATA_PER_TXD, td_tag);
+                                           max_data, td_tag);
 
                         tx_desc++;
                         i++;
@@ -1959,9 +1967,10 @@ static inline void i40evf_tx_map(struct i40e_ring *tx_ring, struct sk_buff *skb,
                                 i = 0;
                         }
 
-                        dma += I40E_MAX_DATA_PER_TXD;
-                        size -= I40E_MAX_DATA_PER_TXD;
+                        dma += max_data;
+                        size -= max_data;
 
+                        max_data = I40E_MAX_DATA_PER_TXD_ALIGNED;
                         tx_desc->buffer_addr = cpu_to_le64(dma);
                 }
 
@@ -2110,7 +2119,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         if (i40e_chk_linearize(skb, count)) {
                 if (__skb_linearize(skb))
                         goto out_drop;
-                count = TXD_USE_COUNT(skb->len);
+                count = i40e_txd_use_count(skb->len);
                 tx_ring->tx_stats.tx_linearize++;
         }
 
@@ -2141,7 +2150,7 @@ static netdev_tx_t i40e_xmit_frame_ring(struct sk_buff *skb,
         else if (protocol == htons(ETH_P_IPV6))
                 tx_flags |= I40E_TX_FLAGS_IPV6;
 
-        tso = i40e_tso(tx_ring, skb, &hdr_len, &cd_type_cmd_tso_mss);
+        tso = i40e_tso(skb, &hdr_len, &cd_type_cmd_tso_mss);
 
         if (tso < 0)
                 goto out_drop;
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
index c1dd8c5c9666..84c28aa64fdf 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
@@ -146,10 +146,39 @@ enum i40e_dyn_idx_t {
 
 #define I40E_MAX_BUFFER_TXD     8
 #define I40E_MIN_TX_LEN         17
-#define I40E_MAX_DATA_PER_TXD   8192
+
+/* The size limit for a transmit buffer in a descriptor is (16K - 1).
+ * In order to align with the read requests we will align the value to
+ * the nearest 4K which represents our maximum read request size.
+ */
+#define I40E_MAX_READ_REQ_SIZE          4096
+#define I40E_MAX_DATA_PER_TXD           (16 * 1024 - 1)
+#define I40E_MAX_DATA_PER_TXD_ALIGNED \
+        (I40E_MAX_DATA_PER_TXD & ~(I40E_MAX_READ_REQ_SIZE - 1))
+
+/* This ugly bit of math is equivalent to DIV_ROUNDUP(size, X) where X is
+ * the value I40E_MAX_DATA_PER_TXD_ALIGNED.  It is needed due to the fact
+ * that 12K is not a power of 2 and division is expensive.  It is used to
+ * approximate the number of descriptors used per linear buffer.  Note
+ * that this will overestimate in some cases as it doesn't account for the
+ * fact that we will add up to 4K - 1 in aligning the 12K buffer, however
+ * the error should not impact things much as large buffers usually mean
+ * we will use fewer descriptors then there are frags in an skb.
+ */
+static inline unsigned int i40e_txd_use_count(unsigned int size)
+{
+        const unsigned int max = I40E_MAX_DATA_PER_TXD_ALIGNED;
+        const unsigned int reciprocal = ((1ull << 32) - 1 + (max / 2)) / max;
+        unsigned int adjust = ~(u32)0;
+
+        /* if we rounded up on the reciprocal pull down the adjustment */
+        if ((max * reciprocal) > adjust)
+                adjust = ~(u32)(reciprocal - 1);
+
+        return (u32)((((u64)size * reciprocal) + adjust) >> 32);
+}
 
 /* Tx Descriptors needed, worst case */
-#define TXD_USE_COUNT(S) DIV_ROUND_UP((S), I40E_MAX_DATA_PER_TXD)
 #define DESC_NEEDED (MAX_SKB_FRAGS + 4)
 #define I40E_MIN_DESC_PENDING   4
 
@@ -359,7 +388,7 @@ static inline int i40e_xmit_descriptor_count(struct sk_buff *skb)
         int count = 0, size = skb_headlen(skb);
 
         for (;;) {
-                count += TXD_USE_COUNT(size);
+                count += i40e_txd_use_count(size);
 
                 if (!nr_frags--)
                         break;
@@ -401,4 +430,14 @@ static inline bool i40e_chk_linearize(struct sk_buff *skb, int count)
 
         return __i40evf_chk_linearize(skb);
 }
+
+/**
+ * i40e_rx_is_fcoe - returns true if the Rx packet type is FCoE
+ * @ptype: the packet type field from Rx descriptor write-back
+ **/
+static inline bool i40e_rx_is_fcoe(u16 ptype)
+{
+        return (ptype >= I40E_RX_PTYPE_L2_FCOE_PAY3) &&
+               (ptype <= I40E_RX_PTYPE_L2_FCOE_VFT_FCOTHER);
+}
 #endif /* _I40E_TXRX_H_ */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_type.h b/drivers/net/ethernet/intel/i40evf/i40e_type.h
index 301fe2b6dd03..4a78c18e0b7b 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_type.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_type.h
@@ -522,6 +522,7 @@ struct i40e_hw {
         enum i40e_nvmupd_state nvmupd_state;
         struct i40e_aq_desc nvm_wb_desc;
         struct i40e_virt_mem nvm_buff;
+        bool nvm_release_on_done;
 
         /* HMC info */
         struct i40e_hmc_info hmc; /* HMC info struct */
@@ -1329,4 +1330,46 @@ enum i40e_reset_type {
 
 /* RSS Hash Table Size */
 #define I40E_PFQF_CTL_0_HASHLUTSIZE_512 0x00010000
+
+/* INPUT SET MASK for RSS, flow director and flexible payload */
+#define I40E_FD_INSET_L3_SRC_SHIFT              47
+#define I40E_FD_INSET_L3_SRC_WORD_MASK          (0x3ULL << \
+                                                 I40E_FD_INSET_L3_SRC_SHIFT)
+#define I40E_FD_INSET_L3_DST_SHIFT              35
+#define I40E_FD_INSET_L3_DST_WORD_MASK          (0x3ULL << \
+                                                 I40E_FD_INSET_L3_DST_SHIFT)
+#define I40E_FD_INSET_L4_SRC_SHIFT              34
+#define I40E_FD_INSET_L4_SRC_WORD_MASK          (0x1ULL << \
+                                                 I40E_FD_INSET_L4_SRC_SHIFT)
+#define I40E_FD_INSET_L4_DST_SHIFT              33
+#define I40E_FD_INSET_L4_DST_WORD_MASK          (0x1ULL << \
+                                                 I40E_FD_INSET_L4_DST_SHIFT)
+#define I40E_FD_INSET_VERIFY_TAG_SHIFT          31
+#define I40E_FD_INSET_VERIFY_TAG_WORD_MASK      (0x3ULL << \
+                                                 I40E_FD_INSET_VERIFY_TAG_SHIFT)
+
+#define I40E_FD_INSET_FLEX_WORD50_SHIFT         17
+#define I40E_FD_INSET_FLEX_WORD50_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD50_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD51_SHIFT         16
+#define I40E_FD_INSET_FLEX_WORD51_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD51_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD52_SHIFT         15
+#define I40E_FD_INSET_FLEX_WORD52_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD52_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD53_SHIFT         14
+#define I40E_FD_INSET_FLEX_WORD53_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD53_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD54_SHIFT         13
+#define I40E_FD_INSET_FLEX_WORD54_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD54_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD55_SHIFT         12
+#define I40E_FD_INSET_FLEX_WORD55_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD55_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD56_SHIFT         11
+#define I40E_FD_INSET_FLEX_WORD56_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD56_SHIFT)
+#define I40E_FD_INSET_FLEX_WORD57_SHIFT         10
+#define I40E_FD_INSET_FLEX_WORD57_MASK          (0x1ULL << \
+                                        I40E_FD_INSET_FLEX_WORD57_SHIFT)
 #endif /* _I40E_TYPE_H_ */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_virtchnl.h b/drivers/net/ethernet/intel/i40evf/i40e_virtchnl.h
index 3b9d2037456c..f04ce6cb70dc 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_virtchnl.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_virtchnl.h
@@ -80,7 +80,12 @@ enum i40e_virtchnl_ops {
         I40E_VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE = 14,
         I40E_VIRTCHNL_OP_GET_STATS = 15,
         I40E_VIRTCHNL_OP_FCOE = 16,
-        I40E_VIRTCHNL_OP_EVENT = 17,
+        I40E_VIRTCHNL_OP_EVENT = 17, /* must ALWAYS be 17 */
+        I40E_VIRTCHNL_OP_CONFIG_RSS_KEY = 23,
+        I40E_VIRTCHNL_OP_CONFIG_RSS_LUT = 24,
+        I40E_VIRTCHNL_OP_GET_RSS_HENA_CAPS = 25,
+        I40E_VIRTCHNL_OP_SET_RSS_HENA = 26,
+
 };
 
 /* Virtual channel message descriptor. This overlays the admin queue
@@ -154,6 +159,7 @@ struct i40e_virtchnl_vsi_resource {
 #define I40E_VIRTCHNL_VF_OFFLOAD_VLAN           0x00010000
 #define I40E_VIRTCHNL_VF_OFFLOAD_RX_POLLING     0x00020000
 #define I40E_VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2  0x00040000
+#define I40E_VIRTCHNL_VF_OFFLOAD_RSS_PF         0X00080000
 
 struct i40e_virtchnl_vf_resource {
         u16 num_vsis;
@@ -162,8 +168,8 @@ struct i40e_virtchnl_vf_resource {
         u16 max_mtu;
 
         u32 vf_offload_flags;
-        u32 max_fcoe_contexts;
-        u32 max_fcoe_filters;
+        u32 rss_key_size;
+        u32 rss_lut_size;
 
         struct i40e_virtchnl_vsi_resource vsi_res[1];
 };
@@ -322,6 +328,39 @@ struct i40e_virtchnl_promisc_info {
  * PF replies with struct i40e_eth_stats in an external buffer.
  */
 
+/* I40E_VIRTCHNL_OP_CONFIG_RSS_KEY
+ * I40E_VIRTCHNL_OP_CONFIG_RSS_LUT
+ * VF sends these messages to configure RSS. Only supported if both PF
+ * and VF drivers set the I40E_VIRTCHNL_VF_OFFLOAD_RSS_PF bit during
+ * configuration negotiation. If this is the case, then the RSS fields in
+ * the VF resource struct are valid.
+ * Both the key and LUT are initialized to 0 by the PF, meaning that
+ * RSS is effectively disabled until set up by the VF.
+ */
+struct i40e_virtchnl_rss_key {
+        u16 vsi_id;
+        u16 key_len;
+        u8 key[1];         /* RSS hash key, packed bytes */
+};
+
+struct i40e_virtchnl_rss_lut {
+        u16 vsi_id;
+        u16 lut_entries;
+        u8 lut[1];        /* RSS lookup table*/
+};
+
+/* I40E_VIRTCHNL_OP_GET_RSS_HENA_CAPS
+ * I40E_VIRTCHNL_OP_SET_RSS_HENA
+ * VF sends these messages to get and set the hash filter enable bits for RSS.
+ * By default, the PF sets these to all possible traffic types that the
+ * hardware supports. The VF can query this value if it wants to change the
+ * traffic types that are hashed by the hardware.
+ * Traffic types are defined in the i40e_filter_pctype enum in i40e_type.h
+ */
+struct i40e_virtchnl_rss_hena {
+        u64 hena;
+};
+
 /* I40E_VIRTCHNL_OP_EVENT
  * PF sends this message to inform the VF driver of events that may affect it.
  * No direct response is expected from the VF, though it may generate other
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
index 4b70aae2fa84..9110319a8f00 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
@@ -37,8 +37,8 @@ static const char i40evf_driver_string[] =
 #define DRV_KERN "-k"
 
 #define DRV_VERSION_MAJOR 1
-#define DRV_VERSION_MINOR 4
-#define DRV_VERSION_BUILD 15
+#define DRV_VERSION_MINOR 5
+#define DRV_VERSION_BUILD 5
 #define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
              __stringify(DRV_VERSION_MINOR) "." \
              __stringify(DRV_VERSION_BUILD) \
@@ -1341,7 +1341,7 @@ static int i40evf_get_rss_aq(struct i40e_vsi *vsi, const u8 *seed,
         }
 
         if (lut) {
-                ret = i40evf_aq_get_rss_lut(hw, vsi->id, seed, lut, lut_size);
+                ret = i40evf_aq_get_rss_lut(hw, vsi->id, false, lut, lut_size);
                 if (ret) {
                         dev_err(&adapter->pdev->dev,
                                 "Cannot get RSS lut, err %s aq_err %s\n",
@@ -1507,7 +1507,7 @@ static int i40evf_alloc_q_vectors(struct i40evf_adapter *adapter)
         adapter->q_vectors = kcalloc(num_q_vectors, sizeof(*q_vector),
                                      GFP_KERNEL);
         if (!adapter->q_vectors)
-                goto err_out;
+                return -ENOMEM;
 
         for (q_idx = 0; q_idx < num_q_vectors; q_idx++) {
                 q_vector = &adapter->q_vectors[q_idx];
@@ -1519,15 +1519,6 @@ static int i40evf_alloc_q_vectors(struct i40evf_adapter *adapter)
         }
 
         return 0;
-
-err_out:
-        while (q_idx) {
-                q_idx--;
-                q_vector = &adapter->q_vectors[q_idx];
-                netif_napi_del(&q_vector->napi);
-        }
-        kfree(adapter->q_vectors);
-        return -ENOMEM;
 }
 
 /**
@@ -2003,6 +1994,8 @@ static void i40evf_adminq_task(struct work_struct *work)
 
         /* check for error indications */
         val = rd32(hw, hw->aq.arq.len);
+        if (val == 0xdeadbeef) /* indicates device in reset */
+                goto freedom;
         oldval = val;
         if (val & I40E_VF_ARQLEN1_ARQVFE_MASK) {
                 dev_info(&adapter->pdev->dev, "ARQ VF Error detected\n");
@@ -2259,6 +2252,28 @@ static int i40evf_change_mtu(struct net_device *netdev, int new_mtu)
         return 0;
 }
 
+#define I40EVF_VLAN_FEATURES (NETIF_F_HW_VLAN_CTAG_TX |\
+                              NETIF_F_HW_VLAN_CTAG_RX |\
+                              NETIF_F_HW_VLAN_CTAG_FILTER)
+
+/**
+ * i40evf_fix_features - fix up the netdev feature bits
+ * @netdev: our net device
+ * @features: desired feature bits
+ *
+ * Returns fixed-up features bits
+ **/
+static netdev_features_t i40evf_fix_features(struct net_device *netdev,
+                                             netdev_features_t features)
+{
+        struct i40evf_adapter *adapter = netdev_priv(netdev);
+
+        features &= ~I40EVF_VLAN_FEATURES;
+        if (adapter->vf_res->vf_offload_flags & I40E_VIRTCHNL_VF_OFFLOAD_VLAN)
+                features |= I40EVF_VLAN_FEATURES;
+        return features;
+}
+
 static const struct net_device_ops i40evf_netdev_ops = {
         .ndo_open               = i40evf_open,
         .ndo_stop               = i40evf_close,
@@ -2271,6 +2286,7 @@ static const struct net_device_ops i40evf_netdev_ops = {
         .ndo_tx_timeout         = i40evf_tx_timeout,
         .ndo_vlan_rx_add_vid    = i40evf_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = i40evf_vlan_rx_kill_vid,
+        .ndo_fix_features       = i40evf_fix_features,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = i40evf_netpoll,
 #endif
@@ -2307,29 +2323,20 @@ static int i40evf_check_reset_complete(struct i40e_hw *hw)
  **/
 int i40evf_process_config(struct i40evf_adapter *adapter)
 {
+        struct i40e_virtchnl_vf_resource *vfres = adapter->vf_res;
         struct net_device *netdev = adapter->netdev;
         int i;
 
         /* got VF config message back from PF, now we can parse it */
-        for (i = 0; i < adapter->vf_res->num_vsis; i++) {
-                if (adapter->vf_res->vsi_res[i].vsi_type == I40E_VSI_SRIOV)
-                        adapter->vsi_res = &adapter->vf_res->vsi_res[i];
+        for (i = 0; i < vfres->num_vsis; i++) {
+                if (vfres->vsi_res[i].vsi_type == I40E_VSI_SRIOV)
+                        adapter->vsi_res = &vfres->vsi_res[i];
         }
         if (!adapter->vsi_res) {
                 dev_err(&adapter->pdev->dev, "No LAN VSI found\n");
                 return -ENODEV;
         }
 
-        if (adapter->vf_res->vf_offload_flags
-            & I40E_VIRTCHNL_VF_OFFLOAD_VLAN) {
-                netdev->vlan_features = netdev->features &
-                                        ~(NETIF_F_HW_VLAN_CTAG_TX |
-                                          NETIF_F_HW_VLAN_CTAG_RX |
-                                          NETIF_F_HW_VLAN_CTAG_FILTER);
-                netdev->features |= NETIF_F_HW_VLAN_CTAG_TX |
-                                    NETIF_F_HW_VLAN_CTAG_RX |
-                                    NETIF_F_HW_VLAN_CTAG_FILTER;
-        }
         netdev->features |= NETIF_F_HIGHDMA |
                             NETIF_F_SG |
                             NETIF_F_IP_CSUM |
@@ -2338,7 +2345,7 @@ int i40evf_process_config(struct i40evf_adapter *adapter)
                             NETIF_F_TSO |
                             NETIF_F_TSO6 |
                             NETIF_F_TSO_ECN |
-                            NETIF_F_GSO_GRE            |
+                            NETIF_F_GSO_GRE |
                             NETIF_F_GSO_UDP_TUNNEL |
                             NETIF_F_RXCSUM |
                             NETIF_F_GRO;
@@ -2355,9 +2362,15 @@ int i40evf_process_config(struct i40evf_adapter *adapter)
         if (adapter->flags & I40EVF_FLAG_OUTER_UDP_CSUM_CAPABLE)
                 netdev->features |= NETIF_F_GSO_UDP_TUNNEL_CSUM;
 
+        /* always clear VLAN features because they can change at every reset */
+        netdev->features &= ~(I40EVF_VLAN_FEATURES);
         /* copy netdev features into list of user selectable features */
         netdev->hw_features |= netdev->features;
-        netdev->hw_features &= ~NETIF_F_RXCSUM;
+
+        if (vfres->vf_offload_flags & I40E_VIRTCHNL_VF_OFFLOAD_VLAN) {
+                netdev->vlan_features = netdev->features;
+                netdev->features |= I40EVF_VLAN_FEATURES;
+        }
 
         adapter->vsi.id = adapter->vsi_res->vsi_id;
 
@@ -2838,11 +2851,11 @@ static void i40evf_remove(struct pci_dev *pdev)
         adapter->state = __I40EVF_REMOVE;
         adapter->aq_required = 0;
         i40evf_request_reset(adapter);
-        msleep(20);
+        msleep(50);
         /* If the FW isn't responding, kick it once, but only once. */
         if (!i40evf_asq_done(hw)) {
                 i40evf_request_reset(adapter);
-                msleep(20);
+                msleep(50);
         }
 
         if (adapter->msix_entries) {
diff --git a/drivers/net/ethernet/intel/igb/igb_ethtool.c b/drivers/net/ethernet/intel/igb/igb_ethtool.c
index 7982243d1f9b..bb4d6cdcd0b8 100644
--- a/drivers/net/ethernet/intel/igb/igb_ethtool.c
+++ b/drivers/net/ethernet/intel/igb/igb_ethtool.c
@@ -2831,7 +2831,8 @@ static int igb_get_module_eeprom(struct net_device *netdev,
 
         /* Read EEPROM block, SFF-8079/SFF-8472, word at a time */
         for (i = 0; i < last_word - first_word + 1; i++) {
-                status = igb_read_phy_reg_i2c(hw, first_word + i, &dataword[i]);
+                status = igb_read_phy_reg_i2c(hw, (first_word + i) * 2,
+                                              &dataword[i]);
                 if (status) {
                         /* Error occurred while reading module */
                         kfree(dataword);
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 55a1405cb2a1..8e96c35307fb 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -50,6 +50,7 @@
 #include <linux/aer.h>
 #include <linux/prefetch.h>
 #include <linux/pm_runtime.h>
+#include <linux/etherdevice.h>
 #ifdef CONFIG_IGB_DCA
 #include <linux/dca.h>
 #endif
@@ -150,7 +151,7 @@ static void igb_update_dca(struct igb_q_vector *);
 static void igb_setup_dca(struct igb_adapter *);
 #endif /* CONFIG_IGB_DCA */
 static int igb_poll(struct napi_struct *, int);
-static bool igb_clean_tx_irq(struct igb_q_vector *);
+static bool igb_clean_tx_irq(struct igb_q_vector *, int);
 static int igb_clean_rx_irq(struct igb_q_vector *, int);
 static int igb_ioctl(struct net_device *, struct ifreq *, int cmd);
 static void igb_tx_timeout(struct net_device *);
@@ -2442,9 +2443,11 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 break;
         }
 
-        /* copy the MAC address out of the NVM */
-        if (hw->mac.ops.read_mac_addr(hw))
-                dev_err(&pdev->dev, "NVM Read Error\n");
+        if (eth_platform_get_mac_address(&pdev->dev, hw->mac.addr)) {
+                /* copy the MAC address out of the NVM */
+                if (hw->mac.ops.read_mac_addr(hw))
+                        dev_err(&pdev->dev, "NVM Read Error\n");
+        }
 
         memcpy(netdev->dev_addr, hw->mac.addr, netdev->addr_len);
 
@@ -6522,13 +6525,14 @@ static int igb_poll(struct napi_struct *napi, int budget)
                 igb_update_dca(q_vector);
 #endif
         if (q_vector->tx.ring)
-                clean_complete = igb_clean_tx_irq(q_vector);
+                clean_complete = igb_clean_tx_irq(q_vector, budget);
 
         if (q_vector->rx.ring) {
                 int cleaned = igb_clean_rx_irq(q_vector, budget);
 
                 work_done += cleaned;
-                clean_complete &= (cleaned < budget);
+                if (cleaned >= budget)
+                        clean_complete = false;
         }
 
         /* If all work not completed, return budget and keep polling */
@@ -6545,10 +6549,11 @@ static int igb_poll(struct napi_struct *napi, int budget)
 /**
  *  igb_clean_tx_irq - Reclaim resources after transmit completes
  *  @q_vector: pointer to q_vector containing needed info
+ *  @napi_budget: Used to determine if we are in netpoll
  *
  *  returns true if ring is completely cleaned
  **/
-static bool igb_clean_tx_irq(struct igb_q_vector *q_vector)
+static bool igb_clean_tx_irq(struct igb_q_vector *q_vector, int napi_budget)
 {
         struct igb_adapter *adapter = q_vector->adapter;
         struct igb_ring *tx_ring = q_vector->tx.ring;
@@ -6587,7 +6592,7 @@ static bool igb_clean_tx_irq(struct igb_q_vector *q_vector)
                 total_packets += tx_buffer->gso_segs;
 
                 /* free the skb */
-                dev_consume_skb_any(tx_buffer->skb);
+                napi_consume_skb(tx_buffer->skb, napi_budget);
 
                 /* unmap skb header data */
                 dma_unmap_single(tx_ring->dev,
@@ -7574,7 +7579,6 @@ static int igb_resume(struct device *dev)
 
         if (igb_init_interrupt_scheme(adapter, true)) {
                 dev_err(&pdev->dev, "Unable to allocate memory for queues\n");
-                rtnl_unlock();
                 return -ENOMEM;
         }
 
@@ -7845,11 +7849,13 @@ static void igb_rar_set_qsel(struct igb_adapter *adapter, u8 *addr, u32 index,
         struct e1000_hw *hw = &adapter->hw;
         u32 rar_low, rar_high;
 
-        /* HW expects these in little endian so we reverse the byte order
-         * from network order (big endian) to CPU endian
+        /* HW expects these to be in network order when they are plugged
+         * into the registers which are little endian.  In order to guarantee
+         * that ordering we need to do an leXX_to_cpup here in order to be
+         * ready for the byteswap that occurs with writel
          */
-        rar_low = le32_to_cpup((__be32 *)(addr));
-        rar_high = le16_to_cpup((__be16 *)(addr + 4));
+        rar_low = le32_to_cpup((__le32 *)(addr));
+        rar_high = le16_to_cpup((__le16 *)(addr + 4));
 
         /* Indicate to hardware the Address is Valid. */
         rar_high |= E1000_RAH_AV;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
index 84fa28ceb200..d10ed62993c1 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2013 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -456,7 +456,7 @@ static inline bool ixgbe_qv_lock_poll(struct ixgbe_q_vector *q_vector)
                                 IXGBE_QV_STATE_POLL);
 #ifdef BP_EXTENDED_STATS
         if (rc != IXGBE_QV_STATE_IDLE)
-                q_vector->tx.ring->stats.yields++;
+                q_vector->rx.ring->stats.yields++;
 #endif
         return rc == IXGBE_QV_STATE_IDLE;
 }
@@ -661,9 +661,7 @@ struct ixgbe_adapter {
 #define IXGBE_FLAG2_RSS_FIELD_IPV6_UDP          (u32)(1 << 9)
 #define IXGBE_FLAG2_PTP_PPS_ENABLED             (u32)(1 << 10)
 #define IXGBE_FLAG2_PHY_INTERRUPT               (u32)(1 << 11)
-#ifdef CONFIG_IXGBE_VXLAN
 #define IXGBE_FLAG2_VXLAN_REREG_NEEDED          BIT(12)
-#endif
 #define IXGBE_FLAG2_VLAN_PROMISC                BIT(13)
 
         /* Tx fast path data */
@@ -675,6 +673,9 @@ struct ixgbe_adapter {
         int num_rx_queues;
         u16 rx_itr_setting;
 
+        /* Port number used to identify VXLAN traffic */
+        __be16 vxlan_port;
+
         /* TX */
         struct ixgbe_ring *tx_ring[MAX_TX_QUEUES] ____cacheline_aligned_in_smp;
 
@@ -782,9 +783,6 @@ struct ixgbe_adapter {
         u32 timer_event_accumulator;
         u32 vferr_refcount;
         struct ixgbe_mac_addr *mac_table;
-#ifdef CONFIG_IXGBE_VXLAN
-        u16 vxlan_port;
-#endif
         struct kobject *info_kobj;
 #ifdef CONFIG_IXGBE_HWMON
         struct hwmon_buff *ixgbe_hwmon_buff;
@@ -819,6 +817,7 @@ static inline u8 ixgbe_max_rss_indices(struct ixgbe_adapter *adapter)
                 return IXGBE_MAX_RSS_INDICES;
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 return IXGBE_MAX_RSS_INDICES_X550;
         default:
                 return 0;
@@ -862,13 +861,15 @@ enum ixgbe_boards {
         board_X540,
         board_X550,
         board_X550EM_x,
+        board_x550em_a,
 };
 
-extern struct ixgbe_info ixgbe_82598_info;
-extern struct ixgbe_info ixgbe_82599_info;
-extern struct ixgbe_info ixgbe_X540_info;
-extern struct ixgbe_info ixgbe_X550_info;
-extern struct ixgbe_info ixgbe_X550EM_x_info;
+extern const struct ixgbe_info ixgbe_82598_info;
+extern const struct ixgbe_info ixgbe_82599_info;
+extern const struct ixgbe_info ixgbe_X540_info;
+extern const struct ixgbe_info ixgbe_X550_info;
+extern const struct ixgbe_info ixgbe_X550EM_x_info;
+extern const struct ixgbe_info ixgbe_x550em_a_info;
 #ifdef CONFIG_IXGBE_DCB
 extern const struct dcbnl_rtnl_ops dcbnl_ops;
 #endif
@@ -879,6 +880,8 @@ extern const char ixgbe_driver_version[];
 extern char ixgbe_default_device_descr[];
 #endif /* IXGBE_FCOE */
 
+int ixgbe_open(struct net_device *netdev);
+int ixgbe_close(struct net_device *netdev);
 void ixgbe_up(struct ixgbe_adapter *adapter);
 void ixgbe_down(struct ixgbe_adapter *adapter);
 void ixgbe_reinit_locked(struct ixgbe_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c
index d8a9fb8a59e2..6ecd598c6ef5 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -1160,7 +1160,7 @@ static void ixgbe_set_rxpba_82598(struct ixgbe_hw *hw, int num_pb,
                 IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), IXGBE_TXPBSIZE_40KB);
 }
 
-static struct ixgbe_mac_operations mac_ops_82598 = {
+static const struct ixgbe_mac_operations mac_ops_82598 = {
         .init_hw                = &ixgbe_init_hw_generic,
         .reset_hw               = &ixgbe_reset_hw_82598,
         .start_hw               = &ixgbe_start_hw_82598,
@@ -1192,9 +1192,11 @@ static struct ixgbe_mac_operations mac_ops_82598 = {
         .clear_vfta             = &ixgbe_clear_vfta_82598,
         .set_vfta               = &ixgbe_set_vfta_82598,
         .fc_enable              = &ixgbe_fc_enable_82598,
+        .setup_fc               = ixgbe_setup_fc_generic,
         .set_fw_drv_ver         = NULL,
         .acquire_swfw_sync      = &ixgbe_acquire_swfw_sync,
         .release_swfw_sync      = &ixgbe_release_swfw_sync,
+        .init_swfw_sync         = NULL,
         .get_thermal_sensor_data = NULL,
         .init_thermal_sensor_thresh = NULL,
         .prot_autoc_read        = &prot_autoc_read_generic,
@@ -1203,7 +1205,7 @@ static struct ixgbe_mac_operations mac_ops_82598 = {
         .disable_rx             = &ixgbe_disable_rx_generic,
 };
 
-static struct ixgbe_eeprom_operations eeprom_ops_82598 = {
+static const struct ixgbe_eeprom_operations eeprom_ops_82598 = {
         .init_params            = &ixgbe_init_eeprom_params_generic,
         .read                   = &ixgbe_read_eerd_generic,
         .write                  = &ixgbe_write_eeprom_generic,
@@ -1214,7 +1216,7 @@ static struct ixgbe_eeprom_operations eeprom_ops_82598 = {
         .update_checksum        = &ixgbe_update_eeprom_checksum_generic,
 };
 
-static struct ixgbe_phy_operations phy_ops_82598 = {
+static const struct ixgbe_phy_operations phy_ops_82598 = {
         .identify               = &ixgbe_identify_phy_generic,
         .identify_sfp           = &ixgbe_identify_module_generic,
         .init                   = &ixgbe_init_phy_ops_82598,
@@ -1230,7 +1232,7 @@ static struct ixgbe_phy_operations phy_ops_82598 = {
         .check_overtemp         = &ixgbe_tn_check_overtemp,
 };
 
-struct ixgbe_info ixgbe_82598_info = {
+const struct ixgbe_info ixgbe_82598_info = {
         .mac                    = ixgbe_mac_82598EB,
         .get_invariants         = &ixgbe_get_invariants_82598,
         .mac_ops                = &mac_ops_82598,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
index fa8d4f40ac2a..01519787324a 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -1633,6 +1633,7 @@ s32 ixgbe_fdir_set_input_mask_82599(struct ixgbe_hw *hw,
         switch (hw->mac.type) {
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 IXGBE_WRITE_REG(hw, IXGBE_FDIRSCTPM, ~fdirtcpm);
                 break;
         default:
@@ -2181,7 +2182,7 @@ release_i2c_access:
         return status;
 }
 
-static struct ixgbe_mac_operations mac_ops_82599 = {
+static const struct ixgbe_mac_operations mac_ops_82599 = {
         .init_hw                = &ixgbe_init_hw_generic,
         .reset_hw               = &ixgbe_reset_hw_82599,
         .start_hw               = &ixgbe_start_hw_82599,
@@ -2220,6 +2221,7 @@ static struct ixgbe_mac_operations mac_ops_82599 = {
         .clear_vfta             = &ixgbe_clear_vfta_generic,
         .set_vfta               = &ixgbe_set_vfta_generic,
         .fc_enable              = &ixgbe_fc_enable_generic,
+        .setup_fc               = ixgbe_setup_fc_generic,
         .set_fw_drv_ver         = &ixgbe_set_fw_drv_ver_generic,
         .init_uta_tables        = &ixgbe_init_uta_tables_generic,
         .setup_sfp              = &ixgbe_setup_sfp_modules_82599,
@@ -2227,6 +2229,7 @@ static struct ixgbe_mac_operations mac_ops_82599 = {
         .set_vlan_anti_spoofing = &ixgbe_set_vlan_anti_spoofing,
         .acquire_swfw_sync      = &ixgbe_acquire_swfw_sync,
         .release_swfw_sync      = &ixgbe_release_swfw_sync,
+        .init_swfw_sync         = NULL,
         .get_thermal_sensor_data = &ixgbe_get_thermal_sensor_data_generic,
         .init_thermal_sensor_thresh = &ixgbe_init_thermal_sensor_thresh_generic,
         .prot_autoc_read        = &prot_autoc_read_82599,
@@ -2235,7 +2238,7 @@ static struct ixgbe_mac_operations mac_ops_82599 = {
         .disable_rx             = &ixgbe_disable_rx_generic,
 };
 
-static struct ixgbe_eeprom_operations eeprom_ops_82599 = {
+static const struct ixgbe_eeprom_operations eeprom_ops_82599 = {
         .init_params            = &ixgbe_init_eeprom_params_generic,
         .read                   = &ixgbe_read_eeprom_82599,
         .read_buffer            = &ixgbe_read_eeprom_buffer_82599,
@@ -2246,7 +2249,7 @@ static struct ixgbe_eeprom_operations eeprom_ops_82599 = {
         .update_checksum        = &ixgbe_update_eeprom_checksum_generic,
 };
 
-static struct ixgbe_phy_operations phy_ops_82599 = {
+static const struct ixgbe_phy_operations phy_ops_82599 = {
         .identify               = &ixgbe_identify_phy_82599,
         .identify_sfp           = &ixgbe_identify_module_generic,
         .init                   = &ixgbe_init_phy_ops_82599,
@@ -2263,7 +2266,7 @@ static struct ixgbe_phy_operations phy_ops_82599 = {
         .check_overtemp         = &ixgbe_tn_check_overtemp,
 };
 
-struct ixgbe_info ixgbe_82599_info = {
+const struct ixgbe_info ixgbe_82599_info = {
         .mac                    = ixgbe_mac_82599EB,
         .get_invariants         = &ixgbe_get_invariants_82599,
         .mac_ops                = &mac_ops_82599,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
index 64045053e874..737443a015d5 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -97,6 +97,7 @@ bool ixgbe_device_supports_autoneg_fc(struct ixgbe_hw *hw)
                 case IXGBE_DEV_ID_X540T:
                 case IXGBE_DEV_ID_X540T1:
                 case IXGBE_DEV_ID_X550T:
+                case IXGBE_DEV_ID_X550T1:
                 case IXGBE_DEV_ID_X550EM_X_10G_T:
                         supported = true;
                         break;
@@ -111,12 +112,12 @@ bool ixgbe_device_supports_autoneg_fc(struct ixgbe_hw *hw)
 }
 
 /**
- *  ixgbe_setup_fc - Set up flow control
+ *  ixgbe_setup_fc_generic - Set up flow control
  *  @hw: pointer to hardware structure
  *
  *  Called at init time to set up flow control.
  **/
-static s32 ixgbe_setup_fc(struct ixgbe_hw *hw)
+s32 ixgbe_setup_fc_generic(struct ixgbe_hw *hw)
 {
         s32 ret_val = 0;
         u32 reg = 0, reg_bp = 0;
@@ -296,7 +297,7 @@ s32 ixgbe_start_hw_generic(struct ixgbe_hw *hw)
         IXGBE_WRITE_FLUSH(hw);
 
         /* Setup flow control */
-        ret_val = ixgbe_setup_fc(hw);
+        ret_val = hw->mac.ops.setup_fc(hw);
         if (ret_val)
                 return ret_val;
 
@@ -681,6 +682,7 @@ s32 ixgbe_get_bus_info_generic(struct ixgbe_hw *hw)
 void ixgbe_set_lan_id_multi_port_pcie(struct ixgbe_hw *hw)
 {
         struct ixgbe_bus_info *bus = &hw->bus;
+        u16 ee_ctrl_4;
         u32 reg;
 
         reg = IXGBE_READ_REG(hw, IXGBE_STATUS);
@@ -691,6 +693,13 @@ void ixgbe_set_lan_id_multi_port_pcie(struct ixgbe_hw *hw)
         reg = IXGBE_READ_REG(hw, IXGBE_FACTPS(hw));
         if (reg & IXGBE_FACTPS_LFS)
                 bus->func ^= 0x1;
+
+        /* Get MAC instance from EEPROM for configuring CS4227 */
+        if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP) {
+                hw->eeprom.ops.read(hw, IXGBE_EEPROM_CTRL_4, &ee_ctrl_4);
+                bus->instance_id = (ee_ctrl_4 & IXGBE_EE_CTRL_4_INST_ID) >>
+                                   IXGBE_EE_CTRL_4_INST_ID_SHIFT;
+        }
 }
 
 /**
@@ -2854,6 +2863,7 @@ u16 ixgbe_get_pcie_msix_count_generic(struct ixgbe_hw *hw)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 pcie_offset = IXGBE_PCIE_MSIX_82599_CAPS;
                 max_msix_count = IXGBE_MAX_MSIX_VECTORS_82599;
                 break;
@@ -3483,18 +3493,27 @@ static u8 ixgbe_calculate_checksum(u8 *buffer, u32 length)
  *  Communicates with the manageability block.  On success return 0
  *  else return IXGBE_ERR_HOST_INTERFACE_COMMAND.
  **/
-s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
+s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, void *buffer,
                                  u32 length, u32 timeout,
                                  bool return_data)
 {
-        u32 hicr, i, bi, fwsts;
         u32 hdr_size = sizeof(struct ixgbe_hic_hdr);
+        u32 hicr, i, bi, fwsts;
         u16 buf_len, dword_len;
+        union {
+                struct ixgbe_hic_hdr hdr;
+                u32 u32arr[1];
+        } *bp = buffer;
+        s32 status;
 
-        if (length == 0 || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) {
+        if (!length || length > IXGBE_HI_MAX_BLOCK_BYTE_LENGTH) {
                 hw_dbg(hw, "Buffer length failure buffersize-%d.\n", length);
                 return IXGBE_ERR_HOST_INTERFACE_COMMAND;
         }
+        /* Take management host interface semaphore */
+        status = hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM);
+        if (status)
+                return status;
 
         /* Set bit 9 of FWSTS clearing FW reset indication */
         fwsts = IXGBE_READ_REG(hw, IXGBE_FWSTS);
@@ -3502,26 +3521,27 @@ s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
 
         /* Check that the host interface is enabled. */
         hicr = IXGBE_READ_REG(hw, IXGBE_HICR);
-        if ((hicr & IXGBE_HICR_EN) == 0) {
+        if (!(hicr & IXGBE_HICR_EN)) {
                 hw_dbg(hw, "IXGBE_HOST_EN bit disabled.\n");
-                return IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                status = IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                goto rel_out;
         }
 
         /* Calculate length in DWORDs. We must be DWORD aligned */
-        if ((length % (sizeof(u32))) != 0) {
+        if (length % sizeof(u32)) {
                 hw_dbg(hw, "Buffer length failure, not aligned to dword");
-                return IXGBE_ERR_INVALID_ARGUMENT;
+                status = IXGBE_ERR_INVALID_ARGUMENT;
+                goto rel_out;
         }
 
         dword_len = length >> 2;
 
-        /*
-         * The device driver writes the relevant command block
+        /* The device driver writes the relevant command block
          * into the ram area.
          */
         for (i = 0; i < dword_len; i++)
                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_FLEX_MNG,
-                                      i, cpu_to_le32(buffer[i]));
+                                      i, cpu_to_le32(bp->u32arr[i]));
 
         /* Setting this bit tells the ARC that a new command is pending. */
         IXGBE_WRITE_REG(hw, IXGBE_HICR, hicr | IXGBE_HICR_C);
@@ -3534,44 +3554,49 @@ s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
         }
 
         /* Check command successful completion. */
-        if ((timeout != 0 && i == timeout) ||
-            (!(IXGBE_READ_REG(hw, IXGBE_HICR) & IXGBE_HICR_SV))) {
+        if ((timeout && i == timeout) ||
+            !(IXGBE_READ_REG(hw, IXGBE_HICR) & IXGBE_HICR_SV)) {
                 hw_dbg(hw, "Command has failed with no status valid.\n");
-                return IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                status = IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                goto rel_out;
         }
 
         if (!return_data)
-                return 0;
+                goto rel_out;
 
         /* Calculate length in DWORDs */
         dword_len = hdr_size >> 2;
 
         /* first pull in the header so we know the buffer length */
         for (bi = 0; bi < dword_len; bi++) {
-                buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
-                le32_to_cpus(&buffer[bi]);
+                bp->u32arr[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
+                le32_to_cpus(&bp->u32arr[bi]);
         }
 
         /* If there is any thing in data position pull it in */
-        buf_len = ((struct ixgbe_hic_hdr *)buffer)->buf_len;
-        if (buf_len == 0)
-                return 0;
+        buf_len = bp->hdr.buf_len;
+        if (!buf_len)
+                goto rel_out;
 
-        if (length < (buf_len + hdr_size)) {
+        if (length < round_up(buf_len, 4) + hdr_size) {
                 hw_dbg(hw, "Buffer not large enough for reply message.\n");
-                return IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                status = IXGBE_ERR_HOST_INTERFACE_COMMAND;
+                goto rel_out;
         }
 
         /* Calculate length in DWORDs, add 3 for odd lengths */
         dword_len = (buf_len + 3) >> 2;
 
-        /* Pull in the rest of the buffer (bi is where we left off)*/
+        /* Pull in the rest of the buffer (bi is where we left off) */
         for (; bi <= dword_len; bi++) {
-                buffer[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
-                le32_to_cpus(&buffer[bi]);
+                bp->u32arr[bi] = IXGBE_READ_REG_ARRAY(hw, IXGBE_FLEX_MNG, bi);
+                le32_to_cpus(&bp->u32arr[bi]);
         }
 
-        return 0;
+rel_out:
+        hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM);
+
+        return status;
 }
 
 /**
@@ -3594,13 +3619,10 @@ s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
         int i;
         s32 ret_val;
 
-        if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM))
-                return IXGBE_ERR_SWFW_SYNC;
-
         fw_cmd.hdr.cmd = FW_CEM_CMD_DRIVER_INFO;
         fw_cmd.hdr.buf_len = FW_CEM_CMD_DRIVER_INFO_LEN;
         fw_cmd.hdr.cmd_or_resp.cmd_resv = FW_CEM_CMD_RESERVED;
-        fw_cmd.port_num = (u8)hw->bus.func;
+        fw_cmd.port_num = hw->bus.func;
         fw_cmd.ver_maj = maj;
         fw_cmd.ver_min = min;
         fw_cmd.ver_build = build;
@@ -3612,7 +3634,7 @@ s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
         fw_cmd.pad2 = 0;
 
         for (i = 0; i <= FW_CEM_MAX_RETRIES; i++) {
-                ret_val = ixgbe_host_interface_command(hw, (u32 *)&fw_cmd,
+                ret_val = ixgbe_host_interface_command(hw, &fw_cmd,
                                                        sizeof(fw_cmd),
                                                        IXGBE_HI_COMMAND_TIMEOUT,
                                                        true);
@@ -3628,7 +3650,6 @@ s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
                 break;
         }
 
-        hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_SW_MNG_SM);
         return ret_val;
 }
 
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
index 2b9563137fd8..6f8e6a56e242 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_common.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -81,6 +81,7 @@ s32 ixgbe_disable_rx_buff_generic(struct ixgbe_hw *hw);
 s32 ixgbe_enable_rx_buff_generic(struct ixgbe_hw *hw);
 s32 ixgbe_enable_rx_dma_generic(struct ixgbe_hw *hw, u32 regval);
 s32 ixgbe_fc_enable_generic(struct ixgbe_hw *hw);
+s32 ixgbe_setup_fc_generic(struct ixgbe_hw *);
 bool ixgbe_device_supports_autoneg_fc(struct ixgbe_hw *hw);
 void ixgbe_fc_autoneg(struct ixgbe_hw *hw);
 
@@ -110,8 +111,8 @@ void ixgbe_set_vlan_anti_spoofing(struct ixgbe_hw *hw, bool enable, int vf);
 s32 ixgbe_get_device_caps_generic(struct ixgbe_hw *hw, u16 *device_caps);
 s32 ixgbe_set_fw_drv_ver_generic(struct ixgbe_hw *hw, u8 maj, u8 min,
                                  u8 build, u8 ver);
-s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, u32 *buffer,
-                                 u32 length, u32 timeout, bool return_data);
+s32 ixgbe_host_interface_command(struct ixgbe_hw *hw, void *, u32 length,
+                                 u32 timeout, bool return_data);
 void ixgbe_clear_tx_pending(struct ixgbe_hw *hw);
 bool ixgbe_mng_present(struct ixgbe_hw *hw);
 bool ixgbe_mng_enabled(struct ixgbe_hw *hw);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
index 02c7333a9c83..f8fb2acc2632 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -293,6 +293,7 @@ s32 ixgbe_dcb_hw_config(struct ixgbe_hw *hw,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 return ixgbe_dcb_hw_config_82599(hw, pfc_en, refill, max,
                                                  bwgid, ptype, prio_tc);
         default:
@@ -311,6 +312,7 @@ s32 ixgbe_dcb_hw_pfc_config(struct ixgbe_hw *hw, u8 pfc_en, u8 *prio_tc)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 return ixgbe_dcb_config_pfc_82599(hw, pfc_en, prio_tc);
         default:
                 break;
@@ -368,6 +370,7 @@ s32 ixgbe_dcb_hw_ets_config(struct ixgbe_hw *hw,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max,
                                                   bwg_id, prio_type, prio_tc);
                 ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max,
@@ -398,6 +401,7 @@ void ixgbe_dcb_read_rtrup2tc(struct ixgbe_hw *hw, u8 *map)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 ixgbe_dcb_read_rtrup2tc_82599(hw, map);
                 break;
         default:
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
index 726e0eeee63b..9f76be1431b1 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -547,6 +547,7 @@ static void ixgbe_get_regs(struct net_device *netdev,
                 case ixgbe_mac_X540:
                 case ixgbe_mac_X550:
                 case ixgbe_mac_X550EM_x:
+                case ixgbe_mac_x550em_a:
                         regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_FCRTL_82599(i));
                         regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_FCRTH_82599(i));
                         break;
@@ -660,6 +661,7 @@ static void ixgbe_get_regs(struct net_device *netdev,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 regs_buff[830] = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
                 regs_buff[832] = IXGBE_READ_REG(hw, IXGBE_RTRPCS);
                 for (i = 0; i < 8; i++)
@@ -1443,6 +1445,7 @@ static int ixgbe_reg_test(struct ixgbe_adapter *adapter, u64 *data)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 toggle = 0x7FFFF30F;
                 test = reg_test_82599;
                 break;
@@ -1681,6 +1684,7 @@ static void ixgbe_free_desc_rings(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 reg_ctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
                 reg_ctl &= ~IXGBE_DMATXCTL_TE;
                 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, reg_ctl);
@@ -1720,6 +1724,7 @@ static int ixgbe_setup_desc_rings(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 reg_data = IXGBE_READ_REG(&adapter->hw, IXGBE_DMATXCTL);
                 reg_data |= IXGBE_DMATXCTL_TE;
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_DMATXCTL, reg_data);
@@ -1780,6 +1785,7 @@ static int ixgbe_setup_loopback_test(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 reg_data = IXGBE_READ_REG(hw, IXGBE_MACC);
                 reg_data |= IXGBE_MACC_FLU;
                 IXGBE_WRITE_REG(hw, IXGBE_MACC, reg_data);
@@ -2053,7 +2059,7 @@ static void ixgbe_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        ixgbe_close(netdev);
                 else
                         ixgbe_reset(adapter);
 
@@ -2091,7 +2097,7 @@ skip_loopback:
                 /* clear testing bit and return adapter to previous state */
                 clear_bit(__IXGBE_TESTING, &adapter->state);
                 if (if_running)
-                        dev_open(netdev);
+                        ixgbe_open(netdev);
                 else if (hw->mac.ops.disable_tx_laser)
                         hw->mac.ops.disable_tx_laser(hw);
         } else {
@@ -2991,6 +2997,7 @@ static int ixgbe_get_ts_info(struct net_device *dev,
         switch (adapter->hw.mac.type) {
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
         case ixgbe_mac_X540:
         case ixgbe_mac_82599EB:
                 info->so_timestamping =
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
index e771e764daa3..bcdc88444ceb 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2013 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -128,6 +128,7 @@ static void ixgbe_get_first_reg_idx(struct ixgbe_adapter *adapter, u8 tc,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 if (num_tcs > 4) {
                         /*
                          * TCs    : TC0/1 TC2/3 TC4-7
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 569cb0757c93..2976df77bf14 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -54,15 +54,6 @@
 #include <net/pkt_cls.h>
 #include <net/tc_act/tc_gact.h>
 
-#ifdef CONFIG_OF
-#include <linux/of_net.h>
-#endif
-
-#ifdef CONFIG_SPARC
-#include <asm/idprom.h>
-#include <asm/prom.h>
-#endif
-
 #include "ixgbe.h"
 #include "ixgbe_common.h"
 #include "ixgbe_dcb_82599.h"
@@ -79,10 +70,10 @@ char ixgbe_default_device_descr[] =
 static char ixgbe_default_device_descr[] =
                               "Intel(R) 10 Gigabit Network Connection";
 #endif
-#define DRV_VERSION "4.2.1-k"
+#define DRV_VERSION "4.4.0-k"
 const char ixgbe_driver_version[] = DRV_VERSION;
 static const char ixgbe_copyright[] =
-                                "Copyright (c) 1999-2015 Intel Corporation.";
+                                "Copyright (c) 1999-2016 Intel Corporation.";
 
 static const char ixgbe_overheat_msg[] = "Network adapter has been stopped because it has over heated. Restart the computer. If the problem persists, power off the system and replace the adapter";
 
@@ -92,6 +83,7 @@ static const struct ixgbe_info *ixgbe_info_tbl[] = {
         [board_X540]            = &ixgbe_X540_info,
         [board_X550]            = &ixgbe_X550_info,
         [board_X550EM_x]        = &ixgbe_X550EM_x_info,
+        [board_x550em_a]        = &ixgbe_x550em_a_info,
 };
 
 /* ixgbe_pci_tbl - PCI Device ID Table
@@ -134,10 +126,17 @@ static const struct pci_device_id ixgbe_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_SF_QP), board_82599 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540T1), board_X540 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T), board_X550},
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T1), board_X550},
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KX4), board_X550EM_x},
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KR), board_X550EM_x},
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_10G_T), board_X550EM_x},
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_SFP), board_X550EM_x},
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR), board_x550em_a },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR_L), board_x550em_a },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP_N), board_x550em_a },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII), board_x550em_a },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII_L), board_x550em_a },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP), board_x550em_a },
         /* required last entry */
         {0, }
 };
@@ -869,6 +868,7 @@ static void ixgbe_set_ivar(struct ixgbe_adapter *adapter, s8 direction,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 if (direction == -1) {
                         /* other causes */
                         msix_vector |= IXGBE_IVAR_ALLOC_VAL;
@@ -907,6 +907,7 @@ static inline void ixgbe_irq_rearm_queues(struct ixgbe_adapter *adapter,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 mask = (qmask & 0xFFFFFFFF);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask);
                 mask = (qmask >> 32);
@@ -1087,9 +1088,40 @@ static void ixgbe_tx_timeout_reset(struct ixgbe_adapter *adapter)
 }
 
 /**
+ * ixgbe_tx_maxrate - callback to set the maximum per-queue bitrate
+ **/
+static int ixgbe_tx_maxrate(struct net_device *netdev,
+                            int queue_index, u32 maxrate)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+        u32 bcnrc_val = ixgbe_link_mbps(adapter);
+
+        if (!maxrate)
+                return 0;
+
+        /* Calculate the rate factor values to set */
+        bcnrc_val <<= IXGBE_RTTBCNRC_RF_INT_SHIFT;
+        bcnrc_val /= maxrate;
+
+        /* clear everything but the rate factor */
+        bcnrc_val &= IXGBE_RTTBCNRC_RF_INT_MASK |
+        IXGBE_RTTBCNRC_RF_DEC_MASK;
+
+        /* enable the rate scheduler */
+        bcnrc_val |= IXGBE_RTTBCNRC_RS_ENA;
+
+        IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, queue_index);
+        IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRC, bcnrc_val);
+
+        return 0;
+}
+
+/**
  * ixgbe_clean_tx_irq - Reclaim resources after transmit completes
  * @q_vector: structure containing interrupt and ring information
  * @tx_ring: tx ring to clean
+ * @napi_budget: Used to determine if we are in netpoll
  **/
 static bool ixgbe_clean_tx_irq(struct ixgbe_q_vector *q_vector,
                                struct ixgbe_ring *tx_ring, int napi_budget)
@@ -2222,6 +2254,7 @@ static void ixgbe_configure_msix(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 ixgbe_set_ivar(adapter, -1, 1, v_idx);
                 break;
         default:
@@ -2333,6 +2366,7 @@ void ixgbe_write_eitr(struct ixgbe_q_vector *q_vector)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 /*
                  * set the WDIS bit to not clear the timer bits and cause an
                  * immediate assertion of the interrupt
@@ -2494,6 +2528,7 @@ static inline bool ixgbe_is_sfp(struct ixgbe_hw *hw)
                 return false;
         case ixgbe_mac_82599EB:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 switch (hw->mac.ops.get_media_type(hw)) {
                 case ixgbe_media_type_fiber:
                 case ixgbe_media_type_fiber_qsfp:
@@ -2568,6 +2603,7 @@ static inline void ixgbe_irq_enable_queues(struct ixgbe_adapter *adapter,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 mask = (qmask & 0xFFFFFFFF);
                 if (mask)
                         IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask);
@@ -2596,6 +2632,7 @@ static inline void ixgbe_irq_disable_queues(struct ixgbe_adapter *adapter,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 mask = (qmask & 0xFFFFFFFF);
                 if (mask)
                         IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask);
@@ -2631,6 +2668,7 @@ static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter, bool queues,
                 case ixgbe_mac_X540:
                 case ixgbe_mac_X550:
                 case ixgbe_mac_X550EM_x:
+                case ixgbe_mac_x550em_a:
                         mask |= IXGBE_EIMS_TS;
                         break;
                 default:
@@ -2646,7 +2684,10 @@ static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter, bool queues,
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
-                if (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_X_SFP)
+        case ixgbe_mac_x550em_a:
+                if (adapter->hw.device_id == IXGBE_DEV_ID_X550EM_X_SFP ||
+                    adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_SFP ||
+                    adapter->hw.device_id == IXGBE_DEV_ID_X550EM_A_SFP_N)
                         mask |= IXGBE_EIMS_GPI_SDP0(&adapter->hw);
                 if (adapter->hw.phy.type == ixgbe_phy_x550em_ext_t)
                         mask |= IXGBE_EICR_GPI_SDP0_X540;
@@ -2704,6 +2745,7 @@ static irqreturn_t ixgbe_msix_other(int irq, void *data)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 if (hw->phy.type == ixgbe_phy_x550em_ext_t &&
                     (eicr & IXGBE_EICR_GPI_SDP0_X540)) {
                         adapter->flags2 |= IXGBE_FLAG2_PHY_INTERRUPT;
@@ -2786,8 +2828,10 @@ int ixgbe_poll(struct napi_struct *napi, int budget)
                 ixgbe_update_dca(q_vector);
 #endif
 
-        ixgbe_for_each_ring(ring, q_vector->tx)
-                clean_complete &= !!ixgbe_clean_tx_irq(q_vector, ring, budget);
+        ixgbe_for_each_ring(ring, q_vector->tx) {
+                if (!ixgbe_clean_tx_irq(q_vector, ring, budget))
+                        clean_complete = false;
+        }
 
         /* Exit if we are called by netpoll or busy polling is active */
         if ((budget <= 0) || !ixgbe_qv_lock_napi(q_vector))
@@ -2805,7 +2849,8 @@ int ixgbe_poll(struct napi_struct *napi, int budget)
                                                  per_ring_budget);
 
                 work_done += cleaned;
-                clean_complete &= (cleaned < per_ring_budget);
+                if (cleaned >= per_ring_budget)
+                        clean_complete = false;
         }
 
         ixgbe_qv_unlock_napi(q_vector);
@@ -2937,6 +2982,7 @@ static irqreturn_t ixgbe_intr(int irq, void *data)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 if (eicr & IXGBE_EICR_ECC) {
                         e_info(link, "Received ECC Err, initiating reset\n");
                         adapter->flags2 |= IXGBE_FLAG2_RESET_REQUESTED;
@@ -3033,6 +3079,7 @@ static inline void ixgbe_irq_disable(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, 0xFFFF0000);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(0), ~0);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC_EX(1), ~0);
@@ -3832,6 +3879,7 @@ static void ixgbe_setup_rdrxctl(struct ixgbe_adapter *adapter)
                 break;
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 if (adapter->num_vfs)
                         rdrxctl |= IXGBE_RDRXCTL_PSP;
                 /* fall through for older HW */
@@ -3908,7 +3956,9 @@ static int ixgbe_vlan_rx_add_vid(struct net_device *netdev,
         struct ixgbe_hw *hw = &adapter->hw;
 
         /* add VID to filter table */
-        hw->mac.ops.set_vfta(&adapter->hw, vid, VMDQ_P(0), true, true);
+        if (!vid || !(adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC))
+                hw->mac.ops.set_vfta(&adapter->hw, vid, VMDQ_P(0), true, !!vid);
+
         set_bit(vid, adapter->active_vlans);
 
         return 0;
@@ -3965,9 +4015,7 @@ static int ixgbe_vlan_rx_kill_vid(struct net_device *netdev,
         struct ixgbe_hw *hw = &adapter->hw;
 
         /* remove VID from filter table */
-        if (adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC)
-                ixgbe_update_pf_promisc_vlvf(adapter, vid);
-        else
+        if (vid && !(adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC))
                 hw->mac.ops.set_vfta(hw, vid, VMDQ_P(0), false, true);
 
         clear_bit(vid, adapter->active_vlans);
@@ -3995,6 +4043,7 @@ static void ixgbe_vlan_strip_disable(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 for (i = 0; i < adapter->num_rx_queues; i++) {
                         struct ixgbe_ring *ring = adapter->rx_ring[i];
 
@@ -4031,6 +4080,7 @@ static void ixgbe_vlan_strip_enable(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 for (i = 0; i < adapter->num_rx_queues; i++) {
                         struct ixgbe_ring *ring = adapter->rx_ring[i];
 
@@ -4057,6 +4107,7 @@ static void ixgbe_vlan_promisc_enable(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
         default:
                 if (adapter->flags & IXGBE_FLAG_VMDQ_ENABLED)
                         break;
@@ -4147,6 +4198,7 @@ static void ixgbe_vlan_promisc_disable(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
         default:
                 if (adapter->flags & IXGBE_FLAG_VMDQ_ENABLED)
                         break;
@@ -4172,11 +4224,11 @@ static void ixgbe_vlan_promisc_disable(struct ixgbe_adapter *adapter)
 
 static void ixgbe_restore_vlan(struct ixgbe_adapter *adapter)
 {
-        u16 vid;
+        u16 vid = 1;
 
         ixgbe_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), 0);
 
-        for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
+        for_each_set_bit_from(vid, adapter->active_vlans, VLAN_N_VID)
                 ixgbe_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
 }
 
@@ -4426,6 +4478,7 @@ void ixgbe_set_rx_mode(struct net_device *netdev)
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
         u32 fctrl, vmolr = IXGBE_VMOLR_BAM | IXGBE_VMOLR_AUPE;
+        netdev_features_t features = netdev->features;
         int count;
 
         /* Check for Promiscuous and All Multicast modes */
@@ -4443,14 +4496,13 @@ void ixgbe_set_rx_mode(struct net_device *netdev)
                 hw->addr_ctrl.user_set_promisc = true;
                 fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
                 vmolr |= IXGBE_VMOLR_MPE;
-                ixgbe_vlan_promisc_enable(adapter);
+                features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;
         } else {
                 if (netdev->flags & IFF_ALLMULTI) {
                         fctrl |= IXGBE_FCTRL_MPE;
                         vmolr |= IXGBE_VMOLR_MPE;
                 }
                 hw->addr_ctrl.user_set_promisc = false;
-                ixgbe_vlan_promisc_disable(adapter);
         }
 
         /*
@@ -4483,7 +4535,7 @@ void ixgbe_set_rx_mode(struct net_device *netdev)
         }
 
         /* This is useful for sniffing bad packets. */
-        if (adapter->netdev->features & NETIF_F_RXALL) {
+        if (features & NETIF_F_RXALL) {
                 /* UPE and MPE will be handled by normal PROMISC logic
                  * in e1000e_set_rx_mode */
                 fctrl |= (IXGBE_FCTRL_SBP | /* Receive bad packets */
@@ -4496,10 +4548,15 @@ void ixgbe_set_rx_mode(struct net_device *netdev)
 
         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
 
-        if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
+        if (features & NETIF_F_HW_VLAN_CTAG_RX)
                 ixgbe_vlan_strip_enable(adapter);
         else
                 ixgbe_vlan_strip_disable(adapter);
+
+        if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
+                ixgbe_vlan_promisc_disable(adapter);
+        else
+                ixgbe_vlan_promisc_enable(adapter);
 }
 
 static void ixgbe_napi_enable_all(struct ixgbe_adapter *adapter)
@@ -4530,10 +4587,9 @@ static void ixgbe_clear_vxlan_port(struct ixgbe_adapter *adapter)
         switch (adapter->hw.mac.type) {
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VXLANCTRL, 0);
-#ifdef CONFIG_IXGBE_VXLAN
                 adapter->vxlan_port = 0;
-#endif
                 break;
         default:
                 break;
@@ -4632,6 +4688,7 @@ static int ixgbe_hpbthresh(struct ixgbe_adapter *adapter, int pb)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 dv_id = IXGBE_DV_X540(link, tc);
                 break;
         default:
@@ -4692,6 +4749,7 @@ static int ixgbe_lpbthresh(struct ixgbe_adapter *adapter, int pb)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 dv_id = IXGBE_LOW_DV_X540(tc);
                 break;
         default:
@@ -5108,6 +5166,7 @@ static void ixgbe_setup_gpie(struct ixgbe_adapter *adapter)
                 case ixgbe_mac_X540:
                 case ixgbe_mac_X550:
                 case ixgbe_mac_X550EM_x:
+                case ixgbe_mac_x550em_a:
                 default:
                         IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF);
                         IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF);
@@ -5158,6 +5217,7 @@ static void ixgbe_setup_gpie(struct ixgbe_adapter *adapter)
                 gpie |= IXGBE_SDP1_GPIEN_8259X | IXGBE_SDP2_GPIEN_8259X;
                 break;
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 gpie |= IXGBE_SDP0_GPIEN_X540;
                 break;
         default:
@@ -5469,6 +5529,7 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL,
                                 (IXGBE_READ_REG(hw, IXGBE_DMATXCTL) &
                                  ~IXGBE_DMATXCTL_TE));
@@ -5587,6 +5648,7 @@ static int ixgbe_sw_init(struct ixgbe_adapter *adapter)
                         adapter->flags2 |= IXGBE_FLAG2_TEMP_SENSOR_CAPABLE;
                 break;
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
         case ixgbe_mac_X550:
 #ifdef CONFIG_IXGBE_DCA
                 adapter->flags &= ~IXGBE_FLAG_DCA_CAPABLE;
@@ -5612,6 +5674,7 @@ static int ixgbe_sw_init(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 adapter->dcb_cfg.num_tcs.pg_tcs = X540_TRAFFIC_CLASS;
                 adapter->dcb_cfg.num_tcs.pfc_tcs = X540_TRAFFIC_CLASS;
                 break;
@@ -5994,7 +6057,7 @@ static int ixgbe_change_mtu(struct net_device *netdev, int new_mtu)
  * handler is registered with the OS, the watchdog timer is started,
  * and the stack is notified that the interface is ready.
  **/
-static int ixgbe_open(struct net_device *netdev)
+int ixgbe_open(struct net_device *netdev)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
@@ -6096,7 +6159,7 @@ static void ixgbe_close_suspend(struct ixgbe_adapter *adapter)
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int ixgbe_close(struct net_device *netdev)
+int ixgbe_close(struct net_device *netdev)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 
@@ -6219,6 +6282,7 @@ static int __ixgbe_shutdown(struct pci_dev *pdev, bool *enable_wake)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 pci_wake_from_d3(pdev, !!wufc);
                 break;
         default:
@@ -6354,6 +6418,7 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter)
                 case ixgbe_mac_X540:
                 case ixgbe_mac_X550:
                 case ixgbe_mac_X550EM_x:
+                case ixgbe_mac_x550em_a:
                         hwstats->pxonrxc[i] +=
                                 IXGBE_READ_REG(hw, IXGBE_PXONRXCNT(i));
                         break;
@@ -6369,7 +6434,8 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter)
                 if ((hw->mac.type == ixgbe_mac_82599EB) ||
                     (hw->mac.type == ixgbe_mac_X540) ||
                     (hw->mac.type == ixgbe_mac_X550) ||
-                    (hw->mac.type == ixgbe_mac_X550EM_x)) {
+                    (hw->mac.type == ixgbe_mac_X550EM_x) ||
+                    (hw->mac.type == ixgbe_mac_x550em_a)) {
                         hwstats->qbtc[i] += IXGBE_READ_REG(hw, IXGBE_QBTC_L(i));
                         IXGBE_READ_REG(hw, IXGBE_QBTC_H(i)); /* to clear */
                         hwstats->qbrc[i] += IXGBE_READ_REG(hw, IXGBE_QBRC_L(i));
@@ -6394,6 +6460,7 @@ void ixgbe_update_stats(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 /* OS2BMC stats are X540 and later */
                 hwstats->o2bgptc += IXGBE_READ_REG(hw, IXGBE_O2BGPTC);
                 hwstats->o2bspc += IXGBE_READ_REG(hw, IXGBE_O2BSPC);
@@ -6664,6 +6731,7 @@ static void ixgbe_watchdog_link_is_up(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
         case ixgbe_mac_82599EB: {
                 u32 mflcn = IXGBE_READ_REG(hw, IXGBE_MFLCN);
                 u32 fccfg = IXGBE_READ_REG(hw, IXGBE_FCCFG);
@@ -7213,103 +7281,61 @@ static int ixgbe_tso(struct ixgbe_ring *tx_ring,
         return 1;
 }
 
+static inline bool ixgbe_ipv6_csum_is_sctp(struct sk_buff *skb)
+{
+        unsigned int offset = 0;
+
+        ipv6_find_hdr(skb, &offset, IPPROTO_SCTP, NULL, NULL);
+
+        return offset == skb_checksum_start_offset(skb);
+}
+
 static void ixgbe_tx_csum(struct ixgbe_ring *tx_ring,
                           struct ixgbe_tx_buffer *first)
 {
         struct sk_buff *skb = first->skb;
         u32 vlan_macip_lens = 0;
-        u32 mss_l4len_idx = 0;
         u32 type_tucmd = 0;
 
         if (skb->ip_summed != CHECKSUM_PARTIAL) {
-                if (!(first->tx_flags & IXGBE_TX_FLAGS_HW_VLAN) &&
-                    !(first->tx_flags & IXGBE_TX_FLAGS_CC))
+csum_failed:
+                if (!(first->tx_flags & (IXGBE_TX_FLAGS_HW_VLAN |
+                                         IXGBE_TX_FLAGS_CC)))
                         return;
-                vlan_macip_lens = skb_network_offset(skb) <<
-                                  IXGBE_ADVTXD_MACLEN_SHIFT;
-        } else {
-                u8 l4_hdr = 0;
-                union {
-                        struct iphdr *ipv4;
-                        struct ipv6hdr *ipv6;
-                        u8 *raw;
-                } network_hdr;
-                union {
-                        struct tcphdr *tcphdr;
-                        u8 *raw;
-                } transport_hdr;
-                __be16 frag_off;
-
-                if (skb->encapsulation) {
-                        network_hdr.raw = skb_inner_network_header(skb);
-                        transport_hdr.raw = skb_inner_transport_header(skb);
-                        vlan_macip_lens = skb_inner_network_offset(skb) <<
-                                          IXGBE_ADVTXD_MACLEN_SHIFT;
-                } else {
-                        network_hdr.raw = skb_network_header(skb);
-                        transport_hdr.raw = skb_transport_header(skb);
-                        vlan_macip_lens = skb_network_offset(skb) <<
-                                          IXGBE_ADVTXD_MACLEN_SHIFT;
-                }
-
-                /* use first 4 bits to determine IP version */
-                switch (network_hdr.ipv4->version) {
-                case IPVERSION:
-                        vlan_macip_lens |= transport_hdr.raw - network_hdr.raw;
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_IPV4;
-                        l4_hdr = network_hdr.ipv4->protocol;
-                        break;
-                case 6:
-                        vlan_macip_lens |= transport_hdr.raw - network_hdr.raw;
-                        l4_hdr = network_hdr.ipv6->nexthdr;
-                        if (likely((transport_hdr.raw - network_hdr.raw) ==
-                                   sizeof(struct ipv6hdr)))
-                                break;
-                        ipv6_skip_exthdr(skb, network_hdr.raw - skb->data +
-                                              sizeof(struct ipv6hdr),
-                                         &l4_hdr, &frag_off);
-                        if (unlikely(frag_off))
-                                l4_hdr = NEXTHDR_FRAGMENT;
-                        break;
-                default:
-                        break;
-                }
+                goto no_csum;
+        }
 
-                switch (l4_hdr) {
-                case IPPROTO_TCP:
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_L4T_TCP;
-                        mss_l4len_idx = (transport_hdr.tcphdr->doff * 4) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
-                        break;
-                case IPPROTO_SCTP:
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_L4T_SCTP;
-                        mss_l4len_idx = sizeof(struct sctphdr) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
-                        break;
-                case IPPROTO_UDP:
-                        mss_l4len_idx = sizeof(struct udphdr) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
+        switch (skb->csum_offset) {
+        case offsetof(struct tcphdr, check):
+                type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_TCP;
+                /* fall through */
+        case offsetof(struct udphdr, check):
+                break;
+        case offsetof(struct sctphdr, checksum):
+                /* validate that this is actually an SCTP request */
+                if (((first->protocol == htons(ETH_P_IP)) &&
+                     (ip_hdr(skb)->protocol == IPPROTO_SCTP)) ||
+                    ((first->protocol == htons(ETH_P_IPV6)) &&
+                     ixgbe_ipv6_csum_is_sctp(skb))) {
+                        type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_SCTP;
                         break;
-                default:
-                        if (unlikely(net_ratelimit())) {
-                                dev_warn(tx_ring->dev,
-                                         "partial checksum, version=%d, l4 proto=%x\n",
-                                         network_hdr.ipv4->version, l4_hdr);
-                        }
-                        skb_checksum_help(skb);
-                        goto no_csum;
                 }
-
-                /* update TX checksum flag */
-                first->tx_flags |= IXGBE_TX_FLAGS_CSUM;
+                /* fall through */
+        default:
+                skb_checksum_help(skb);
+                goto csum_failed;
         }
 
+        /* update TX checksum flag */
+        first->tx_flags |= IXGBE_TX_FLAGS_CSUM;
+        vlan_macip_lens = skb_checksum_start_offset(skb) -
+                          skb_network_offset(skb);
 no_csum:
         /* vlan_macip_lens: MACLEN, VLAN tag */
+        vlan_macip_lens |= skb_network_offset(skb) << IXGBE_ADVTXD_MACLEN_SHIFT;
         vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
 
-        ixgbe_tx_ctxtdesc(tx_ring, vlan_macip_lens, 0,
-                          type_tucmd, mss_l4len_idx);
+        ixgbe_tx_ctxtdesc(tx_ring, vlan_macip_lens, 0, type_tucmd, 0);
 }
 
 #define IXGBE_SET_FLAG(_input, _flag, _result) \
@@ -7560,11 +7586,10 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
                 struct ipv6hdr *ipv6;
         } hdr;
         struct tcphdr *th;
+        unsigned int hlen;
         struct sk_buff *skb;
-#ifdef CONFIG_IXGBE_VXLAN
-        u8 encap = false;
-#endif /* CONFIG_IXGBE_VXLAN */
         __be16 vlan_id;
+        int l4_proto;
 
         /* if ring doesn't have a interrupt vector, cannot perform ATR */
         if (!q_vector)
@@ -7576,62 +7601,50 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
 
         ring->atr_count++;
 
+        /* currently only IPv4/IPv6 with TCP is supported */
+        if ((first->protocol != htons(ETH_P_IP)) &&
+            (first->protocol != htons(ETH_P_IPV6)))
+                return;
+
         /* snag network header to get L4 type and address */
         skb = first->skb;
         hdr.network = skb_network_header(skb);
-        if (!skb->encapsulation) {
-                th = tcp_hdr(skb);
-        } else {
 #ifdef CONFIG_IXGBE_VXLAN
+        if (skb->encapsulation &&
+            first->protocol == htons(ETH_P_IP) &&
+            hdr.ipv4->protocol != IPPROTO_UDP) {
                 struct ixgbe_adapter *adapter = q_vector->adapter;
 
-                if (!adapter->vxlan_port)
-                        return;
-                if (first->protocol != htons(ETH_P_IP) ||
-                    hdr.ipv4->version != IPVERSION ||
-                    hdr.ipv4->protocol != IPPROTO_UDP) {
-                        return;
-                }
-                if (ntohs(udp_hdr(skb)->dest) != adapter->vxlan_port)
-                        return;
-                encap = true;
-                hdr.network = skb_inner_network_header(skb);
-                th = inner_tcp_hdr(skb);
-#else
-                return;
-#endif /* CONFIG_IXGBE_VXLAN */
+                /* verify the port is recognized as VXLAN */
+                if (adapter->vxlan_port &&
+                    udp_hdr(skb)->dest == adapter->vxlan_port)
+                        hdr.network = skb_inner_network_header(skb);
         }
+#endif /* CONFIG_IXGBE_VXLAN */
 
         /* Currently only IPv4/IPv6 with TCP is supported */
         switch (hdr.ipv4->version) {
         case IPVERSION:
-                if (hdr.ipv4->protocol != IPPROTO_TCP)
-                        return;
+                /* access ihl as u8 to avoid unaligned access on ia64 */
+                hlen = (hdr.network[0] & 0x0F) << 2;
+                l4_proto = hdr.ipv4->protocol;
                 break;
         case 6:
-                if (likely((unsigned char *)th - hdr.network ==
-                           sizeof(struct ipv6hdr))) {
-                        if (hdr.ipv6->nexthdr != IPPROTO_TCP)
-                                return;
-                } else {
-                        __be16 frag_off;
-                        u8 l4_hdr;
-
-                        ipv6_skip_exthdr(skb, hdr.network - skb->data +
-                                              sizeof(struct ipv6hdr),
-                                         &l4_hdr, &frag_off);
-                        if (unlikely(frag_off))
-                                return;
-                        if (l4_hdr != IPPROTO_TCP)
-                                return;
-                }
+                hlen = hdr.network - skb->data;
+                l4_proto = ipv6_find_hdr(skb, &hlen, IPPROTO_TCP, NULL, NULL);
+                hlen -= hdr.network - skb->data;
                 break;
         default:
                 return;
         }
 
-        /* skip this packet since it is invalid or the socket is closing */
-        if (!th || th->fin)
+        if (l4_proto != IPPROTO_TCP)
+                return;
+
+        th = (struct tcphdr *)(hdr.network + hlen);
+
+        /* skip this packet since the socket is closing */
+        if (th->fin)
                 return;
 
         /* sample on all syn packets or once every atr sample count */
@@ -7682,10 +7695,8 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
                 break;
         }
 
-#ifdef CONFIG_IXGBE_VXLAN
-        if (encap)
+        if (hdr.network != skb_network_header(skb))
                 input.formatted.flow_type |= IXGBE_ATR_L4TYPE_TUNNEL_MASK;
-#endif /* CONFIG_IXGBE_VXLAN */
 
         /* This assumes the Rx queue and Tx queue are bound to the same CPU */
         ixgbe_fdir_add_signature_filter_82599(&q_vector->adapter->hw,
@@ -8209,10 +8220,17 @@ int ixgbe_setup_tc(struct net_device *dev, u8 tc)
 static int ixgbe_delete_clsu32(struct ixgbe_adapter *adapter,
                                struct tc_cls_u32_offload *cls)
 {
+        u32 uhtid = TC_U32_USERHTID(cls->knode.handle);
+        u32 loc;
         int err;
 
+        if ((uhtid != 0x800) && (uhtid >= IXGBE_MAX_LINK_HANDLE))
+                return -EINVAL;
+
+        loc = cls->knode.handle & 0xfffff;
+
         spin_lock(&adapter->fdir_perfect_lock);
-        err = ixgbe_update_ethtool_fdir_entry(adapter, NULL, cls->knode.handle);
+        err = ixgbe_update_ethtool_fdir_entry(adapter, NULL, loc);
         spin_unlock(&adapter->fdir_perfect_lock);
         return err;
 }
@@ -8221,20 +8239,30 @@ static int ixgbe_configure_clsu32_add_hnode(struct ixgbe_adapter *adapter,
                                             __be16 protocol,
                                             struct tc_cls_u32_offload *cls)
 {
+        u32 uhtid = TC_U32_USERHTID(cls->hnode.handle);
+
+        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
+                return -EINVAL;
+
         /* This ixgbe devices do not support hash tables at the moment
          * so abort when given hash tables.
          */
         if (cls->hnode.divisor > 0)
                 return -EINVAL;
 
-        set_bit(TC_U32_USERHTID(cls->hnode.handle), &adapter->tables);
+        set_bit(uhtid - 1, &adapter->tables);
         return 0;
 }
 
 static int ixgbe_configure_clsu32_del_hnode(struct ixgbe_adapter *adapter,
                                             struct tc_cls_u32_offload *cls)
 {
-        clear_bit(TC_U32_USERHTID(cls->hnode.handle), &adapter->tables);
+        u32 uhtid = TC_U32_USERHTID(cls->hnode.handle);
+
+        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
+                return -EINVAL;
+
+        clear_bit(uhtid - 1, &adapter->tables);
         return 0;
 }
 
@@ -8252,46 +8280,46 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
 #endif
         int i, err = 0;
         u8 queue;
-        u32 handle;
+        u32 uhtid, link_uhtid;
 
         memset(&mask, 0, sizeof(union ixgbe_atr_input));
-        handle = cls->knode.handle;
+        uhtid = TC_U32_USERHTID(cls->knode.handle);
+        link_uhtid = TC_U32_USERHTID(cls->knode.link_handle);
 
-        /* At the moment cls_u32 jumps to transport layer and skips past
+        /* At the moment cls_u32 jumps to network layer and skips past
          * L2 headers. The canonical method to match L2 frames is to use
          * negative values. However this is error prone at best but really
          * just broken because there is no way to "know" what sort of hdr
-         * is in front of the transport layer. Fix cls_u32 to support L2
+         * is in front of the network layer. Fix cls_u32 to support L2
          * headers when needed.
          */
         if (protocol != htons(ETH_P_IP))
                 return -EINVAL;
 
-        if (cls->knode.link_handle ||
-            cls->knode.link_handle >= IXGBE_MAX_LINK_HANDLE) {
+        if (link_uhtid) {
                 struct ixgbe_nexthdr *nexthdr = ixgbe_ipv4_jumps;
-                u32 uhtid = TC_U32_USERHTID(cls->knode.link_handle);
 
-                if (!test_bit(uhtid, &adapter->tables))
+                if (link_uhtid >= IXGBE_MAX_LINK_HANDLE)
+                        return -EINVAL;
+
+                if (!test_bit(link_uhtid - 1, &adapter->tables))
                         return -EINVAL;
 
                 for (i = 0; nexthdr[i].jump; i++) {
-                        if (nexthdr->o != cls->knode.sel->offoff ||
-                            nexthdr->s != cls->knode.sel->offshift ||
-                            nexthdr->m != cls->knode.sel->offmask ||
+                        if (nexthdr[i].o != cls->knode.sel->offoff ||
+                            nexthdr[i].s != cls->knode.sel->offshift ||
+                            nexthdr[i].m != cls->knode.sel->offmask ||
                             /* do not support multiple key jumps its just mad */
                             cls->knode.sel->nkeys > 1)
                                 return -EINVAL;
 
-                        if (nexthdr->off != cls->knode.sel->keys[0].off ||
-                            nexthdr->val != cls->knode.sel->keys[0].val ||
-                            nexthdr->mask != cls->knode.sel->keys[0].mask)
-                                return -EINVAL;
-
-                        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
-                                return -EINVAL;
-
-                        adapter->jump_tables[uhtid] = nexthdr->jump;
+                        if (nexthdr[i].off == cls->knode.sel->keys[0].off &&
+                            nexthdr[i].val == cls->knode.sel->keys[0].val &&
+                            nexthdr[i].mask == cls->knode.sel->keys[0].mask) {
+                                adapter->jump_tables[link_uhtid] =
+                                                                nexthdr[i].jump;
+                                break;
+                        }
                 }
                 return 0;
         }
@@ -8308,13 +8336,13 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
          * To add support for new nodes update ixgbe_model.h parse structures
          * this function _should_ be generic try not to hardcode values here.
          */
-        if (TC_U32_USERHTID(handle) == 0x800) {
+        if (uhtid == 0x800) {
                 field_ptr = adapter->jump_tables[0];
         } else {
-                if (TC_U32_USERHTID(handle) >= ARRAY_SIZE(adapter->jump_tables))
+                if (uhtid >= IXGBE_MAX_LINK_HANDLE)
                         return -EINVAL;
 
-                field_ptr = adapter->jump_tables[TC_U32_USERHTID(handle)];
+                field_ptr = adapter->jump_tables[uhtid];
         }
 
         if (!field_ptr)
@@ -8332,8 +8360,7 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
                 int j;
 
                 for (j = 0; field_ptr[j].val; j++) {
-                        if (field_ptr[j].off == off &&
-                            field_ptr[j].mask == m) {
+                        if (field_ptr[j].off == off) {
                                 field_ptr[j].val(input, &mask, val, m);
                                 input->filter.formatted.flow_type |=
                                         field_ptr[j].type;
@@ -8393,8 +8420,8 @@ err_out:
         return -EINVAL;
 }
 
-int __ixgbe_setup_tc(struct net_device *dev, u32 handle, __be16 proto,
-                     struct tc_to_netdev *tc)
+static int __ixgbe_setup_tc(struct net_device *dev, u32 handle, __be16 proto,
+                            struct tc_to_netdev *tc)
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
 
@@ -8517,11 +8544,6 @@ static int ixgbe_set_features(struct net_device *netdev,
                         adapter->flags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
         }
 
-        if (features & NETIF_F_HW_VLAN_CTAG_RX)
-                ixgbe_vlan_strip_enable(adapter);
-        else
-                ixgbe_vlan_strip_disable(adapter);
-
         if (changed & NETIF_F_RXALL)
                 need_reset = true;
 
@@ -8538,6 +8560,9 @@ static int ixgbe_set_features(struct net_device *netdev,
 
         if (need_reset)
                 ixgbe_do_reset(netdev);
+        else if (changed & (NETIF_F_HW_VLAN_CTAG_RX |
+                            NETIF_F_HW_VLAN_CTAG_FILTER))
+                ixgbe_set_rx_mode(netdev);
 
         return 0;
 }
@@ -8554,7 +8579,6 @@ static void ixgbe_add_vxlan_port(struct net_device *dev, sa_family_t sa_family,
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
         struct ixgbe_hw *hw = &adapter->hw;
-        u16 new_port = ntohs(port);
 
         if (!(adapter->flags & IXGBE_FLAG_VXLAN_OFFLOAD_CAPABLE))
                 return;
@@ -8562,18 +8586,18 @@ static void ixgbe_add_vxlan_port(struct net_device *dev, sa_family_t sa_family,
         if (sa_family == AF_INET6)
                 return;
 
-        if (adapter->vxlan_port == new_port)
+        if (adapter->vxlan_port == port)
                 return;
 
         if (adapter->vxlan_port) {
                 netdev_info(dev,
                             "Hit Max num of VXLAN ports, not adding port %d\n",
-                            new_port);
+                            ntohs(port));
                 return;
         }
 
-        adapter->vxlan_port = new_port;
-        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, new_port);
+        adapter->vxlan_port = port;
+        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, ntohs(port));
 }
 
 /**
@@ -8586,7 +8610,6 @@ static void ixgbe_del_vxlan_port(struct net_device *dev, sa_family_t sa_family,
                                  __be16 port)
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
-        u16 new_port = ntohs(port);
 
         if (!(adapter->flags & IXGBE_FLAG_VXLAN_OFFLOAD_CAPABLE))
                 return;
@@ -8594,9 +8617,9 @@ static void ixgbe_del_vxlan_port(struct net_device *dev, sa_family_t sa_family,
         if (sa_family == AF_INET6)
                 return;
 
-        if (adapter->vxlan_port != new_port) {
+        if (adapter->vxlan_port != port) {
                 netdev_info(dev, "Port %d was not found, not deleting\n",
-                            new_port);
+                            ntohs(port));
                 return;
         }
 
@@ -8862,6 +8885,7 @@ static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_set_mac_address    = ixgbe_set_mac,
         .ndo_change_mtu         = ixgbe_change_mtu,
         .ndo_tx_timeout         = ixgbe_tx_timeout,
+        .ndo_set_tx_maxrate     = ixgbe_tx_maxrate,
         .ndo_vlan_rx_add_vid    = ixgbe_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = ixgbe_vlan_rx_kill_vid,
         .ndo_do_ioctl           = ixgbe_ioctl,
@@ -8999,6 +9023,7 @@ int ixgbe_wol_supported(struct ixgbe_adapter *adapter, u16 device_id,
         case IXGBE_DEV_ID_X540T:
         case IXGBE_DEV_ID_X540T1:
         case IXGBE_DEV_ID_X550T:
+        case IXGBE_DEV_ID_X550T1:
         case IXGBE_DEV_ID_X550EM_X_KX4:
         case IXGBE_DEV_ID_X550EM_X_KR:
         case IXGBE_DEV_ID_X550EM_X_10G_T:
@@ -9015,29 +9040,6 @@ int ixgbe_wol_supported(struct ixgbe_adapter *adapter, u16 device_id,
 }
 
 /**
- * ixgbe_get_platform_mac_addr - Look up MAC address in Open Firmware / IDPROM
- * @adapter: Pointer to adapter struct
- */
-static void ixgbe_get_platform_mac_addr(struct ixgbe_adapter *adapter)
-{
-#ifdef CONFIG_OF
-        struct device_node *dp = pci_device_to_OF_node(adapter->pdev);
-        struct ixgbe_hw *hw = &adapter->hw;
-        const unsigned char *addr;
-
-        addr = of_get_mac_address(dp);
-        if (addr) {
-                ether_addr_copy(hw->mac.perm_addr, addr);
-                return;
-        }
-#endif /* CONFIG_OF */
-
-#ifdef CONFIG_SPARC
-        ether_addr_copy(hw->mac.perm_addr, idprom->id_ethaddr);
-#endif /* CONFIG_SPARC */
-}
-
-/**
  * ixgbe_probe - Device Initialization Routine
  * @pdev: PCI device information struct
  * @ent: entry in ixgbe_pci_tbl
@@ -9140,12 +9142,12 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         strlcpy(netdev->name, pci_name(pdev), sizeof(netdev->name));
 
         /* Setup hw api */
-        memcpy(&hw->mac.ops, ii->mac_ops, sizeof(hw->mac.ops));
+        hw->mac.ops   = *ii->mac_ops;
         hw->mac.type  = ii->mac;
         hw->mvals     = ii->mvals;
 
         /* EEPROM */
-        memcpy(&hw->eeprom.ops, ii->eeprom_ops, sizeof(hw->eeprom.ops));
+        hw->eeprom.ops = *ii->eeprom_ops;
         eec = IXGBE_READ_REG(hw, IXGBE_EEC(hw));
         if (ixgbe_removed(hw->hw_addr)) {
                 err = -EIO;
@@ -9156,7 +9158,7 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 hw->eeprom.ops.read = &ixgbe_read_eeprom_bit_bang_generic;
 
         /* PHY */
-        memcpy(&hw->phy.ops, ii->phy_ops, sizeof(hw->phy.ops));
+        hw->phy.ops = *ii->phy_ops;
         hw->phy.sfp_type = ixgbe_sfp_type_unknown;
         /* ixgbe_identify_phy_generic will set prtad and mmds properly */
         hw->phy.mdio.prtad = MDIO_PRTAD_NONE;
@@ -9173,12 +9175,17 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (err)
                 goto err_sw_init;
 
+        /* Make sure the SWFW semaphore is in a valid state */
+        if (hw->mac.ops.init_swfw_sync)
+                hw->mac.ops.init_swfw_sync(hw);
+
         /* Make it possible the adapter to be woken up via WOL */
         switch (adapter->hw.mac.type) {
         case ixgbe_mac_82599EB:
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_WUS, ~0);
                 break;
         default:
@@ -9219,63 +9226,46 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto skip_sriov;
         /* Mailbox */
         ixgbe_init_mbx_params_pf(hw);
-        memcpy(&hw->mbx.ops, ii->mbx_ops, sizeof(hw->mbx.ops));
+        hw->mbx.ops = ii->mbx_ops;
         pci_sriov_set_totalvfs(pdev, IXGBE_MAX_VFS_DRV_LIMIT);
         ixgbe_enable_sriov(adapter);
 skip_sriov:
 
 #endif
         netdev->features = NETIF_F_SG |
-                           NETIF_F_IP_CSUM |
-                           NETIF_F_IPV6_CSUM |
-                           NETIF_F_HW_VLAN_CTAG_TX |
-                           NETIF_F_HW_VLAN_CTAG_RX |
                            NETIF_F_TSO |
                            NETIF_F_TSO6 |
                            NETIF_F_RXHASH |
-                           NETIF_F_RXCSUM;
-
-        netdev->hw_features = netdev->features | NETIF_F_HW_L2FW_DOFFLOAD;
+                           NETIF_F_RXCSUM |
+                           NETIF_F_HW_CSUM |
+                           NETIF_F_HW_VLAN_CTAG_TX |
+                           NETIF_F_HW_VLAN_CTAG_RX |
+                           NETIF_F_HW_VLAN_CTAG_FILTER;
 
-        switch (adapter->hw.mac.type) {
-        case ixgbe_mac_82599EB:
-        case ixgbe_mac_X540:
-        case ixgbe_mac_X550:
-        case ixgbe_mac_X550EM_x:
+        if (hw->mac.type >= ixgbe_mac_82599EB)
                 netdev->features |= NETIF_F_SCTP_CRC;
-                netdev->hw_features |= NETIF_F_SCTP_CRC |
-                                       NETIF_F_NTUPLE |
-                                       NETIF_F_HW_TC;
-                break;
-        default:
-                break;
-        }
 
-        netdev->hw_features |= NETIF_F_RXALL;
-        netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
+        /* copy netdev features into list of user selectable features */
+        netdev->hw_features |= netdev->features;
+        netdev->hw_features |= NETIF_F_RXALL |
+                               NETIF_F_HW_L2FW_DOFFLOAD;
 
-        netdev->vlan_features |= NETIF_F_TSO;
-        netdev->vlan_features |= NETIF_F_TSO6;
-        netdev->vlan_features |= NETIF_F_IP_CSUM;
-        netdev->vlan_features |= NETIF_F_IPV6_CSUM;
-        netdev->vlan_features |= NETIF_F_SG;
+        if (hw->mac.type >= ixgbe_mac_82599EB)
+                netdev->hw_features |= NETIF_F_NTUPLE |
+                                       NETIF_F_HW_TC;
+
+        netdev->vlan_features |= NETIF_F_SG |
+                                 NETIF_F_TSO |
+                                 NETIF_F_TSO6 |
+                                 NETIF_F_HW_CSUM |
+                                 NETIF_F_SCTP_CRC;
 
-        netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
+        netdev->mpls_features |= NETIF_F_HW_CSUM;
+        netdev->hw_enc_features |= NETIF_F_HW_CSUM;
 
         netdev->priv_flags |= IFF_UNICAST_FLT;
         netdev->priv_flags |= IFF_SUPP_NOFCS;
 
-#ifdef CONFIG_IXGBE_VXLAN
-        switch (adapter->hw.mac.type) {
-        case ixgbe_mac_X550:
-        case ixgbe_mac_X550EM_x:
-                netdev->hw_enc_features |= NETIF_F_RXCSUM;
-                break;
-        default:
-                break;
-        }
-#endif /* CONFIG_IXGBE_VXLAN */
-
 #ifdef CONFIG_IXGBE_DCB
         netdev->dcbnl_ops = &dcbnl_ops;
 #endif
@@ -9319,7 +9309,8 @@ skip_sriov:
                 goto err_sw_init;
         }
 
-        ixgbe_get_platform_mac_addr(adapter);
+        eth_platform_get_mac_address(&adapter->pdev->dev,
+                                     adapter->hw.mac.perm_addr);
 
         memcpy(netdev->dev_addr, hw->mac.perm_addr, netdev->addr_len);
 
@@ -9329,6 +9320,8 @@ skip_sriov:
                 goto err_sw_init;
         }
 
+        /* Set hw->mac.addr to permanent MAC address */
+        ether_addr_copy(hw->mac.addr, hw->mac.perm_addr);
         ixgbe_mac_set_default_filter(adapter);
 
         setup_timer(&adapter->service_timer, &ixgbe_service_timer,
@@ -9625,6 +9618,9 @@ static pci_ers_result_t ixgbe_io_error_detected(struct pci_dev *pdev,
                 case ixgbe_mac_X550EM_x:
                         device_id = IXGBE_DEV_ID_X550EM_X_VF;
                         break;
+                case ixgbe_mac_x550em_a:
+                        device_id = IXGBE_DEV_ID_X550EM_A_VF;
+                        break;
                 default:
                         device_id = 0;
                         break;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.c
index 9993a471d668..b2125e358f7b 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -48,10 +48,10 @@ s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
         if (size > mbx->size)
                 size = mbx->size;
 
-        if (!mbx->ops.read)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        return mbx->ops.read(hw, msg, size, mbx_id);
+        return mbx->ops->read(hw, msg, size, mbx_id);
 }
 
 /**
@@ -70,10 +70,10 @@ s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
         if (size > mbx->size)
                 return IXGBE_ERR_MBX;
 
-        if (!mbx->ops.write)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        return mbx->ops.write(hw, msg, size, mbx_id);
+        return mbx->ops->write(hw, msg, size, mbx_id);
 }
 
 /**
@@ -87,10 +87,10 @@ s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
 {
         struct ixgbe_mbx_info *mbx = &hw->mbx;
 
-        if (!mbx->ops.check_for_msg)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        return mbx->ops.check_for_msg(hw, mbx_id);
+        return mbx->ops->check_for_msg(hw, mbx_id);
 }
 
 /**
@@ -104,10 +104,10 @@ s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
 {
         struct ixgbe_mbx_info *mbx = &hw->mbx;
 
-        if (!mbx->ops.check_for_ack)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        return mbx->ops.check_for_ack(hw, mbx_id);
+        return mbx->ops->check_for_ack(hw, mbx_id);
 }
 
 /**
@@ -121,10 +121,10 @@ s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
 {
         struct ixgbe_mbx_info *mbx = &hw->mbx;
 
-        if (!mbx->ops.check_for_rst)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        return mbx->ops.check_for_rst(hw, mbx_id);
+        return mbx->ops->check_for_rst(hw, mbx_id);
 }
 
 /**
@@ -139,10 +139,10 @@ static s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
         struct ixgbe_mbx_info *mbx = &hw->mbx;
         int countdown = mbx->timeout;
 
-        if (!countdown || !mbx->ops.check_for_msg)
+        if (!countdown || !mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        while (mbx->ops.check_for_msg(hw, mbx_id)) {
+        while (mbx->ops->check_for_msg(hw, mbx_id)) {
                 countdown--;
                 if (!countdown)
                         return IXGBE_ERR_MBX;
@@ -164,10 +164,10 @@ static s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
         struct ixgbe_mbx_info *mbx = &hw->mbx;
         int countdown = mbx->timeout;
 
-        if (!countdown || !mbx->ops.check_for_ack)
+        if (!countdown || !mbx->ops)
                 return IXGBE_ERR_MBX;
 
-        while (mbx->ops.check_for_ack(hw, mbx_id)) {
+        while (mbx->ops->check_for_ack(hw, mbx_id)) {
                 countdown--;
                 if (!countdown)
                         return IXGBE_ERR_MBX;
@@ -193,7 +193,7 @@ static s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
         struct ixgbe_mbx_info *mbx = &hw->mbx;
         s32 ret_val;
 
-        if (!mbx->ops.read)
+        if (!mbx->ops)
                 return IXGBE_ERR_MBX;
 
         ret_val = ixgbe_poll_for_msg(hw, mbx_id);
@@ -201,7 +201,7 @@ static s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
                 return ret_val;
 
         /* if ack received read message */
-        return mbx->ops.read(hw, msg, size, mbx_id);
+        return mbx->ops->read(hw, msg, size, mbx_id);
 }
 
 /**
@@ -221,11 +221,11 @@ static s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
         s32 ret_val;
 
         /* exit if either we can't write or there isn't a defined timeout */
-        if (!mbx->ops.write || !mbx->timeout)
+        if (!mbx->ops || !mbx->timeout)
                 return IXGBE_ERR_MBX;
 
         /* send msg */
-        ret_val = mbx->ops.write(hw, msg, size, mbx_id);
+        ret_val = mbx->ops->write(hw, msg, size, mbx_id);
         if (ret_val)
                 return ret_val;
 
@@ -307,6 +307,7 @@ static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
         case ixgbe_mac_X540:
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
                 break;
         default:
@@ -430,6 +431,7 @@ void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
         if (hw->mac.type != ixgbe_mac_82599EB &&
             hw->mac.type != ixgbe_mac_X550 &&
             hw->mac.type != ixgbe_mac_X550EM_x &&
+            hw->mac.type != ixgbe_mac_x550em_a &&
             hw->mac.type != ixgbe_mac_X540)
                 return;
 
@@ -446,7 +448,7 @@ void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
 }
 #endif /* CONFIG_PCI_IOV */
 
-struct ixgbe_mbx_operations mbx_ops_generic = {
+const struct ixgbe_mbx_operations mbx_ops_generic = {
         .read                   = ixgbe_read_mbx_pf,
         .write                  = ixgbe_write_mbx_pf,
         .read_posted            = ixgbe_read_posted_mbx,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
index 8daa95f74548..01c2667c0f92 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_mbx.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2013 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -123,6 +123,6 @@ s32 ixgbe_check_for_rst(struct ixgbe_hw *, u16);
 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *);
 #endif /* CONFIG_PCI_IOV */
 
-extern struct ixgbe_mbx_operations mbx_ops_generic;
+extern const struct ixgbe_mbx_operations mbx_ops_generic;
 
 #endif /* _IXGBE_MBX_H_ */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
index ce48872d4782..60adde55a8c3 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
@@ -32,7 +32,6 @@
 
 struct ixgbe_mat_field {
         unsigned int off;
-        unsigned int mask;
         int (*val)(struct ixgbe_fdir_filter *input,
                    union ixgbe_atr_input *mask,
                    u32 val, u32 m);
@@ -58,39 +57,37 @@ static inline int ixgbe_mat_prgm_dip(struct ixgbe_fdir_filter *input,
 }
 
 static struct ixgbe_mat_field ixgbe_ipv4_fields[] = {
-        { .off = 12, .mask = -1, .val = ixgbe_mat_prgm_sip,
+        { .off = 12, .val = ixgbe_mat_prgm_sip,
           .type = IXGBE_ATR_FLOW_TYPE_IPV4},
-        { .off = 16, .mask = -1, .val = ixgbe_mat_prgm_dip,
+        { .off = 16, .val = ixgbe_mat_prgm_dip,
           .type = IXGBE_ATR_FLOW_TYPE_IPV4},
         { .val = NULL } /* terminal node */
 };
 
-static inline int ixgbe_mat_prgm_sport(struct ixgbe_fdir_filter *input,
+static inline int ixgbe_mat_prgm_ports(struct ixgbe_fdir_filter *input,
                                        union ixgbe_atr_input *mask,
                                        u32 val, u32 m)
 {
         input->filter.formatted.src_port = val & 0xffff;
         mask->formatted.src_port = m & 0xffff;
-        return 0;
-};
+        input->filter.formatted.dst_port = val >> 16;
+        mask->formatted.dst_port = m >> 16;
 
-static inline int ixgbe_mat_prgm_dport(struct ixgbe_fdir_filter *input,
-                                       union ixgbe_atr_input *mask,
-                                       u32 val, u32 m)
-{
-        input->filter.formatted.dst_port = val & 0xffff;
-        mask->formatted.dst_port = m & 0xffff;
         return 0;
 };
 
 static struct ixgbe_mat_field ixgbe_tcp_fields[] = {
-        {.off = 0, .mask = 0xffff, .val = ixgbe_mat_prgm_sport,
-         .type = IXGBE_ATR_FLOW_TYPE_TCPV4},
-        {.off = 2, .mask = 0xffff, .val = ixgbe_mat_prgm_dport,
+        {.off = 0, .val = ixgbe_mat_prgm_ports,
          .type = IXGBE_ATR_FLOW_TYPE_TCPV4},
         { .val = NULL } /* terminal node */
 };
 
+static struct ixgbe_mat_field ixgbe_udp_fields[] = {
+        {.off = 0, .val = ixgbe_mat_prgm_ports,
+         .type = IXGBE_ATR_FLOW_TYPE_UDPV4},
+        { .val = NULL } /* terminal node */
+};
+
 struct ixgbe_nexthdr {
         /* offset, shift, and mask of position to next header */
         unsigned int o;
@@ -107,6 +104,8 @@ struct ixgbe_nexthdr {
 static struct ixgbe_nexthdr ixgbe_ipv4_jumps[] = {
         { .o = 0, .s = 6, .m = 0xf,
           .off = 8, .val = 0x600, .mask = 0xff00, .jump = ixgbe_tcp_fields},
+        { .o = 0, .s = 6, .m = 0xf,
+          .off = 8, .val = 0x1100, .mask = 0xff00, .jump = ixgbe_udp_fields},
         { .jump = NULL } /* terminal node */
 };
 #endif /* _IXGBE_MODEL_H_ */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.h
index 5abd66c84d00..cdf4c3800801 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -81,7 +81,11 @@
 #define IXGBE_I2C_EEPROM_STATUS_FAIL            0x2
 #define IXGBE_I2C_EEPROM_STATUS_IN_PROGRESS     0x3
 #define IXGBE_CS4227                            0xBE    /* CS4227 address */
+#define IXGBE_CS4227_GLOBAL_ID_LSB              0
+#define IXGBE_CS4227_GLOBAL_ID_MSB              1
 #define IXGBE_CS4227_SCRATCH                    2
+#define IXGBE_CS4223_PHY_ID                     0x7003  /* Quad port */
+#define IXGBE_CS4227_PHY_ID                     0x3003  /* Dual port */
 #define IXGBE_CS4227_RESET_PENDING              0x1357
 #define IXGBE_CS4227_RESET_COMPLETE             0x5AA5
 #define IXGBE_CS4227_RETRIES                    15
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
index ef1504d41890..bdc8fdcc07a5 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ptp.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -333,6 +333,7 @@ static void ixgbe_ptp_convert_to_hwtstamp(struct ixgbe_adapter *adapter,
          */
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 /* Upper 32 bits represent billions of cycles, lower 32 bits
                  * represent cycles. However, we use timespec64_to_ns for the
                  * correct math even though the units haven't been corrected
@@ -921,6 +922,7 @@ static int ixgbe_ptp_set_timestamp_mode(struct ixgbe_adapter *adapter,
         switch (hw->mac.type) {
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 /* enable timestamping all packets only if at least some
                  * packets were requested. Otherwise, play nice and disable
                  * timestamping
@@ -1083,6 +1085,7 @@ void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter)
                         cc.shift = 2;
                 }
                 /* fallthrough */
+        case ixgbe_mac_x550em_a:
         case ixgbe_mac_X550:
                 cc.read = ixgbe_ptp_read_X550;
 
@@ -1223,6 +1226,7 @@ static long ixgbe_ptp_create_clock(struct ixgbe_adapter *adapter)
                 break;
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
+        case ixgbe_mac_x550em_a:
                 snprintf(adapter->ptp_caps.name, 16, "%s", netdev->name);
                 adapter->ptp_caps.owner = THIS_MODULE;
                 adapter->ptp_caps.max_adj = 30000000;
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
index 8025a3f93598..adcf00002483 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c
@@ -589,40 +589,40 @@ static void ixgbe_clear_vmvir(struct ixgbe_adapter *adapter, u32 vf)
 static void ixgbe_clear_vf_vlans(struct ixgbe_adapter *adapter, u32 vf)
 {
         struct ixgbe_hw *hw = &adapter->hw;
-        u32 i;
+        u32 vlvfb_mask, pool_mask, i;
+
+        /* create mask for VF and other pools */
+        pool_mask = ~(1 << (VMDQ_P(0) % 32));
+        vlvfb_mask = 1 << (vf % 32);
 
         /* post increment loop, covers VLVF_ENTRIES - 1 to 0 */
         for (i = IXGBE_VLVF_ENTRIES; i--;) {
                 u32 bits[2], vlvfb, vid, vfta, vlvf;
                 u32 word = i * 2 + vf / 32;
-                u32 mask = 1 << (vf % 32);
+                u32 mask;
 
                 vlvfb = IXGBE_READ_REG(hw, IXGBE_VLVFB(word));
 
                 /* if our bit isn't set we can skip it */
-                if (!(vlvfb & mask))
+                if (!(vlvfb & vlvfb_mask))
                         continue;
 
                 /* clear our bit from vlvfb */
-                vlvfb ^= mask;
+                vlvfb ^= vlvfb_mask;
 
                 /* create 64b mask to chedk to see if we should clear VLVF */
                 bits[word % 2] = vlvfb;
                 bits[~word % 2] = IXGBE_READ_REG(hw, IXGBE_VLVFB(word ^ 1));
 
-                /* if promisc is enabled, PF will be present, leave VFTA */
-                if (adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC) {
-                        bits[VMDQ_P(0) / 32] &= ~(1 << (VMDQ_P(0) % 32));
-
-                        if (bits[0] || bits[1])
-                                goto update_vlvfb;
-                        goto update_vlvf;
-                }
-
                 /* if other pools are present, just remove ourselves */
-                if (bits[0] || bits[1])
+                if (bits[(VMDQ_P(0) / 32) ^ 1] ||
+                    (bits[VMDQ_P(0) / 32] & pool_mask))
                         goto update_vlvfb;
 
+                /* if PF is present, leave VFTA */
+                if (bits[0] || bits[1])
+                        goto update_vlvf;
+
                 /* if we cannot determine VLAN just remove ourselves */
                 vlvf = IXGBE_READ_REG(hw, IXGBE_VLVF(i));
                 if (!vlvf)
@@ -638,6 +638,9 @@ static void ixgbe_clear_vf_vlans(struct ixgbe_adapter *adapter, u32 vf)
 update_vlvf:
                 /* clear POOL selection enable */
                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(i), 0);
+
+                if (!(adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC))
+                        vlvfb = 0;
 update_vlvfb:
                 /* clear pool bits */
                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(word), vlvfb);
@@ -887,7 +890,7 @@ static int ixgbe_set_vf_mac_addr(struct ixgbe_adapter *adapter,
                 return -1;
         }
 
-        if (adapter->vfinfo[vf].pf_set_mac &&
+        if (adapter->vfinfo[vf].pf_set_mac && !adapter->vfinfo[vf].trusted &&
             !ether_addr_equal(adapter->vfinfo[vf].vf_mac_addresses, new_mac)) {
                 e_warn(drv,
                        "VF %d attempted to override administratively set MAC address\n"
@@ -1395,7 +1398,7 @@ out:
         return err;
 }
 
-static int ixgbe_link_mbps(struct ixgbe_adapter *adapter)
+int ixgbe_link_mbps(struct ixgbe_adapter *adapter)
 {
         switch (adapter->link_speed) {
         case IXGBE_LINK_SPEED_100_FULL:
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h
index dad925706f4c..47e65e2f886a 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.h
@@ -44,6 +44,7 @@ void ixgbe_ping_all_vfs(struct ixgbe_adapter *adapter);
 int ixgbe_ndo_set_vf_mac(struct net_device *netdev, int queue, u8 *mac);
 int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int queue, u16 vlan,
                            u8 qos);
+int ixgbe_link_mbps(struct ixgbe_adapter *adapter);
 int ixgbe_ndo_set_vf_bw(struct net_device *netdev, int vf, int min_tx_rate,
                         int max_tx_rate);
 int ixgbe_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
index bf7367a08716..ba3b837c7e9d 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_type.h
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2015 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -75,21 +75,29 @@
 #define IXGBE_DEV_ID_X540T1              0x1560
 
 #define IXGBE_DEV_ID_X550T              0x1563
+#define IXGBE_DEV_ID_X550T1             0x15D1
 #define IXGBE_DEV_ID_X550EM_X_KX4       0x15AA
 #define IXGBE_DEV_ID_X550EM_X_KR        0x15AB
 #define IXGBE_DEV_ID_X550EM_X_SFP       0x15AC
 #define IXGBE_DEV_ID_X550EM_X_10G_T     0x15AD
 #define IXGBE_DEV_ID_X550EM_X_1G_T      0x15AE
+#define IXGBE_DEV_ID_X550EM_A_KR        0x15C2
+#define IXGBE_DEV_ID_X550EM_A_KR_L      0x15C3
+#define IXGBE_DEV_ID_X550EM_A_SFP_N     0x15C4
+#define IXGBE_DEV_ID_X550EM_A_SGMII     0x15C6
+#define IXGBE_DEV_ID_X550EM_A_SGMII_L   0x15C7
+#define IXGBE_DEV_ID_X550EM_A_SFP       0x15CE
+
+/* VF Device IDs */
 #define IXGBE_DEV_ID_X550_VF_HV 0x1564
 #define IXGBE_DEV_ID_X550_VF            0x1565
 #define IXGBE_DEV_ID_X550EM_X_VF        0x15A8
 #define IXGBE_DEV_ID_X550EM_X_VF_HV     0x15A9
-
-/* VF Device IDs */
 #define IXGBE_DEV_ID_82599_VF           0x10ED
 #define IXGBE_DEV_ID_X540_VF            0x1515
 #define IXGBE_DEV_ID_X550_VF            0x1565
 #define IXGBE_DEV_ID_X550EM_X_VF        0x15A8
+#define IXGBE_DEV_ID_X550EM_A_VF        0x15C5
 
 #define IXGBE_CAT(r, m) IXGBE_##r##_##m
 
@@ -128,7 +136,7 @@
 #define IXGBE_FLA_X540          IXGBE_FLA_8259X
 #define IXGBE_FLA_X550          IXGBE_FLA_8259X
 #define IXGBE_FLA_X550EM_x      IXGBE_FLA_8259X
-#define IXGBE_FLA_X550EM_a      0x15F6C
+#define IXGBE_FLA_X550EM_a      0x15F68
 #define IXGBE_FLA(_hw)          IXGBE_BY_MAC((_hw), FLA)
 #define IXGBE_EEMNGCTL  0x10110
 #define IXGBE_EEMNGDATA 0x10114
@@ -143,13 +151,6 @@
 #define IXGBE_GRC_X550EM_a      0x15F64
 #define IXGBE_GRC(_hw)          IXGBE_BY_MAC((_hw), GRC)
 
-#define IXGBE_SRAMREL_8259X     0x10210
-#define IXGBE_SRAMREL_X540      IXGBE_SRAMREL_8259X
-#define IXGBE_SRAMREL_X550      IXGBE_SRAMREL_8259X
-#define IXGBE_SRAMREL_X550EM_x  IXGBE_SRAMREL_8259X
-#define IXGBE_SRAMREL_X550EM_a  0x15F6C
-#define IXGBE_SRAMREL(_hw)      IXGBE_BY_MAC((_hw), SRAMREL)
-
 /* General Receive Control */
 #define IXGBE_GRC_MNG  0x00000001 /* Manageability Enable */
 #define IXGBE_GRC_APME 0x00000002 /* APM enabled in EEPROM */
@@ -375,6 +376,8 @@ struct ixgbe_thermal_sensor_data {
 #define IXGBE_MRCTL(_i)      (0x0F600 + ((_i) * 4))
 #define IXGBE_VMRVLAN(_i)    (0x0F610 + ((_i) * 4))
 #define IXGBE_VMRVM(_i)      (0x0F630 + ((_i) * 4))
+#define IXGBE_WQBR_RX(_i)    (0x2FB0 + ((_i) * 4)) /* 4 total */
+#define IXGBE_WQBR_TX(_i)    (0x8130 + ((_i) * 4)) /* 4 total */
 #define IXGBE_L34T_IMIR(_i)  (0x0E800 + ((_i) * 4)) /*128 of these (0-127)*/
 #define IXGBE_RXFECCERR0         0x051B8
 #define IXGBE_LLITHRESH 0x0EC90
@@ -446,6 +449,8 @@ struct ixgbe_thermal_sensor_data {
 #define IXGBE_DMATXCTL_TE       0x1 /* Transmit Enable */
 #define IXGBE_DMATXCTL_NS       0x2 /* No Snoop LSO hdr buffer */
 #define IXGBE_DMATXCTL_GDV      0x8 /* Global Double VLAN */
+#define IXGBE_DMATXCTL_MDP_EN   0x20 /* Bit 5 */
+#define IXGBE_DMATXCTL_MBINTEN  0x40 /* Bit 6 */
 #define IXGBE_DMATXCTL_VT_SHIFT 16  /* VLAN EtherType */
 
 #define IXGBE_PFDTXGSWC_VT_LBEN 0x1 /* Local L2 VT switch enable */
@@ -554,7 +559,6 @@ struct ixgbe_thermal_sensor_data {
 #define IXGBE_TDPT2TCCR(_i)     (0x0CD20 + ((_i) * 4)) /* 8 of these (0-7) */
 #define IXGBE_TDPT2TCSR(_i)     (0x0CD40 + ((_i) * 4)) /* 8 of these (0-7) */
 
-
 /* Security Control Registers */
 #define IXGBE_SECTXCTRL         0x08800
 #define IXGBE_SECTXSTAT         0x08804
@@ -1203,6 +1207,8 @@ struct ixgbe_thermal_sensor_data {
 #define IXGBE_RDRXCTL_RSCLLIDIS     0x00800000 /* Disable RSC compl on LLI */
 #define IXGBE_RDRXCTL_RSCACKC       0x02000000 /* must set 1 when RSC enabled */
 #define IXGBE_RDRXCTL_FCOE_WRFIX    0x04000000 /* must set 1 when RSC enabled */
+#define IXGBE_RDRXCTL_MBINTEN       0x10000000
+#define IXGBE_RDRXCTL_MDP_EN        0x20000000
 
 /* RQTC Bit Masks and Shifts */
 #define IXGBE_RQTC_SHIFT_TC(_i)     ((_i) * 4)
@@ -1309,6 +1315,7 @@ struct ixgbe_thermal_sensor_data {
 
 /* MDIO definitions */
 
+#define IXGBE_MDIO_ZERO_DEV_TYPE                0x0
 #define IXGBE_MDIO_PMA_PMD_DEV_TYPE             0x1
 #define IXGBE_MDIO_PCS_DEV_TYPE         0x3
 #define IXGBE_MDIO_PHY_XS_DEV_TYPE              0x4
@@ -1957,7 +1964,9 @@ enum {
 #define IXGBE_GSSR_PHY1_SM              0x0004
 #define IXGBE_GSSR_MAC_CSR_SM           0x0008
 #define IXGBE_GSSR_FLASH_SM             0x0010
+#define IXGBE_GSSR_NVM_UPDATE_SM        0x0200
 #define IXGBE_GSSR_SW_MNG_SM            0x0400
+#define IXGBE_GSSR_TOKEN_SM     0x40000000 /* SW bit for shared access */
 #define IXGBE_GSSR_SHARED_I2C_SM        0x1806 /* Wait for both phys & I2Cs */
 #define IXGBE_GSSR_I2C_MASK             0x1800
 #define IXGBE_GSSR_NVM_PHY_MASK         0xF
@@ -1997,6 +2006,9 @@ enum {
 #define IXGBE_PBANUM_PTR_GUARD          0xFAFA
 #define IXGBE_EEPROM_CHECKSUM           0x3F
 #define IXGBE_EEPROM_SUM                0xBABA
+#define IXGBE_EEPROM_CTRL_4             0x45
+#define IXGBE_EE_CTRL_4_INST_ID         0x10
+#define IXGBE_EE_CTRL_4_INST_ID_SHIFT   4
 #define IXGBE_PCIE_ANALOG_PTR           0x03
 #define IXGBE_ATLAS0_CONFIG_PTR         0x04
 #define IXGBE_PHY_PTR                   0x04
@@ -2530,6 +2542,10 @@ enum ixgbe_fdir_pballoc_type {
 #define IXGBE_FDIRCTRL_REPORT_STATUS_ALWAYS     0x00000080
 #define IXGBE_FDIRCTRL_DROP_Q_SHIFT             8
 #define IXGBE_FDIRCTRL_FLEX_SHIFT               16
+#define IXGBE_FDIRCTRL_DROP_NO_MATCH            0x00008000
+#define IXGBE_FDIRCTRL_FILTERMODE_SHIFT         21
+#define IXGBE_FDIRCTRL_FILTERMODE_MACVLAN       0x0001 /* bit 23:21, 001b */
+#define IXGBE_FDIRCTRL_FILTERMODE_CLOUD         0x0002 /* bit 23:21, 010b */
 #define IXGBE_FDIRCTRL_SEARCHLIM                0x00800000
 #define IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT         24
 #define IXGBE_FDIRCTRL_FULL_THRESH_MASK         0xF0000000
@@ -2620,6 +2636,20 @@ enum ixgbe_fdir_pballoc_type {
 #define FW_MAX_READ_BUFFER_SIZE         1024
 #define FW_DISABLE_RXEN_CMD             0xDE
 #define FW_DISABLE_RXEN_LEN             0x1
+#define FW_PHY_MGMT_REQ_CMD             0x20
+#define FW_PHY_TOKEN_REQ_CMD            0x0A
+#define FW_PHY_TOKEN_REQ_LEN            2
+#define FW_PHY_TOKEN_REQ                0
+#define FW_PHY_TOKEN_REL                1
+#define FW_PHY_TOKEN_OK                 1
+#define FW_PHY_TOKEN_RETRY              0x80
+#define FW_PHY_TOKEN_DELAY              5       /* milliseconds */
+#define FW_PHY_TOKEN_WAIT               5       /* seconds */
+#define FW_PHY_TOKEN_RETRIES ((FW_PHY_TOKEN_WAIT * 1000) / FW_PHY_TOKEN_DELAY)
+#define FW_INT_PHY_REQ_CMD              0xB
+#define FW_INT_PHY_REQ_LEN              10
+#define FW_INT_PHY_REQ_READ             0
+#define FW_INT_PHY_REQ_WRITE            1
 
 /* Host Interface Command Structures */
 struct ixgbe_hic_hdr {
@@ -2688,6 +2718,28 @@ struct ixgbe_hic_disable_rxen {
         u16 pad3;
 };
 
+struct ixgbe_hic_phy_token_req {
+        struct ixgbe_hic_hdr hdr;
+        u8 port_number;
+        u8 command_type;
+        u16 pad;
+};
+
+struct ixgbe_hic_internal_phy_req {
+        struct ixgbe_hic_hdr hdr;
+        u8 port_number;
+        u8 command_type;
+        __be16 address;
+        u16 rsv1;
+        __be32 write_data;
+        u16 pad;
+} __packed;
+
+struct ixgbe_hic_internal_phy_resp {
+        struct ixgbe_hic_hdr hdr;
+        __be32 read_data;
+};
+
 /* Transmit Descriptor - Advanced */
 union ixgbe_adv_tx_desc {
         struct {
@@ -2948,7 +3000,6 @@ union ixgbe_atr_hash_dword {
         IXGBE_CAT(EEC, m),              \
         IXGBE_CAT(FLA, m),              \
         IXGBE_CAT(GRC, m),              \
-        IXGBE_CAT(SRAMREL, m),          \
         IXGBE_CAT(FACTPS, m),           \
         IXGBE_CAT(SWSM, m),             \
         IXGBE_CAT(SWFW_SYNC, m),        \
@@ -2989,6 +3040,7 @@ enum ixgbe_mac_type {
         ixgbe_mac_X540,
         ixgbe_mac_X550,
         ixgbe_mac_X550EM_x,
+        ixgbe_mac_x550em_a,
         ixgbe_num_macs
 };
 
@@ -3017,6 +3069,7 @@ enum ixgbe_phy_type {
         ixgbe_phy_qsfp_intel,
         ixgbe_phy_qsfp_unknown,
         ixgbe_phy_sfp_unsupported,
+        ixgbe_phy_sgmii,
         ixgbe_phy_generic
 };
 
@@ -3130,8 +3183,9 @@ struct ixgbe_bus_info {
         enum ixgbe_bus_width width;
         enum ixgbe_bus_type type;
 
-        u16 func;
-        u16 lan_id;
+        u8 func;
+        u8 lan_id;
+        u8 instance_id;
 };
 
 /* Flow control parameters */
@@ -3266,6 +3320,7 @@ struct ixgbe_mac_operations {
         s32 (*enable_rx_dma)(struct ixgbe_hw *, u32);
         s32 (*acquire_swfw_sync)(struct ixgbe_hw *, u32);
         void (*release_swfw_sync)(struct ixgbe_hw *, u32);
+        void (*init_swfw_sync)(struct ixgbe_hw *);
         s32 (*prot_autoc_read)(struct ixgbe_hw *, bool *, u32 *);
         s32 (*prot_autoc_write)(struct ixgbe_hw *, u32, bool);
 
@@ -3308,6 +3363,7 @@ struct ixgbe_mac_operations {
 
         /* Flow Control */
         s32 (*fc_enable)(struct ixgbe_hw *);
+        s32 (*setup_fc)(struct ixgbe_hw *);
 
         /* Manageability interface */
         s32 (*set_fw_drv_ver)(struct ixgbe_hw *, u8, u8, u8, u8);
@@ -3323,6 +3379,8 @@ struct ixgbe_mac_operations {
         s32 (*dmac_config)(struct ixgbe_hw *hw);
         s32 (*dmac_update_tcs)(struct ixgbe_hw *hw);
         s32 (*dmac_config_tcs)(struct ixgbe_hw *hw);
+        s32 (*read_iosf_sb_reg)(struct ixgbe_hw *, u32, u32, u32 *);
+        s32 (*write_iosf_sb_reg)(struct ixgbe_hw *, u32, u32, u32);
 };
 
 struct ixgbe_phy_operations {
@@ -3442,7 +3500,7 @@ struct ixgbe_mbx_stats {
 };
 
 struct ixgbe_mbx_info {
-        struct ixgbe_mbx_operations ops;
+        const struct ixgbe_mbx_operations *ops;
         struct ixgbe_mbx_stats stats;
         u32 timeout;
         u32 usec_delay;
@@ -3475,10 +3533,10 @@ struct ixgbe_hw {
 struct ixgbe_info {
         enum ixgbe_mac_type             mac;
         s32                             (*get_invariants)(struct ixgbe_hw *);
-        struct ixgbe_mac_operations     *mac_ops;
-        struct ixgbe_eeprom_operations  *eeprom_ops;
-        struct ixgbe_phy_operations     *phy_ops;
-        struct ixgbe_mbx_operations     *mbx_ops;
+        const struct ixgbe_mac_operations       *mac_ops;
+        const struct ixgbe_eeprom_operations    *eeprom_ops;
+        const struct ixgbe_phy_operations       *phy_ops;
+        const struct ixgbe_mbx_operations       *mbx_ops;
         const u32                       *mvals;
 };
 
@@ -3517,6 +3575,8 @@ struct ixgbe_info {
 #define IXGBE_ERR_INVALID_ARGUMENT              -32
 #define IXGBE_ERR_HOST_INTERFACE_COMMAND        -33
 #define IXGBE_ERR_FDIR_CMD_INCOMPLETE           -38
+#define IXGBE_ERR_FW_RESP_INVALID               -39
+#define IXGBE_ERR_TOKEN_RETRY                   -40
 #define IXGBE_NOT_IMPLEMENTED                   0x7FFFFFFF
 
 #define IXGBE_FUSES0_GROUP(_i)          (0x11158 + ((_i) * 4))
@@ -3525,6 +3585,9 @@ struct ixgbe_info {
 
 #define IXGBE_KRM_PORT_CAR_GEN_CTRL(P)  ((P) ? 0x8010 : 0x4010)
 #define IXGBE_KRM_LINK_CTRL_1(P)        ((P) ? 0x820C : 0x420C)
+#define IXGBE_KRM_AN_CNTL_1(P)          ((P) ? 0x822C : 0x422C)
+#define IXGBE_KRM_AN_CNTL_8(P)          ((P) ? 0x8248 : 0x4248)
+#define IXGBE_KRM_SGMII_CTRL(P)         ((P) ? 0x82A0 : 0x42A0)
 #define IXGBE_KRM_DSP_TXFFE_STATE_4(P)  ((P) ? 0x8634 : 0x4634)
 #define IXGBE_KRM_DSP_TXFFE_STATE_5(P)  ((P) ? 0x8638 : 0x4638)
 #define IXGBE_KRM_RX_TRN_LINKUP_CTRL(P) ((P) ? 0x8B00 : 0x4B00)
@@ -3538,6 +3601,8 @@ struct ixgbe_info {
 #define IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK     (0x7 << 8)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_1G       (2 << 8)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_10G      (4 << 8)
+#define IXGBE_KRM_LINK_CTRL_1_TETH_AN_SGMII_EN          BIT(12)
+#define IXGBE_KRM_LINK_CTRL_1_TETH_AN_CLAUSE_37_EN      BIT(13)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_AN_FEC_REQ           (1 << 14)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_FEC           (1 << 15)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KX            (1 << 16)
@@ -3547,6 +3612,15 @@ struct ixgbe_info {
 #define IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE            (1 << 29)
 #define IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART           (1 << 31)
 
+#define IXGBE_KRM_AN_CNTL_1_SYM_PAUSE                   (1 << 28)
+#define IXGBE_KRM_AN_CNTL_1_ASM_PAUSE                   (1 << 29)
+
+#define IXGBE_KRM_AN_CNTL_8_LINEAR                      BIT(0)
+#define IXGBE_KRM_AN_CNTL_8_LIMITING                    BIT(1)
+
+#define IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_100_D        BIT(12)
+#define IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_10_D         BIT(19)
+
 #define IXGBE_KRM_DSP_TXFFE_STATE_C0_EN                 (1 << 6)
 #define IXGBE_KRM_DSP_TXFFE_STATE_CP1_CN1_EN            (1 << 15)
 #define IXGBE_KRM_DSP_TXFFE_STATE_CO_ADAPT_EN           (1 << 16)
@@ -3591,5 +3665,10 @@ struct ixgbe_info {
 #define IXGBE_SB_IOSF_TARGET_KX4_PCS1   3
 
 #define IXGBE_NW_MNG_IF_SEL             0x00011178
+#define IXGBE_NW_MNG_IF_SEL_MDIO_ACT            BIT(1)
+#define IXGBE_NW_MNG_IF_SEL_ENABLE_10_100M      BIT(23)
 #define IXGBE_NW_MNG_IF_SEL_INT_PHY_MODE        BIT(24)
+#define IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD_SHIFT  3
+#define IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD        \
+                                (0x1F << IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD_SHIFT)
 #endif /* _IXGBE_TYPE_H_ */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
index 2358c1b7d586..40824d85d807 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   Intel 10 Gigabit PCI Express Linux driver
-  Copyright(c) 1999 - 2014 Intel Corporation.
+  Copyright(c) 1999 - 2016 Intel Corporation.
 
   This program is free software; you can redistribute it and/or modify it
   under the terms and conditions of the GNU General Public License,
@@ -747,6 +747,25 @@ static void ixgbe_release_swfw_sync_semaphore(struct ixgbe_hw *hw)
 }
 
 /**
+ *  ixgbe_init_swfw_sync_X540 - Release hardware semaphore
+ *  @hw: pointer to hardware structure
+ *
+ *  This function reset hardware semaphore bits for a semaphore that may
+ *  have be left locked due to a catastrophic failure.
+ **/
+void ixgbe_init_swfw_sync_X540(struct ixgbe_hw *hw)
+{
+        /* First try to grab the semaphore but we don't need to bother
+         * looking to see whether we got the lock or not since we do
+         * the same thing regardless of whether we got the lock or not.
+         * We got the lock - we release it.
+         * We timeout trying to get the lock - we force its release.
+         */
+        ixgbe_get_swfw_sync_semaphore(hw);
+        ixgbe_release_swfw_sync_semaphore(hw);
+}
+
+/**
  * ixgbe_blink_led_start_X540 - Blink LED based on index.
  * @hw: pointer to hardware structure
  * @index: led number to blink
@@ -810,7 +829,7 @@ s32 ixgbe_blink_led_stop_X540(struct ixgbe_hw *hw, u32 index)
 
         return 0;
 }
-static struct ixgbe_mac_operations mac_ops_X540 = {
+static const struct ixgbe_mac_operations mac_ops_X540 = {
         .init_hw                = &ixgbe_init_hw_generic,
         .reset_hw               = &ixgbe_reset_hw_X540,
         .start_hw               = &ixgbe_start_hw_X540,
@@ -846,6 +865,7 @@ static struct ixgbe_mac_operations mac_ops_X540 = {
         .clear_vfta             = &ixgbe_clear_vfta_generic,
         .set_vfta               = &ixgbe_set_vfta_generic,
         .fc_enable              = &ixgbe_fc_enable_generic,
+        .setup_fc               = ixgbe_setup_fc_generic,
         .set_fw_drv_ver         = &ixgbe_set_fw_drv_ver_generic,
         .init_uta_tables        = &ixgbe_init_uta_tables_generic,
         .setup_sfp              = NULL,
@@ -853,6 +873,7 @@ static struct ixgbe_mac_operations mac_ops_X540 = {
         .set_vlan_anti_spoofing = &ixgbe_set_vlan_anti_spoofing,
         .acquire_swfw_sync      = &ixgbe_acquire_swfw_sync_X540,
         .release_swfw_sync      = &ixgbe_release_swfw_sync_X540,
+        .init_swfw_sync         = &ixgbe_init_swfw_sync_X540,
         .disable_rx_buff        = &ixgbe_disable_rx_buff_generic,
         .enable_rx_buff         = &ixgbe_enable_rx_buff_generic,
         .get_thermal_sensor_data = NULL,
@@ -863,7 +884,7 @@ static struct ixgbe_mac_operations mac_ops_X540 = {
         .disable_rx             = &ixgbe_disable_rx_generic,
 };
 
-static struct ixgbe_eeprom_operations eeprom_ops_X540 = {
+static const struct ixgbe_eeprom_operations eeprom_ops_X540 = {
         .init_params            = &ixgbe_init_eeprom_params_X540,
         .read                   = &ixgbe_read_eerd_X540,
         .read_buffer            = &ixgbe_read_eerd_buffer_X540,
@@ -874,7 +895,7 @@ static struct ixgbe_eeprom_operations eeprom_ops_X540 = {
         .update_checksum        = &ixgbe_update_eeprom_checksum_X540,
 };
 
-static struct ixgbe_phy_operations phy_ops_X540 = {
+static const struct ixgbe_phy_operations phy_ops_X540 = {
         .identify               = &ixgbe_identify_phy_generic,
         .identify_sfp           = &ixgbe_identify_sfp_module_generic,
         .init                   = NULL,
@@ -897,7 +918,7 @@ static const u32 ixgbe_mvals_X540[IXGBE_MVALS_IDX_LIMIT] = {
         IXGBE_MVALS_INIT(X540)
 };
 
-struct ixgbe_info ixgbe_X540_info = {
+const struct ixgbe_info ixgbe_X540_info = {
         .mac                    = ixgbe_mac_X540,
         .get_invariants         = &ixgbe_get_invariants_X540,
         .mac_ops                = &mac_ops_X540,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.h
index a1468b1f4d8a..e21cd48491d3 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x540.h
@@ -36,4 +36,5 @@ s32 ixgbe_blink_led_start_X540(struct ixgbe_hw *hw, u32 index);
 s32 ixgbe_blink_led_stop_X540(struct ixgbe_hw *hw, u32 index);
 s32 ixgbe_acquire_swfw_sync_X540(struct ixgbe_hw *hw, u32 mask);
 void ixgbe_release_swfw_sync_X540(struct ixgbe_hw *hw, u32 mask);
+void ixgbe_init_swfw_sync_X540(struct ixgbe_hw *hw);
 s32 ixgbe_init_eeprom_params_X540(struct ixgbe_hw *hw);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
index 87aca3f7c3de..c71e93ed4451 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
@@ -1,7 +1,7 @@
 /*******************************************************************************
  *
  *  Intel 10 Gigabit PCI Express Linux driver
- *  Copyright(c) 1999 - 2015 Intel Corporation.
+ *  Copyright(c) 1999 - 2016 Intel Corporation.
  *
  *  This program is free software; you can redistribute it and/or modify it
  *  under the terms and conditions of the GNU General Public License,
@@ -27,6 +27,7 @@
 #include "ixgbe_phy.h"
 
 static s32 ixgbe_setup_kr_speed_x550em(struct ixgbe_hw *, ixgbe_link_speed);
+static s32 ixgbe_setup_fc_x550em(struct ixgbe_hw *);
 
 static s32 ixgbe_get_invariants_X550_x(struct ixgbe_hw *hw)
 {
@@ -272,16 +273,26 @@ out:
 static s32 ixgbe_identify_phy_x550em(struct ixgbe_hw *hw)
 {
         switch (hw->device_id) {
+        case IXGBE_DEV_ID_X550EM_A_SFP:
+                if (hw->bus.lan_id)
+                        hw->phy.phy_semaphore_mask = IXGBE_GSSR_PHY1_SM;
+                else
+                        hw->phy.phy_semaphore_mask = IXGBE_GSSR_PHY0_SM;
+                return ixgbe_identify_module_generic(hw);
         case IXGBE_DEV_ID_X550EM_X_SFP:
                 /* set up for CS4227 usage */
                 hw->phy.phy_semaphore_mask = IXGBE_GSSR_SHARED_I2C_SM;
                 ixgbe_setup_mux_ctl(hw);
                 ixgbe_check_cs4227(hw);
+                /* Fallthrough */
+        case IXGBE_DEV_ID_X550EM_A_SFP_N:
                 return ixgbe_identify_module_generic(hw);
         case IXGBE_DEV_ID_X550EM_X_KX4:
                 hw->phy.type = ixgbe_phy_x550em_kx4;
                 break;
         case IXGBE_DEV_ID_X550EM_X_KR:
+        case IXGBE_DEV_ID_X550EM_A_KR:
+        case IXGBE_DEV_ID_X550EM_A_KR_L:
                 hw->phy.type = ixgbe_phy_x550em_kr;
                 break;
         case IXGBE_DEV_ID_X550EM_X_1G_T:
@@ -355,7 +366,7 @@ static s32 ixgbe_iosf_wait(struct ixgbe_hw *hw, u32 *ctrl)
                 command = IXGBE_READ_REG(hw, IXGBE_SB_IOSF_INDIRECT_CTRL);
                 if (!(command & IXGBE_SB_IOSF_CTRL_BUSY))
                         break;
-                usleep_range(10, 20);
+                udelay(10);
         }
         if (ctrl)
                 *ctrl = command;
@@ -412,6 +423,121 @@ out:
         return ret;
 }
 
+/**
+ * ixgbe_get_phy_token - Get the token for shared PHY access
+ * @hw: Pointer to hardware structure
+ */
+static s32 ixgbe_get_phy_token(struct ixgbe_hw *hw)
+{
+        struct ixgbe_hic_phy_token_req token_cmd;
+        s32 status;
+
+        token_cmd.hdr.cmd = FW_PHY_TOKEN_REQ_CMD;
+        token_cmd.hdr.buf_len = FW_PHY_TOKEN_REQ_LEN;
+        token_cmd.hdr.cmd_or_resp.cmd_resv = 0;
+        token_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
+        token_cmd.port_number = hw->bus.lan_id;
+        token_cmd.command_type = FW_PHY_TOKEN_REQ;
+        token_cmd.pad = 0;
+        status = ixgbe_host_interface_command(hw, &token_cmd, sizeof(token_cmd),
+                                              IXGBE_HI_COMMAND_TIMEOUT,
+                                              true);
+        if (status)
+                return status;
+        if (token_cmd.hdr.cmd_or_resp.ret_status == FW_PHY_TOKEN_OK)
+                return 0;
+        if (token_cmd.hdr.cmd_or_resp.ret_status != FW_PHY_TOKEN_RETRY)
+                return IXGBE_ERR_FW_RESP_INVALID;
+
+        return IXGBE_ERR_TOKEN_RETRY;
+}
+
+/**
+ * ixgbe_put_phy_token - Put the token for shared PHY access
+ * @hw: Pointer to hardware structure
+ */
+static s32 ixgbe_put_phy_token(struct ixgbe_hw *hw)
+{
+        struct ixgbe_hic_phy_token_req token_cmd;
+        s32 status;
+
+        token_cmd.hdr.cmd = FW_PHY_TOKEN_REQ_CMD;
+        token_cmd.hdr.buf_len = FW_PHY_TOKEN_REQ_LEN;
+        token_cmd.hdr.cmd_or_resp.cmd_resv = 0;
+        token_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
+        token_cmd.port_number = hw->bus.lan_id;
+        token_cmd.command_type = FW_PHY_TOKEN_REL;
+        token_cmd.pad = 0;
+        status = ixgbe_host_interface_command(hw, &token_cmd, sizeof(token_cmd),
+                                              IXGBE_HI_COMMAND_TIMEOUT,
+                                              true);
+        if (status)
+                return status;
+        if (token_cmd.hdr.cmd_or_resp.ret_status == FW_PHY_TOKEN_OK)
+                return 0;
+        return IXGBE_ERR_FW_RESP_INVALID;
+}
+
+/**
+ *  ixgbe_write_iosf_sb_reg_x550a - Write to IOSF PHY register
+ *  @hw: pointer to hardware structure
+ *  @reg_addr: 32 bit PHY register to write
+ *  @device_type: 3 bit device type
+ *  @data: Data to write to the register
+ **/
+static s32 ixgbe_write_iosf_sb_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
+                                         __always_unused u32 device_type,
+                                         u32 data)
+{
+        struct ixgbe_hic_internal_phy_req write_cmd;
+
+        memset(&write_cmd, 0, sizeof(write_cmd));
+        write_cmd.hdr.cmd = FW_INT_PHY_REQ_CMD;
+        write_cmd.hdr.buf_len = FW_INT_PHY_REQ_LEN;
+        write_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
+        write_cmd.port_number = hw->bus.lan_id;
+        write_cmd.command_type = FW_INT_PHY_REQ_WRITE;
+        write_cmd.address = cpu_to_be16(reg_addr);
+        write_cmd.write_data = cpu_to_be32(data);
+
+        return ixgbe_host_interface_command(hw, &write_cmd, sizeof(write_cmd),
+                                            IXGBE_HI_COMMAND_TIMEOUT, false);
+}
+
+/**
+ *  ixgbe_read_iosf_sb_reg_x550a - Read from IOSF PHY register
+ *  @hw: pointer to hardware structure
+ *  @reg_addr: 32 bit PHY register to write
+ *  @device_type: 3 bit device type
+ *  @data: Pointer to read data from the register
+ **/
+static s32 ixgbe_read_iosf_sb_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
+                                        __always_unused u32 device_type,
+                                        u32 *data)
+{
+        union {
+                struct ixgbe_hic_internal_phy_req cmd;
+                struct ixgbe_hic_internal_phy_resp rsp;
+        } hic;
+        s32 status;
+
+        memset(&hic, 0, sizeof(hic));
+        hic.cmd.hdr.cmd = FW_INT_PHY_REQ_CMD;
+        hic.cmd.hdr.buf_len = FW_INT_PHY_REQ_LEN;
+        hic.cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
+        hic.cmd.port_number = hw->bus.lan_id;
+        hic.cmd.command_type = FW_INT_PHY_REQ_READ;
+        hic.cmd.address = cpu_to_be16(reg_addr);
+
+        status = ixgbe_host_interface_command(hw, &hic.cmd, sizeof(hic.cmd),
+                                              IXGBE_HI_COMMAND_TIMEOUT, true);
+
+        /* Extract the register value from the response. */
+        *data = be32_to_cpu(hic.rsp.read_data);
+
+        return status;
+}
+
 /** ixgbe_read_ee_hostif_data_X550 - Read EEPROM word using a host interface
  *  command assuming that the semaphore is already obtained.
  *  @hw: pointer to hardware structure
@@ -436,8 +562,7 @@ static s32 ixgbe_read_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
         /* one word */
         buffer.length = cpu_to_be16(sizeof(u16));
 
-        status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
-                                              sizeof(buffer),
+        status = ixgbe_host_interface_command(hw, &buffer, sizeof(buffer),
                                               IXGBE_HI_COMMAND_TIMEOUT, false);
         if (status)
                 return status;
@@ -487,7 +612,7 @@ static s32 ixgbe_read_ee_hostif_buffer_X550(struct ixgbe_hw *hw,
                 buffer.address = cpu_to_be32((offset + current_word) * 2);
                 buffer.length = cpu_to_be16(words_to_read * 2);
 
-                status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
+                status = ixgbe_host_interface_command(hw, &buffer,
                                                       sizeof(buffer),
                                                       IXGBE_HI_COMMAND_TIMEOUT,
                                                       false);
@@ -770,8 +895,7 @@ static s32 ixgbe_write_ee_hostif_data_X550(struct ixgbe_hw *hw, u16 offset,
         buffer.data = data;
         buffer.address = cpu_to_be32(offset * 2);
 
-        status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
-                                              sizeof(buffer),
+        status = ixgbe_host_interface_command(hw, &buffer, sizeof(buffer),
                                               IXGBE_HI_COMMAND_TIMEOUT, false);
         return status;
 }
@@ -813,8 +937,7 @@ static s32 ixgbe_update_flash_X550(struct ixgbe_hw *hw)
         buffer.req.buf_lenl = FW_SHADOW_RAM_DUMP_LEN;
         buffer.req.checksum = FW_DEFAULT_CHECKSUM;
 
-        status = ixgbe_host_interface_command(hw, (u32 *)&buffer,
-                                              sizeof(buffer),
+        status = ixgbe_host_interface_command(hw, &buffer, sizeof(buffer),
                                               IXGBE_HI_COMMAND_TIMEOUT, false);
         return status;
 }
@@ -861,9 +984,9 @@ static void ixgbe_disable_rx_x550(struct ixgbe_hw *hw)
                 fw_cmd.hdr.cmd = FW_DISABLE_RXEN_CMD;
                 fw_cmd.hdr.buf_len = FW_DISABLE_RXEN_LEN;
                 fw_cmd.hdr.checksum = FW_DEFAULT_CHECKSUM;
-                fw_cmd.port_number = (u8)hw->bus.lan_id;
+                fw_cmd.port_number = hw->bus.lan_id;
 
-                status = ixgbe_host_interface_command(hw, (u32 *)&fw_cmd,
+                status = ixgbe_host_interface_command(hw, &fw_cmd,
                                         sizeof(struct ixgbe_hic_disable_rxen),
                                         IXGBE_HI_COMMAND_TIMEOUT, true);
 
@@ -1248,6 +1371,117 @@ i2c_err:
 }
 
 /**
+ * ixgbe_setup_mac_link_sfp_n - Setup internal PHY for native SFP
+ * @hw: pointer to hardware structure
+ *
+ * Configure the the integrated PHY for native SFP support.
+ */
+static s32
+ixgbe_setup_mac_link_sfp_n(struct ixgbe_hw *hw, ixgbe_link_speed speed,
+                           __always_unused bool autoneg_wait_to_complete)
+{
+        bool setup_linear = false;
+        u32 reg_phy_int;
+        s32 rc;
+
+        /* Check if SFP module is supported and linear */
+        rc = ixgbe_supported_sfp_modules_X550em(hw, &setup_linear);
+
+        /* If no SFP module present, then return success. Return success since
+         * SFP not present error is not excepted in the setup MAC link flow.
+         */
+        if (rc == IXGBE_ERR_SFP_NOT_PRESENT)
+                return 0;
+
+        if (!rc)
+                return rc;
+
+        /* Configure internal PHY for native SFI */
+        rc = hw->mac.ops.read_iosf_sb_reg(hw,
+                                          IXGBE_KRM_AN_CNTL_8(hw->bus.lan_id),
+                                          IXGBE_SB_IOSF_TARGET_KR_PHY,
+                                          &reg_phy_int);
+        if (rc)
+                return rc;
+
+        if (setup_linear) {
+                reg_phy_int &= ~IXGBE_KRM_AN_CNTL_8_LIMITING;
+                reg_phy_int |= IXGBE_KRM_AN_CNTL_8_LINEAR;
+        } else {
+                reg_phy_int |= IXGBE_KRM_AN_CNTL_8_LIMITING;
+                reg_phy_int &= ~IXGBE_KRM_AN_CNTL_8_LINEAR;
+        }
+
+        rc = hw->mac.ops.write_iosf_sb_reg(hw,
+                                           IXGBE_KRM_AN_CNTL_8(hw->bus.lan_id),
+                                           IXGBE_SB_IOSF_TARGET_KR_PHY,
+                                           reg_phy_int);
+        if (rc)
+                return rc;
+
+        /* Setup XFI/SFI internal link */
+        return ixgbe_setup_ixfi_x550em(hw, &speed);
+}
+
+/**
+ * ixgbe_setup_mac_link_sfp_x550a - Setup internal PHY for SFP
+ * @hw: pointer to hardware structure
+ *
+ * Configure the the integrated PHY for SFP support.
+ */
+static s32
+ixgbe_setup_mac_link_sfp_x550a(struct ixgbe_hw *hw, ixgbe_link_speed speed,
+                               __always_unused bool autoneg_wait_to_complete)
+{
+        u32 reg_slice, slice_offset;
+        bool setup_linear = false;
+        u16 reg_phy_ext;
+        s32 rc;
+
+        /* Check if SFP module is supported and linear */
+        rc = ixgbe_supported_sfp_modules_X550em(hw, &setup_linear);
+
+        /* If no SFP module present, then return success. Return success since
+         * SFP not present error is not excepted in the setup MAC link flow.
+         */
+        if (rc == IXGBE_ERR_SFP_NOT_PRESENT)
+                return 0;
+
+        if (!rc)
+                return rc;
+
+        /* Configure internal PHY for KR/KX. */
+        ixgbe_setup_kr_speed_x550em(hw, speed);
+
+        if (!hw->phy.mdio.prtad || hw->phy.mdio.prtad == 0xFFFF)
+                return IXGBE_ERR_PHY_ADDR_INVALID;
+
+        /* Get external PHY device id */
+        rc = hw->phy.ops.read_reg(hw, IXGBE_CS4227_GLOBAL_ID_MSB,
+                                  IXGBE_MDIO_ZERO_DEV_TYPE, &reg_phy_ext);
+        if (rc)
+                return rc;
+
+        /* When configuring quad port CS4223, the MAC instance is part
+         * of the slice offset.
+         */
+        if (reg_phy_ext == IXGBE_CS4223_PHY_ID)
+                slice_offset = (hw->bus.lan_id +
+                                (hw->bus.instance_id << 1)) << 12;
+        else
+                slice_offset = hw->bus.lan_id << 12;
+
+        /* Configure CS4227/CS4223 LINE side to proper mode. */
+        reg_slice = IXGBE_CS4227_LINE_SPARE24_LSB + slice_offset;
+        if (setup_linear)
+                reg_phy_ext = (IXGBE_CS4227_EDC_MODE_CX1 << 1) | 1;
+        else
+                reg_phy_ext = (IXGBE_CS4227_EDC_MODE_SR << 1) | 1;
+        return hw->phy.ops.write_reg(hw, reg_slice, IXGBE_MDIO_ZERO_DEV_TYPE,
+                                     reg_phy_ext);
+}
+
+/**
  * ixgbe_setup_mac_link_t_X550em - Sets the auto advertised link speed
  * @hw: pointer to hardware structure
  * @speed: new link speed
@@ -1326,6 +1560,57 @@ static s32 ixgbe_check_link_t_X550em(struct ixgbe_hw *hw,
         return 0;
 }
 
+/**
+ * ixgbe_setup_sgmii - Set up link for sgmii
+ * @hw: pointer to hardware structure
+ */
+static s32
+ixgbe_setup_sgmii(struct ixgbe_hw *hw, __always_unused ixgbe_link_speed speed,
+                  __always_unused bool autoneg_wait_to_complete)
+{
+        struct ixgbe_mac_info *mac = &hw->mac;
+        u32 lval, sval;
+        s32 rc;
+
+        rc = mac->ops.read_iosf_sb_reg(hw,
+                                       IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
+                                       IXGBE_SB_IOSF_TARGET_KR_PHY, &lval);
+        if (rc)
+                return rc;
+
+        lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE;
+        lval &= ~IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_MASK;
+        lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_SGMII_EN;
+        lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_CLAUSE_37_EN;
+        lval |= IXGBE_KRM_LINK_CTRL_1_TETH_FORCE_SPEED_1G;
+        rc = mac->ops.write_iosf_sb_reg(hw,
+                                        IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
+                                        IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
+        if (rc)
+                return rc;
+
+        rc = mac->ops.read_iosf_sb_reg(hw,
+                                       IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
+                                       IXGBE_SB_IOSF_TARGET_KR_PHY, &sval);
+        if (rc)
+                return rc;
+
+        sval |= IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_10_D;
+        sval |= IXGBE_KRM_SGMII_CTRL_MAC_TAR_FORCE_100_D;
+        rc = mac->ops.write_iosf_sb_reg(hw,
+                                        IXGBE_KRM_SGMII_CTRL(hw->bus.lan_id),
+                                        IXGBE_SB_IOSF_TARGET_KR_PHY, sval);
+        if (rc)
+                return rc;
+
+        lval |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
+        rc = mac->ops.write_iosf_sb_reg(hw,
+                                        IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
+                                        IXGBE_SB_IOSF_TARGET_KR_PHY, lval);
+
+        return rc;
+}
+
 /** ixgbe_init_mac_link_ops_X550em - init mac link function pointers
  *  @hw: pointer to hardware structure
  **/
@@ -1342,15 +1627,35 @@ static void ixgbe_init_mac_link_ops_X550em(struct ixgbe_hw *hw)
                 mac->ops.enable_tx_laser = NULL;
                 mac->ops.flap_tx_laser = NULL;
                 mac->ops.setup_link = ixgbe_setup_mac_link_multispeed_fiber;
-                mac->ops.setup_mac_link = ixgbe_setup_mac_link_sfp_x550em;
+                mac->ops.setup_fc = ixgbe_setup_fc_x550em;
+                switch (hw->device_id) {
+                case IXGBE_DEV_ID_X550EM_A_SFP_N:
+                        mac->ops.setup_mac_link = ixgbe_setup_mac_link_sfp_n;
+                        break;
+                case IXGBE_DEV_ID_X550EM_A_SFP:
+                        mac->ops.setup_mac_link =
+                                                ixgbe_setup_mac_link_sfp_x550a;
+                        break;
+                default:
+                        mac->ops.setup_mac_link =
+                                                ixgbe_setup_mac_link_sfp_x550em;
+                        break;
+                }
                 mac->ops.set_rate_select_speed =
                                         ixgbe_set_soft_rate_select_speed;
                 break;
         case ixgbe_media_type_copper:
                 mac->ops.setup_link = ixgbe_setup_mac_link_t_X550em;
+                mac->ops.setup_fc = ixgbe_setup_fc_generic;
                 mac->ops.check_link = ixgbe_check_link_t_X550em;
+                return;
+        case ixgbe_media_type_backplane:
+                if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII ||
+                    hw->device_id == IXGBE_DEV_ID_X550EM_A_SGMII_L)
+                        mac->ops.setup_link = ixgbe_setup_sgmii;
                 break;
         default:
+                mac->ops.setup_fc = ixgbe_setup_fc_x550em;
                 break;
         }
 }
@@ -1614,7 +1919,7 @@ static s32 ixgbe_setup_kr_speed_x550em(struct ixgbe_hw *hw,
         s32 status;
         u32 reg_val;
 
-        status = ixgbe_read_iosf_sb_reg_x550(hw,
+        status = hw->mac.ops.read_iosf_sb_reg(hw,
                                         IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
                                         IXGBE_SB_IOSF_TARGET_KR_PHY, &reg_val);
         if (status)
@@ -1636,7 +1941,7 @@ static s32 ixgbe_setup_kr_speed_x550em(struct ixgbe_hw *hw,
 
         /* Restart auto-negotiation. */
         reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_RESTART;
-        status = ixgbe_write_iosf_sb_reg_x550(hw,
+        status = hw->mac.ops.write_iosf_sb_reg(hw,
                                         IXGBE_KRM_LINK_CTRL_1(hw->bus.lan_id),
                                         IXGBE_SB_IOSF_TARGET_KR_PHY, reg_val);
 
@@ -1653,9 +1958,9 @@ static s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw)
         s32 status;
         u32 reg_val;
 
-        status = ixgbe_read_iosf_sb_reg_x550(hw, IXGBE_KX4_LINK_CNTL_1,
-                                             IXGBE_SB_IOSF_TARGET_KX4_PCS0 +
-                                             hw->bus.lan_id, &reg_val);
+        status = hw->mac.ops.read_iosf_sb_reg(hw, IXGBE_KX4_LINK_CNTL_1,
+                                              IXGBE_SB_IOSF_TARGET_KX4_PCS0 +
+                                              hw->bus.lan_id, &reg_val);
         if (status)
                 return status;
 
@@ -1674,20 +1979,24 @@ static s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw)
 
         /* Restart auto-negotiation. */
         reg_val |= IXGBE_KX4_LINK_CNTL_1_TETH_AN_RESTART;
-        status = ixgbe_write_iosf_sb_reg_x550(hw, IXGBE_KX4_LINK_CNTL_1,
-                                              IXGBE_SB_IOSF_TARGET_KX4_PCS0 +
-                                              hw->bus.lan_id, reg_val);
+        status = hw->mac.ops.write_iosf_sb_reg(hw, IXGBE_KX4_LINK_CNTL_1,
+                                               IXGBE_SB_IOSF_TARGET_KX4_PCS0 +
+                                               hw->bus.lan_id, reg_val);
 
         return status;
 }
 
-/**  ixgbe_setup_kr_x550em - Configure the KR PHY.
- *   @hw: pointer to hardware structure
+/**
+ * ixgbe_setup_kr_x550em - Configure the KR PHY
+ * @hw: pointer to hardware structure
  *
- *   Configures the integrated KR PHY.
+ * Configures the integrated KR PHY for X550EM_x.
  **/
 static s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw)
 {
+        if (hw->mac.type != ixgbe_mac_X550EM_x)
+                return 0;
+
         return ixgbe_setup_kr_speed_x550em(hw, hw->phy.autoneg_advertised);
 }
 
@@ -1842,6 +2151,86 @@ static s32 ixgbe_get_lcd_t_x550em(struct ixgbe_hw *hw,
         return status;
 }
 
+/**
+ * ixgbe_setup_fc_x550em - Set up flow control
+ * @hw: pointer to hardware structure
+ */
+static s32 ixgbe_setup_fc_x550em(struct ixgbe_hw *hw)
+{
+        bool pause, asm_dir;
+        u32 reg_val;
+        s32 rc;
+
+        /* Validate the requested mode */
+        if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
+                hw_err(hw, "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
+                return IXGBE_ERR_INVALID_LINK_SETTINGS;
+        }
+
+        /* 10gig parts do not have a word in the EEPROM to determine the
+         * default flow control setting, so we explicitly set it to full.
+         */
+        if (hw->fc.requested_mode == ixgbe_fc_default)
+                hw->fc.requested_mode = ixgbe_fc_full;
+
+        /* Determine PAUSE and ASM_DIR bits. */
+        switch (hw->fc.requested_mode) {
+        case ixgbe_fc_none:
+                pause = false;
+                asm_dir = false;
+                break;
+        case ixgbe_fc_tx_pause:
+                pause = false;
+                asm_dir = true;
+                break;
+        case ixgbe_fc_rx_pause:
+                /* Rx Flow control is enabled and Tx Flow control is
+                 * disabled by software override. Since there really
+                 * isn't a way to advertise that we are capable of RX
+                 * Pause ONLY, we will advertise that we support both
+                 * symmetric and asymmetric Rx PAUSE, as such we fall
+                 * through to the fc_full statement.  Later, we will
+                 * disable the adapter's ability to send PAUSE frames.
+                 */
+                /* Fallthrough */
+        case ixgbe_fc_full:
+                pause = true;
+                asm_dir = true;
+                break;
+        default:
+                hw_err(hw, "Flow control param set incorrectly\n");
+                return IXGBE_ERR_CONFIG;
+        }
+
+        if (hw->device_id != IXGBE_DEV_ID_X550EM_X_KR &&
+            hw->device_id != IXGBE_DEV_ID_X550EM_A_KR &&
+            hw->device_id != IXGBE_DEV_ID_X550EM_A_KR_L)
+                return 0;
+
+        rc = hw->mac.ops.read_iosf_sb_reg(hw,
+                                          IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
+                                          IXGBE_SB_IOSF_TARGET_KR_PHY,
+                                          &reg_val);
+        if (rc)
+                return rc;
+
+        reg_val &= ~(IXGBE_KRM_AN_CNTL_1_SYM_PAUSE |
+                     IXGBE_KRM_AN_CNTL_1_ASM_PAUSE);
+        if (pause)
+                reg_val |= IXGBE_KRM_AN_CNTL_1_SYM_PAUSE;
+        if (asm_dir)
+                reg_val |= IXGBE_KRM_AN_CNTL_1_ASM_PAUSE;
+        rc = hw->mac.ops.write_iosf_sb_reg(hw,
+                                           IXGBE_KRM_AN_CNTL_1(hw->bus.lan_id),
+                                           IXGBE_SB_IOSF_TARGET_KR_PHY,
+                                           reg_val);
+
+        /* This device does not fully support AN. */
+        hw->fc.disable_fc_autoneg = true;
+
+        return rc;
+}
+
 /** ixgbe_enter_lplu_x550em - Transition to low power states
  *  @hw: pointer to hardware structure
  *
@@ -1939,6 +2328,36 @@ static s32 ixgbe_enter_lplu_t_x550em(struct ixgbe_hw *hw)
         return status;
 }
 
+/**
+ * ixgbe_read_mng_if_sel_x550em - Read NW_MNG_IF_SEL register
+ * @hw: pointer to hardware structure
+ *
+ * Read NW_MNG_IF_SEL register and save field values.
+ */
+static void ixgbe_read_mng_if_sel_x550em(struct ixgbe_hw *hw)
+{
+        /* Save NW management interface connected on board. This is used
+         * to determine internal PHY mode.
+         */
+        hw->phy.nw_mng_if_sel = IXGBE_READ_REG(hw, IXGBE_NW_MNG_IF_SEL);
+
+        /* If X552 (X550EM_a) and MDIO is connected to external PHY, then set
+         * PHY address. This register field was has only been used for X552.
+         */
+        if (!hw->phy.nw_mng_if_sel) {
+                if (hw->mac.type == ixgbe_mac_x550em_a) {
+                        struct ixgbe_adapter *adapter = hw->back;
+
+                        e_warn(drv, "nw_mng_if_sel not set\n");
+                }
+                return;
+        }
+
+        hw->phy.mdio.prtad = (hw->phy.nw_mng_if_sel &
+                              IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD) >>
+                             IXGBE_NW_MNG_IF_SEL_MDIO_PHY_ADD_SHIFT;
+}
+
 /** ixgbe_init_phy_ops_X550em - PHY/SFP specific init
  *  @hw: pointer to hardware structure
  *
@@ -1953,14 +2372,11 @@ static s32 ixgbe_init_phy_ops_X550em(struct ixgbe_hw *hw)
 
         hw->mac.ops.set_lan_id(hw);
 
+        ixgbe_read_mng_if_sel_x550em(hw);
+
         if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber) {
                 phy->phy_semaphore_mask = IXGBE_GSSR_SHARED_I2C_SM;
                 ixgbe_setup_mux_ctl(hw);
-
-                /* Save NW management interface connected on board. This is used
-                 * to determine internal PHY mode.
-                 */
-                phy->nw_mng_if_sel = IXGBE_READ_REG(hw, IXGBE_NW_MNG_IF_SEL);
         }
 
         /* Identify the PHY or SFP module */
@@ -2023,16 +2439,24 @@ static enum ixgbe_media_type ixgbe_get_media_type_X550em(struct ixgbe_hw *hw)
 
         /* Detect if there is a copper PHY attached. */
         switch (hw->device_id) {
+        case IXGBE_DEV_ID_X550EM_A_SGMII:
+        case IXGBE_DEV_ID_X550EM_A_SGMII_L:
+                hw->phy.type = ixgbe_phy_sgmii;
+                /* Fallthrough */
         case IXGBE_DEV_ID_X550EM_X_KR:
         case IXGBE_DEV_ID_X550EM_X_KX4:
+        case IXGBE_DEV_ID_X550EM_A_KR:
+        case IXGBE_DEV_ID_X550EM_A_KR_L:
                 media_type = ixgbe_media_type_backplane;
                 break;
         case IXGBE_DEV_ID_X550EM_X_SFP:
+        case IXGBE_DEV_ID_X550EM_A_SFP:
+        case IXGBE_DEV_ID_X550EM_A_SFP_N:
                 media_type = ixgbe_media_type_fiber;
                 break;
         case IXGBE_DEV_ID_X550EM_X_1G_T:
         case IXGBE_DEV_ID_X550EM_X_10G_T:
-                 media_type = ixgbe_media_type_copper;
+                media_type = ixgbe_media_type_copper;
                 break;
         default:
                 media_type = ixgbe_media_type_unknown;
@@ -2080,6 +2504,27 @@ static s32 ixgbe_init_ext_t_x550em(struct ixgbe_hw *hw)
         return status;
 }
 
+/**
+ * ixgbe_set_mdio_speed - Set MDIO clock speed
+ * @hw: pointer to hardware structure
+ */
+static void ixgbe_set_mdio_speed(struct ixgbe_hw *hw)
+{
+        u32 hlreg0;
+
+        switch (hw->device_id) {
+        case IXGBE_DEV_ID_X550EM_X_10G_T:
+        case IXGBE_DEV_ID_X550EM_A_SFP:
+                /* Config MDIO clock speed before the first MDIO PHY access */
+                hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
+                hlreg0 &= ~IXGBE_HLREG0_MDCSPD;
+                IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
+                break;
+        default:
+                break;
+        }
+}
+
 /**  ixgbe_reset_hw_X550em - Perform hardware reset
  **  @hw: pointer to hardware structure
  **
@@ -2093,7 +2538,6 @@ static s32 ixgbe_reset_hw_X550em(struct ixgbe_hw *hw)
         s32 status;
         u32 ctrl = 0;
         u32 i;
-        u32 hlreg0;
         bool link_up = false;
 
         /* Call adapter stop to disable Tx/Rx and clear interrupts */
@@ -2179,11 +2623,7 @@ mac_reset_top:
         hw->mac.num_rar_entries = 128;
         hw->mac.ops.init_rx_addrs(hw);
 
-        if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) {
-                hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
-                hlreg0 &= ~IXGBE_HLREG0_MDCSPD;
-                IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
-        }
+        ixgbe_set_mdio_speed(hw);
 
         if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP)
                 ixgbe_setup_mux_ctl(hw);
@@ -2296,6 +2736,110 @@ static void ixgbe_release_swfw_sync_X550em(struct ixgbe_hw *hw, u32 mask)
         ixgbe_release_swfw_sync_X540(hw, mask);
 }
 
+/**
+ * ixgbe_acquire_swfw_sync_x550em_a - Acquire SWFW semaphore
+ * @hw: pointer to hardware structure
+ * @mask: Mask to specify which semaphore to acquire
+ *
+ * Acquires the SWFW semaphore and get the shared PHY token as needed
+ */
+static s32 ixgbe_acquire_swfw_sync_x550em_a(struct ixgbe_hw *hw, u32 mask)
+{
+        u32 hmask = mask & ~IXGBE_GSSR_TOKEN_SM;
+        int retries = FW_PHY_TOKEN_RETRIES;
+        s32 status;
+
+        while (--retries) {
+                status = 0;
+                if (hmask)
+                        status = ixgbe_acquire_swfw_sync_X540(hw, hmask);
+                if (status)
+                        return status;
+                if (!(mask & IXGBE_GSSR_TOKEN_SM))
+                        return 0;
+
+                status = ixgbe_get_phy_token(hw);
+                if (!status)
+                        return 0;
+                if (hmask)
+                        ixgbe_release_swfw_sync_X540(hw, hmask);
+                if (status != IXGBE_ERR_TOKEN_RETRY)
+                        return status;
+                udelay(FW_PHY_TOKEN_DELAY * 1000);
+        }
+
+        return status;
+}
+
+/**
+ * ixgbe_release_swfw_sync_x550em_a - Release SWFW semaphore
+ * @hw: pointer to hardware structure
+ * @mask: Mask to specify which semaphore to release
+ *
+ * Release the SWFW semaphore and puts the shared PHY token as needed
+ */
+static void ixgbe_release_swfw_sync_x550em_a(struct ixgbe_hw *hw, u32 mask)
+{
+        u32 hmask = mask & ~IXGBE_GSSR_TOKEN_SM;
+
+        if (mask & IXGBE_GSSR_TOKEN_SM)
+                ixgbe_put_phy_token(hw);
+
+        if (hmask)
+                ixgbe_release_swfw_sync_X540(hw, hmask);
+}
+
+/**
+ * ixgbe_read_phy_reg_x550a - Reads specified PHY register
+ * @hw: pointer to hardware structure
+ * @reg_addr: 32 bit address of PHY register to read
+ * @phy_data: Pointer to read data from PHY register
+ *
+ * Reads a value from a specified PHY register using the SWFW lock and PHY
+ * Token. The PHY Token is needed since the MDIO is shared between to MAC
+ * instances.
+ */
+static s32 ixgbe_read_phy_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
+                                    u32 device_type, u16 *phy_data)
+{
+        u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
+        s32 status;
+
+        if (hw->mac.ops.acquire_swfw_sync(hw, mask))
+                return IXGBE_ERR_SWFW_SYNC;
+
+        status = hw->phy.ops.read_reg_mdi(hw, reg_addr, device_type, phy_data);
+
+        hw->mac.ops.release_swfw_sync(hw, mask);
+
+        return status;
+}
+
+/**
+ * ixgbe_write_phy_reg_x550a - Writes specified PHY register
+ * @hw: pointer to hardware structure
+ * @reg_addr: 32 bit PHY register to write
+ * @device_type: 5 bit device type
+ * @phy_data: Data to write to the PHY register
+ *
+ * Writes a value to specified PHY register using the SWFW lock and PHY Token.
+ * The PHY Token is needed since the MDIO is shared between to MAC instances.
+ */
+static s32 ixgbe_write_phy_reg_x550a(struct ixgbe_hw *hw, u32 reg_addr,
+                                     u32 device_type, u16 phy_data)
+{
+        u32 mask = hw->phy.phy_semaphore_mask | IXGBE_GSSR_TOKEN_SM;
+        s32 status;
+
+        if (hw->mac.ops.acquire_swfw_sync(hw, mask))
+                return IXGBE_ERR_SWFW_SYNC;
+
+        status = ixgbe_write_phy_reg_mdi(hw, reg_addr, device_type, phy_data);
+        hw->mac.ops.release_swfw_sync(hw, mask);
+
+        return status;
+}
+
 #define X550_COMMON_MAC \
         .init_hw                        = &ixgbe_init_hw_generic, \
         .start_hw                       = &ixgbe_start_hw_X540, \
@@ -2337,12 +2881,10 @@ static void ixgbe_release_swfw_sync_X550em(struct ixgbe_hw *hw, u32 mask)
         .enable_rx_buff                 = &ixgbe_enable_rx_buff_generic, \
         .get_thermal_sensor_data        = NULL, \
         .init_thermal_sensor_thresh     = NULL, \
-        .prot_autoc_read                = &prot_autoc_read_generic, \
-        .prot_autoc_write               = &prot_autoc_write_generic, \
         .enable_rx                      = &ixgbe_enable_rx_generic, \
         .disable_rx                     = &ixgbe_disable_rx_x550, \
 
-static struct ixgbe_mac_operations mac_ops_X550 = {
+static const struct ixgbe_mac_operations mac_ops_X550 = {
         X550_COMMON_MAC
         .reset_hw               = &ixgbe_reset_hw_X540,
         .get_media_type         = &ixgbe_get_media_type_X540,
@@ -2354,9 +2896,13 @@ static struct ixgbe_mac_operations mac_ops_X550 = {
         .setup_sfp              = NULL,
         .acquire_swfw_sync      = &ixgbe_acquire_swfw_sync_X540,
         .release_swfw_sync      = &ixgbe_release_swfw_sync_X540,
+        .init_swfw_sync         = &ixgbe_init_swfw_sync_X540,
+        .prot_autoc_read        = prot_autoc_read_generic,
+        .prot_autoc_write       = prot_autoc_write_generic,
+        .setup_fc               = ixgbe_setup_fc_generic,
 };
 
-static struct ixgbe_mac_operations mac_ops_X550EM_x = {
+static const struct ixgbe_mac_operations mac_ops_X550EM_x = {
         X550_COMMON_MAC
         .reset_hw               = &ixgbe_reset_hw_X550em,
         .get_media_type         = &ixgbe_get_media_type_X550em,
@@ -2368,6 +2914,27 @@ static struct ixgbe_mac_operations mac_ops_X550EM_x = {
         .setup_sfp              = ixgbe_setup_sfp_modules_X550em,
         .acquire_swfw_sync      = &ixgbe_acquire_swfw_sync_X550em,
         .release_swfw_sync      = &ixgbe_release_swfw_sync_X550em,
+        .init_swfw_sync         = &ixgbe_init_swfw_sync_X540,
+        .setup_fc               = NULL, /* defined later */
+        .read_iosf_sb_reg       = ixgbe_read_iosf_sb_reg_x550,
+        .write_iosf_sb_reg      = ixgbe_write_iosf_sb_reg_x550,
+};
+
+static struct ixgbe_mac_operations mac_ops_x550em_a = {
+        X550_COMMON_MAC
+        .reset_hw               = ixgbe_reset_hw_X550em,
+        .get_media_type         = ixgbe_get_media_type_X550em,
+        .get_san_mac_addr       = NULL,
+        .get_wwn_prefix         = NULL,
+        .setup_link             = NULL, /* defined later */
+        .get_link_capabilities  = ixgbe_get_link_capabilities_X550em,
+        .get_bus_info           = ixgbe_get_bus_info_X550em,
+        .setup_sfp              = ixgbe_setup_sfp_modules_X550em,
+        .acquire_swfw_sync      = ixgbe_acquire_swfw_sync_x550em_a,
+        .release_swfw_sync      = ixgbe_release_swfw_sync_x550em_a,
+        .setup_fc               = ixgbe_setup_fc_generic,
+        .read_iosf_sb_reg       = ixgbe_read_iosf_sb_reg_x550a,
+        .write_iosf_sb_reg      = ixgbe_write_iosf_sb_reg_x550a,
 };
 
 #define X550_COMMON_EEP \
@@ -2379,12 +2946,12 @@ static struct ixgbe_mac_operations mac_ops_X550EM_x = {
         .update_checksum        = &ixgbe_update_eeprom_checksum_X550, \
         .calc_checksum          = &ixgbe_calc_eeprom_checksum_X550, \
 
-static struct ixgbe_eeprom_operations eeprom_ops_X550 = {
+static const struct ixgbe_eeprom_operations eeprom_ops_X550 = {
         X550_COMMON_EEP
         .init_params            = &ixgbe_init_eeprom_params_X550,
 };
 
-static struct ixgbe_eeprom_operations eeprom_ops_X550EM_x = {
+static const struct ixgbe_eeprom_operations eeprom_ops_X550EM_x = {
         X550_COMMON_EEP
         .init_params            = &ixgbe_init_eeprom_params_X540,
 };
@@ -2398,23 +2965,25 @@ static struct ixgbe_eeprom_operations eeprom_ops_X550EM_x = {
         .read_i2c_sff8472       = &ixgbe_read_i2c_sff8472_generic, \
         .read_i2c_eeprom        = &ixgbe_read_i2c_eeprom_generic, \
         .write_i2c_eeprom       = &ixgbe_write_i2c_eeprom_generic, \
-        .read_reg               = &ixgbe_read_phy_reg_generic, \
-        .write_reg              = &ixgbe_write_phy_reg_generic, \
         .setup_link             = &ixgbe_setup_phy_link_generic, \
         .set_phy_power          = NULL, \
         .check_overtemp         = &ixgbe_tn_check_overtemp, \
         .get_firmware_version   = &ixgbe_get_phy_firmware_version_generic,
 
-static struct ixgbe_phy_operations phy_ops_X550 = {
+static const struct ixgbe_phy_operations phy_ops_X550 = {
         X550_COMMON_PHY
         .init                   = NULL,
         .identify               = &ixgbe_identify_phy_generic,
+        .read_reg               = &ixgbe_read_phy_reg_generic,
+        .write_reg              = &ixgbe_write_phy_reg_generic,
 };
 
-static struct ixgbe_phy_operations phy_ops_X550EM_x = {
+static const struct ixgbe_phy_operations phy_ops_X550EM_x = {
         X550_COMMON_PHY
         .init                   = &ixgbe_init_phy_ops_X550em,
         .identify               = &ixgbe_identify_phy_x550em,
+        .read_reg               = &ixgbe_read_phy_reg_generic,
+        .write_reg              = &ixgbe_write_phy_reg_generic,
         .read_i2c_combined      = &ixgbe_read_i2c_combined_generic,
         .write_i2c_combined     = &ixgbe_write_i2c_combined_generic,
         .read_i2c_combined_unlocked = &ixgbe_read_i2c_combined_generic_unlocked,
@@ -2422,6 +2991,14 @@ static struct ixgbe_phy_operations phy_ops_X550EM_x = {
                                      &ixgbe_write_i2c_combined_generic_unlocked,
 };
 
+static const struct ixgbe_phy_operations phy_ops_x550em_a = {
+        X550_COMMON_PHY
+        .init                   = &ixgbe_init_phy_ops_X550em,
+        .identify               = &ixgbe_identify_phy_x550em,
+        .read_reg               = &ixgbe_read_phy_reg_x550a,
+        .write_reg              = &ixgbe_write_phy_reg_x550a,
+};
+
 static const u32 ixgbe_mvals_X550[IXGBE_MVALS_IDX_LIMIT] = {
         IXGBE_MVALS_INIT(X550)
 };
@@ -2430,7 +3007,11 @@ static const u32 ixgbe_mvals_X550EM_x[IXGBE_MVALS_IDX_LIMIT] = {
         IXGBE_MVALS_INIT(X550EM_x)
 };
 
-struct ixgbe_info ixgbe_X550_info = {
+static const u32 ixgbe_mvals_x550em_a[IXGBE_MVALS_IDX_LIMIT] = {
+        IXGBE_MVALS_INIT(X550EM_a)
+};
+
+const struct ixgbe_info ixgbe_X550_info = {
         .mac                    = ixgbe_mac_X550,
         .get_invariants         = &ixgbe_get_invariants_X540,
         .mac_ops                = &mac_ops_X550,
@@ -2440,7 +3021,7 @@ struct ixgbe_info ixgbe_X550_info = {
         .mvals                  = ixgbe_mvals_X550,
 };
 
-struct ixgbe_info ixgbe_X550EM_x_info = {
+const struct ixgbe_info ixgbe_X550EM_x_info = {
         .mac                    = ixgbe_mac_X550EM_x,
         .get_invariants         = &ixgbe_get_invariants_X550_x,
         .mac_ops                = &mac_ops_X550EM_x,
@@ -2449,3 +3030,13 @@ struct ixgbe_info ixgbe_X550EM_x_info = {
         .mbx_ops                = &mbx_ops_generic,
         .mvals                  = ixgbe_mvals_X550EM_x,
 };
+
+const struct ixgbe_info ixgbe_x550em_a_info = {
+        .mac                    = ixgbe_mac_x550em_a,
+        .get_invariants         = &ixgbe_get_invariants_X550_x,
+        .mac_ops                = &mac_ops_x550em_a,
+        .eeprom_ops             = &eeprom_ops_X550EM_x,
+        .phy_ops                = &phy_ops_x550em_a,
+        .mbx_ops                = &mbx_ops_generic,
+        .mvals                  = ixgbe_mvals_x550em_a,
+};
diff --git a/drivers/net/ethernet/intel/ixgbevf/ethtool.c b/drivers/net/ethernet/intel/ixgbevf/ethtool.c
index c48aef613b0a..d7aa4b203f40 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ethtool.c
@@ -680,7 +680,7 @@ static void ixgbevf_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        ixgbevf_close(netdev);
                 else
                         ixgbevf_reset(adapter);
 
@@ -692,7 +692,7 @@ static void ixgbevf_diag_test(struct net_device *netdev,
 
                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
                 if (if_running)
-                        dev_open(netdev);
+                        ixgbevf_open(netdev);
         } else {
                 hw_dbg(&adapter->hw, "online testing starting\n");
                 /* Online tests */
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
index 68ec7daa04fd..5ac60eefb0cd 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
@@ -403,13 +403,6 @@ struct ixgbevf_adapter {
         u32 alloc_rx_page_failed;
         u32 alloc_rx_buff_failed;
 
-        /* Some features need tri-state capability,
-         * thus the additional *_CAPABLE flags.
-         */
-        u32 flags;
-#define IXGBEVF_FLAG_RESET_REQUESTED            (u32)(1)
-#define IXGBEVF_FLAG_QUEUE_RESET_REQUESTED      (u32)(1 << 2)
-
         struct msix_entry *msix_entries;
 
         /* OS defined structs */
@@ -461,6 +454,8 @@ enum ixbgevf_state_t {
         __IXGBEVF_REMOVING,
         __IXGBEVF_SERVICE_SCHED,
         __IXGBEVF_SERVICE_INITED,
+        __IXGBEVF_RESET_REQUESTED,
+        __IXGBEVF_QUEUE_RESET_REQUESTED,
 };
 
 enum ixgbevf_boards {
@@ -486,6 +481,8 @@ extern const struct ixgbe_mbx_operations ixgbevf_mbx_ops;
 extern const char ixgbevf_driver_name[];
 extern const char ixgbevf_driver_version[];
 
+int ixgbevf_open(struct net_device *netdev);
+int ixgbevf_close(struct net_device *netdev);
 void ixgbevf_up(struct ixgbevf_adapter *adapter);
 void ixgbevf_down(struct ixgbevf_adapter *adapter);
 void ixgbevf_reinit_locked(struct ixgbevf_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 0ea14c0a2e74..007cbe094990 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -268,7 +268,7 @@ static void ixgbevf_tx_timeout_reset(struct ixgbevf_adapter *adapter)
 {
         /* Do the reset outside of interrupt context */
         if (!test_bit(__IXGBEVF_DOWN, &adapter->state)) {
-                adapter->flags |= IXGBEVF_FLAG_RESET_REQUESTED;
+                set_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state);
                 ixgbevf_service_event_schedule(adapter);
         }
 }
@@ -288,9 +288,10 @@ static void ixgbevf_tx_timeout(struct net_device *netdev)
  * ixgbevf_clean_tx_irq - Reclaim resources after transmit completes
  * @q_vector: board private structure
  * @tx_ring: tx ring to clean
+ * @napi_budget: Used to determine if we are in netpoll
  **/
 static bool ixgbevf_clean_tx_irq(struct ixgbevf_q_vector *q_vector,
-                                 struct ixgbevf_ring *tx_ring)
+                                 struct ixgbevf_ring *tx_ring, int napi_budget)
 {
         struct ixgbevf_adapter *adapter = q_vector->adapter;
         struct ixgbevf_tx_buffer *tx_buffer;
@@ -328,7 +329,7 @@ static bool ixgbevf_clean_tx_irq(struct ixgbevf_q_vector *q_vector,
                 total_packets += tx_buffer->gso_segs;
 
                 /* free the skb */
-                dev_kfree_skb_any(tx_buffer->skb);
+                napi_consume_skb(tx_buffer->skb, napi_budget);
 
                 /* unmap skb header data */
                 dma_unmap_single(tx_ring->dev,
@@ -1013,8 +1014,10 @@ static int ixgbevf_poll(struct napi_struct *napi, int budget)
         int per_ring_budget, work_done = 0;
         bool clean_complete = true;
 
-        ixgbevf_for_each_ring(ring, q_vector->tx)
-                clean_complete &= ixgbevf_clean_tx_irq(q_vector, ring);
+        ixgbevf_for_each_ring(ring, q_vector->tx) {
+                if (!ixgbevf_clean_tx_irq(q_vector, ring, budget))
+                        clean_complete = false;
+        }
 
         if (budget <= 0)
                 return budget;
@@ -1035,7 +1038,8 @@ static int ixgbevf_poll(struct napi_struct *napi, int budget)
                 int cleaned = ixgbevf_clean_rx_irq(q_vector, ring,
                                                    per_ring_budget);
                 work_done += cleaned;
-                clean_complete &= (cleaned < per_ring_budget);
+                if (cleaned >= per_ring_budget)
+                        clean_complete = false;
         }
 
 #ifdef CONFIG_NET_RX_BUSY_POLL
@@ -1984,7 +1988,7 @@ static int ixgbevf_configure_dcb(struct ixgbevf_adapter *adapter)
                 hw->mbx.timeout = 0;
 
                 /* wait for watchdog to come around and bail us out */
-                adapter->flags |= IXGBEVF_FLAG_QUEUE_RESET_REQUESTED;
+                set_bit(__IXGBEVF_QUEUE_RESET_REQUESTED, &adapter->state);
         }
 
         return 0;
@@ -2749,11 +2753,9 @@ static void ixgbevf_service_timer(unsigned long data)
 
 static void ixgbevf_reset_subtask(struct ixgbevf_adapter *adapter)
 {
-        if (!(adapter->flags & IXGBEVF_FLAG_RESET_REQUESTED))
+        if (!test_and_clear_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state))
                 return;
 
-        adapter->flags &= ~IXGBEVF_FLAG_RESET_REQUESTED;
-
         /* If we're already down or resetting, just bail */
         if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
             test_bit(__IXGBEVF_RESETTING, &adapter->state))
@@ -2821,7 +2823,7 @@ static void ixgbevf_watchdog_update_link(struct ixgbevf_adapter *adapter)
 
         /* if check for link returns error we will need to reset */
         if (err && time_after(jiffies, adapter->last_reset + (10 * HZ))) {
-                adapter->flags |= IXGBEVF_FLAG_RESET_REQUESTED;
+                set_bit(__IXGBEVF_RESET_REQUESTED, &adapter->state);
                 link_up = false;
         }
 
@@ -3122,7 +3124,7 @@ static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter)
  * handler is registered with the OS, the watchdog timer is started,
  * and the stack is notified that the interface is ready.
  **/
-static int ixgbevf_open(struct net_device *netdev)
+int ixgbevf_open(struct net_device *netdev)
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
@@ -3205,7 +3207,7 @@ err_setup_reset:
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int ixgbevf_close(struct net_device *netdev)
+int ixgbevf_close(struct net_device *netdev)
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 
@@ -3222,11 +3224,10 @@ static void ixgbevf_queue_reset_subtask(struct ixgbevf_adapter *adapter)
 {
         struct net_device *dev = adapter->netdev;
 
-        if (!(adapter->flags & IXGBEVF_FLAG_QUEUE_RESET_REQUESTED))
+        if (!test_and_clear_bit(__IXGBEVF_QUEUE_RESET_REQUESTED,
+                                &adapter->state))
                 return;
 
-        adapter->flags &= ~IXGBEVF_FLAG_QUEUE_RESET_REQUESTED;
-
         /* if interface is down do nothing */
         if (test_bit(__IXGBEVF_DOWN, &adapter->state) ||
             test_bit(__IXGBEVF_RESETTING, &adapter->state))
@@ -3337,76 +3338,55 @@ static int ixgbevf_tso(struct ixgbevf_ring *tx_ring,
         return 1;
 }
 
+static inline bool ixgbevf_ipv6_csum_is_sctp(struct sk_buff *skb)
+{
+        unsigned int offset = 0;
+
+        ipv6_find_hdr(skb, &offset, IPPROTO_SCTP, NULL, NULL);
+
+        return offset == skb_checksum_start_offset(skb);
+}
+
 static void ixgbevf_tx_csum(struct ixgbevf_ring *tx_ring,
                             struct ixgbevf_tx_buffer *first)
 {
         struct sk_buff *skb = first->skb;
         u32 vlan_macip_lens = 0;
-        u32 mss_l4len_idx = 0;
         u32 type_tucmd = 0;
 
-        if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                u8 l4_hdr = 0;
-                __be16 frag_off;
-
-                switch (first->protocol) {
-                case htons(ETH_P_IP):
-                        vlan_macip_lens |= skb_network_header_len(skb);
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_IPV4;
-                        l4_hdr = ip_hdr(skb)->protocol;
-                        break;
-                case htons(ETH_P_IPV6):
-                        vlan_macip_lens |= skb_network_header_len(skb);
-                        l4_hdr = ipv6_hdr(skb)->nexthdr;
-                        if (likely(skb_network_header_len(skb) ==
-                                   sizeof(struct ipv6hdr)))
-                                break;
-                        ipv6_skip_exthdr(skb, skb_network_offset(skb) +
-                                              sizeof(struct ipv6hdr),
-                                         &l4_hdr, &frag_off);
-                        if (unlikely(frag_off))
-                                l4_hdr = NEXTHDR_FRAGMENT;
-                        break;
-                default:
-                        break;
-                }
+        if (skb->ip_summed != CHECKSUM_PARTIAL)
+                goto no_csum;
 
-                switch (l4_hdr) {
-                case IPPROTO_TCP:
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_L4T_TCP;
-                        mss_l4len_idx = tcp_hdrlen(skb) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
-                        break;
-                case IPPROTO_SCTP:
-                        type_tucmd |= IXGBE_ADVTXD_TUCMD_L4T_SCTP;
-                        mss_l4len_idx = sizeof(struct sctphdr) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
-                        break;
-                case IPPROTO_UDP:
-                        mss_l4len_idx = sizeof(struct udphdr) <<
-                                        IXGBE_ADVTXD_L4LEN_SHIFT;
+        switch (skb->csum_offset) {
+        case offsetof(struct tcphdr, check):
+                type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_TCP;
+                /* fall through */
+        case offsetof(struct udphdr, check):
+                break;
+        case offsetof(struct sctphdr, checksum):
+                /* validate that this is actually an SCTP request */
+                if (((first->protocol == htons(ETH_P_IP)) &&
+                     (ip_hdr(skb)->protocol == IPPROTO_SCTP)) ||
+                    ((first->protocol == htons(ETH_P_IPV6)) &&
+                     ixgbevf_ipv6_csum_is_sctp(skb))) {
+                        type_tucmd = IXGBE_ADVTXD_TUCMD_L4T_SCTP;
                         break;
-                default:
-                        if (unlikely(net_ratelimit())) {
-                                dev_warn(tx_ring->dev,
-                                         "partial checksum, l3 proto=%x, l4 proto=%x\n",
-                                         first->protocol, l4_hdr);
-                        }
-                        skb_checksum_help(skb);
-                        goto no_csum;
                 }
-
-                /* update TX checksum flag */
-                first->tx_flags |= IXGBE_TX_FLAGS_CSUM;
+                /* fall through */
+        default:
+                skb_checksum_help(skb);
+                goto no_csum;
         }
-
+        /* update TX checksum flag */
+        first->tx_flags |= IXGBE_TX_FLAGS_CSUM;
+        vlan_macip_lens = skb_checksum_start_offset(skb) -
+                          skb_network_offset(skb);
 no_csum:
         /* vlan_macip_lens: MACLEN, VLAN tag */
         vlan_macip_lens |= skb_network_offset(skb) << IXGBE_ADVTXD_MACLEN_SHIFT;
         vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
 
-        ixgbevf_tx_ctxtdesc(tx_ring, vlan_macip_lens,
-                            type_tucmd, mss_l4len_idx);
+        ixgbevf_tx_ctxtdesc(tx_ring, vlan_macip_lens, type_tucmd, 0);
 }
 
 static __le32 ixgbevf_tx_cmd_type(u32 tx_flags)
@@ -3692,19 +3672,23 @@ static int ixgbevf_set_mac(struct net_device *netdev, void *p)
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
         struct sockaddr *addr = p;
+        int err;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
-        ether_addr_copy(netdev->dev_addr, addr->sa_data);
-        ether_addr_copy(hw->mac.addr, addr->sa_data);
-
         spin_lock_bh(&adapter->mbx_lock);
 
-        hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0);
+        err = hw->mac.ops.set_rar(hw, 0, addr->sa_data, 0);
 
         spin_unlock_bh(&adapter->mbx_lock);
 
+        if (err)
+                return -EPERM;
+
+        ether_addr_copy(hw->mac.addr, addr->sa_data);
+        ether_addr_copy(netdev->dev_addr, addr->sa_data);
+
         return 0;
 }
 
@@ -4009,22 +3993,25 @@ static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
 
         netdev->hw_features = NETIF_F_SG |
-                              NETIF_F_IP_CSUM |
-                              NETIF_F_IPV6_CSUM |
                               NETIF_F_TSO |
                               NETIF_F_TSO6 |
-                              NETIF_F_RXCSUM;
+                              NETIF_F_RXCSUM |
+                              NETIF_F_HW_CSUM |
+                              NETIF_F_SCTP_CRC;
 
         netdev->features = netdev->hw_features |
                            NETIF_F_HW_VLAN_CTAG_TX |
                            NETIF_F_HW_VLAN_CTAG_RX |
                            NETIF_F_HW_VLAN_CTAG_FILTER;
 
-        netdev->vlan_features |= NETIF_F_TSO |
+        netdev->vlan_features |= NETIF_F_SG |
+                                 NETIF_F_TSO |
                                  NETIF_F_TSO6 |
-                                 NETIF_F_IP_CSUM |
-                                 NETIF_F_IPV6_CSUM |
-                                 NETIF_F_SG;
+                                 NETIF_F_HW_CSUM |
+                                 NETIF_F_SCTP_CRC;
+
+        netdev->mpls_features |= NETIF_F_HW_CSUM;
+        netdev->hw_enc_features |= NETIF_F_HW_CSUM;
 
         if (pci_using_dac)
                 netdev->features |= NETIF_F_HIGHDMA;
diff --git a/drivers/net/ethernet/intel/ixgbevf/vf.c b/drivers/net/ethernet/intel/ixgbevf/vf.c
index 61a98f4c5746..4d613a4f2a7f 100644
--- a/drivers/net/ethernet/intel/ixgbevf/vf.c
+++ b/drivers/net/ethernet/intel/ixgbevf/vf.c
@@ -408,8 +408,10 @@ static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
 
         /* if nacked the address was rejected, use "perm_addr" */
         if (!ret_val &&
-            (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK)))
+            (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) {
                 ixgbevf_get_mac_addr_vf(hw, hw->mac.addr);
+                return IXGBE_ERR_MBX;
+        }
 
         return ret_val;
 }
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index 577f7ca7deba..7fc490225da5 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -260,7 +260,6 @@
 
 #define MVNETA_VLAN_TAG_LEN             4
 
-#define MVNETA_CPU_D_CACHE_LINE_SIZE    32
 #define MVNETA_TX_CSUM_DEF_SIZE         1600
 #define MVNETA_TX_CSUM_MAX_SIZE         9800
 #define MVNETA_ACC_MODE_EXT1            1
@@ -300,7 +299,7 @@
 #define MVNETA_RX_PKT_SIZE(mtu) \
         ALIGN((mtu) + MVNETA_MH_SIZE + MVNETA_VLAN_TAG_LEN + \
               ETH_HLEN + ETH_FCS_LEN,                        \
-              MVNETA_CPU_D_CACHE_LINE_SIZE)
+              cache_line_size())
 
 #define IS_TSO_HEADER(txq, addr) \
         ((addr >= txq->tso_hdrs_phys) && \
@@ -2764,9 +2763,6 @@ static int mvneta_rxq_init(struct mvneta_port *pp,
         if (rxq->descs == NULL)
                 return -ENOMEM;
 
-        BUG_ON(rxq->descs !=
-               PTR_ALIGN(rxq->descs, MVNETA_CPU_D_CACHE_LINE_SIZE));
-
         rxq->last_desc = rxq->size - 1;
 
         /* Set Rx descriptors queue starting address */
@@ -2837,10 +2833,6 @@ static int mvneta_txq_init(struct mvneta_port *pp,
         if (txq->descs == NULL)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(txq->descs !=
-               PTR_ALIGN(txq->descs, MVNETA_CPU_D_CACHE_LINE_SIZE));
-
         txq->last_desc = txq->size - 1;
 
         /* Set maximum bandwidth for enabled TXQs */
@@ -3050,6 +3042,20 @@ static int mvneta_check_mtu_valid(struct net_device *dev, int mtu)
         return mtu;
 }
 
+static void mvneta_percpu_enable(void *arg)
+{
+        struct mvneta_port *pp = arg;
+
+        enable_percpu_irq(pp->dev->irq, IRQ_TYPE_NONE);
+}
+
+static void mvneta_percpu_disable(void *arg)
+{
+        struct mvneta_port *pp = arg;
+
+        disable_percpu_irq(pp->dev->irq);
+}
+
 /* Change the device mtu */
 static int mvneta_change_mtu(struct net_device *dev, int mtu)
 {
@@ -3074,6 +3080,7 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu)
          * reallocation of the queues
          */
         mvneta_stop_dev(pp);
+        on_each_cpu(mvneta_percpu_disable, pp, true);
 
         mvneta_cleanup_txqs(pp);
         mvneta_cleanup_rxqs(pp);
@@ -3097,6 +3104,7 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu)
                 return ret;
         }
 
+        on_each_cpu(mvneta_percpu_enable, pp, true);
         mvneta_start_dev(pp);
         mvneta_port_up(pp);
 
@@ -3250,20 +3258,6 @@ static void mvneta_mdio_remove(struct mvneta_port *pp)
         pp->phy_dev = NULL;
 }
 
-static void mvneta_percpu_enable(void *arg)
-{
-        struct mvneta_port *pp = arg;
-
-        enable_percpu_irq(pp->dev->irq, IRQ_TYPE_NONE);
-}
-
-static void mvneta_percpu_disable(void *arg)
-{
-        struct mvneta_port *pp = arg;
-
-        disable_percpu_irq(pp->dev->irq);
-}
-
 /* Electing a CPU must be done in an atomic way: it should be done
  * after or before the removal/insertion of a CPU and this function is
  * not reentrant.
diff --git a/drivers/net/ethernet/marvell/mvpp2.c b/drivers/net/ethernet/marvell/mvpp2.c
index c797971aefab..868a957f24bb 100644
--- a/drivers/net/ethernet/marvell/mvpp2.c
+++ b/drivers/net/ethernet/marvell/mvpp2.c
@@ -321,7 +321,6 @@
 /* Lbtd 802.3 type */
 #define MVPP2_IP_LBDT_TYPE              0xfffa
 
-#define MVPP2_CPU_D_CACHE_LINE_SIZE     32
 #define MVPP2_TX_CSUM_MAX_SIZE          9800
 
 /* Timeout constants */
@@ -377,7 +376,7 @@
 
 #define MVPP2_RX_PKT_SIZE(mtu) \
         ALIGN((mtu) + MVPP2_MH_SIZE + MVPP2_VLAN_TAG_LEN + \
-              ETH_HLEN + ETH_FCS_LEN, MVPP2_CPU_D_CACHE_LINE_SIZE)
+              ETH_HLEN + ETH_FCS_LEN, cache_line_size())
 
 #define MVPP2_RX_BUF_SIZE(pkt_size)     ((pkt_size) + NET_SKB_PAD)
 #define MVPP2_RX_TOTAL_SIZE(buf_size)   ((buf_size) + MVPP2_SKB_SHINFO_SIZE)
@@ -4493,10 +4492,6 @@ static int mvpp2_aggr_txq_init(struct platform_device *pdev,
         if (!aggr_txq->descs)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(aggr_txq->descs !=
-               PTR_ALIGN(aggr_txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         aggr_txq->last_desc = aggr_txq->size - 1;
 
         /* Aggr TXQ no reset WA */
@@ -4526,9 +4521,6 @@ static int mvpp2_rxq_init(struct mvpp2_port *port,
         if (!rxq->descs)
                 return -ENOMEM;
 
-        BUG_ON(rxq->descs !=
-               PTR_ALIGN(rxq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         rxq->last_desc = rxq->size - 1;
 
         /* Zero occupied and non-occupied counters - direct access */
@@ -4616,10 +4608,6 @@ static int mvpp2_txq_init(struct mvpp2_port *port,
         if (!txq->descs)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(txq->descs !=
-               PTR_ALIGN(txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         txq->last_desc = txq->size - 1;
 
         /* Set Tx descriptors queue starting address - indirect access */
@@ -6059,8 +6047,10 @@ static int mvpp2_port_init(struct mvpp2_port *port)
 
                 /* Map physical Rx queue to port's logical Rx queue */
                 rxq = devm_kzalloc(dev, sizeof(*rxq), GFP_KERNEL);
-                if (!rxq)
+                if (!rxq) {
+                        err = -ENOMEM;
                         goto err_free_percpu;
+                }
                 /* Map this Rx queue to a physical queue */
                 rxq->id = port->first_rxq + queue;
                 rxq->port = port->id;
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 7f2126b6a179..e0b68afea56e 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -1690,8 +1690,8 @@ static int mtk_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         eth->base = devm_ioremap_resource(&pdev->dev, res);
-        if (!eth->base)
-                return -EADDRNOTAVAIL;
+        if (IS_ERR(eth->base))
+                return PTR_ERR(eth->base);
 
         spin_lock_init(&eth->page_lock);
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/mcg.c b/drivers/net/ethernet/mellanox/mlx4/mcg.c
index 42d8de892bfe..6aa73972d478 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mcg.c
+++ b/drivers/net/ethernet/mellanox/mlx4/mcg.c
@@ -39,8 +39,6 @@
 
 #include "mlx4.h"
 
-static const u8 zero_gid[16];   /* automatically initialized to 0 */
-
 int mlx4_get_mgm_entry_size(struct mlx4_dev *dev)
 {
         return 1 << dev->oper_log_mgm_entry_size;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
index 97f5114fc113..eb926e1ee71c 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
@@ -407,6 +407,12 @@ static int mlx5_internal_err_ret_value(struct mlx5_core_dev *dev, u16 op,
 const char *mlx5_command_str(int command)
 {
         switch (command) {
+        case MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT:
+                return "QUERY_HCA_VPORT_CONTEXT";
+
+        case MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT:
+                return "MODIFY_HCA_VPORT_CONTEXT";
+
         case MLX5_CMD_OP_QUERY_HCA_CAP:
                 return "QUERY_HCA_CAP";
 
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fw.c b/drivers/net/ethernet/mellanox/mlx5/core/fw.c
index aa1ab4702385..75c7ae6a5cc4 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/fw.c
@@ -98,88 +98,55 @@ int mlx5_query_hca_caps(struct mlx5_core_dev *dev)
 {
         int err;
 
-        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL, HCA_CAP_OPMOD_GET_CUR);
-        if (err)
-                return err;
-
-        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL, HCA_CAP_OPMOD_GET_MAX);
+        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL);
         if (err)
                 return err;
 
         if (MLX5_CAP_GEN(dev, eth_net_offloads)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ETHERNET_OFFLOADS,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ETHERNET_OFFLOADS,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ETHERNET_OFFLOADS);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, pg)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ODP,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ODP,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ODP);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, atomic)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ATOMIC,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ATOMIC,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ATOMIC);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, roce)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ROCE,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ROCE,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ROCE);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, nic_flow_table)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_FLOW_TABLE,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_FLOW_TABLE,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_FLOW_TABLE);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, vport_group_manager) &&
             MLX5_CAP_GEN(dev, eswitch_flow_table)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH_FLOW_TABLE,
-                                         HCA_CAP_OPMOD_GET_CUR);
-                if (err)
-                        return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH_FLOW_TABLE,
-                                         HCA_CAP_OPMOD_GET_MAX);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH_FLOW_TABLE);
                 if (err)
                         return err;
         }
 
         if (MLX5_CAP_GEN(dev, eswitch_flow_table)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH,
-                                         HCA_CAP_OPMOD_GET_CUR);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH);
                 if (err)
                         return err;
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ESWITCH,
-                                         HCA_CAP_OPMOD_GET_MAX);
+        }
+
+        if (MLX5_CAP_GEN(dev, vector_calc)) {
+                err = mlx5_core_get_caps(dev, MLX5_CAP_VECTOR_CALC);
                 if (err)
                         return err;
         }
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c
index 72a94e72ee25..3f3b2fae4991 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c
@@ -341,8 +341,9 @@ static u16 to_fw_pkey_sz(u32 size)
         }
 }
 
-int mlx5_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type,
-                       enum mlx5_cap_mode cap_mode)
+static int mlx5_core_get_caps_mode(struct mlx5_core_dev *dev,
+                                   enum mlx5_cap_type cap_type,
+                                   enum mlx5_cap_mode cap_mode)
 {
         u8 in[MLX5_ST_SZ_BYTES(query_hca_cap_in)];
         int out_sz = MLX5_ST_SZ_BYTES(query_hca_cap_out);
@@ -392,6 +393,16 @@ query_ex:
         return err;
 }
 
+int mlx5_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type)
+{
+        int ret;
+
+        ret = mlx5_core_get_caps_mode(dev, cap_type, HCA_CAP_OPMOD_GET_CUR);
+        if (ret)
+                return ret;
+        return mlx5_core_get_caps_mode(dev, cap_type, HCA_CAP_OPMOD_GET_MAX);
+}
+
 static int set_caps(struct mlx5_core_dev *dev, void *in, int in_sz, int opmod)
 {
         u32 out[MLX5_ST_SZ_DW(set_hca_cap_out)];
@@ -419,8 +430,7 @@ static int handle_hca_cap_atomic(struct mlx5_core_dev *dev)
         int err;
 
         if (MLX5_CAP_GEN(dev, atomic)) {
-                err = mlx5_core_get_caps(dev, MLX5_CAP_ATOMIC,
-                                         HCA_CAP_OPMOD_GET_CUR);
+                err = mlx5_core_get_caps(dev, MLX5_CAP_ATOMIC);
                 if (err)
                         return err;
         } else {
@@ -462,11 +472,7 @@ static int handle_hca_cap(struct mlx5_core_dev *dev)
         if (!set_ctx)
                 goto query_ex;
 
-        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL, HCA_CAP_OPMOD_GET_MAX);
-        if (err)
-                goto query_ex;
-
-        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL, HCA_CAP_OPMOD_GET_CUR);
+        err = mlx5_core_get_caps(dev, MLX5_CAP_GENERAL);
         if (err)
                 goto query_ex;
 
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vport.c b/drivers/net/ethernet/mellanox/mlx5/core/vport.c
index 90ab09e375b8..bd518405859e 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/vport.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/vport.c
@@ -852,7 +852,8 @@ int mlx5_nic_vport_disable_roce(struct mlx5_core_dev *mdev)
 EXPORT_SYMBOL_GPL(mlx5_nic_vport_disable_roce);
 
 int mlx5_core_query_vport_counter(struct mlx5_core_dev *dev, u8 other_vport,
-                                  u8 port_num, void *out, size_t out_sz)
+                                  int vf, u8 port_num, void *out,
+                                  size_t out_sz)
 {
         int     in_sz = MLX5_ST_SZ_BYTES(query_vport_counter_in);
         int     is_group_manager;
@@ -871,7 +872,7 @@ int mlx5_core_query_vport_counter(struct mlx5_core_dev *dev, u8 other_vport,
         if (other_vport) {
                 if (is_group_manager) {
                         MLX5_SET(query_vport_counter_in, in, other_vport, 1);
-                        MLX5_SET(query_vport_counter_in, in, vport_number, 0);
+                        MLX5_SET(query_vport_counter_in, in, vport_number, vf + 1);
                 } else {
                         err = -EPERM;
                         goto free;
@@ -890,3 +891,70 @@ free:
         return err;
 }
 EXPORT_SYMBOL_GPL(mlx5_core_query_vport_counter);
+
+int mlx5_core_modify_hca_vport_context(struct mlx5_core_dev *dev,
+                                       u8 other_vport, u8 port_num,
+                                       int vf,
+                                       struct mlx5_hca_vport_context *req)
+{
+        int in_sz = MLX5_ST_SZ_BYTES(modify_hca_vport_context_in);
+        u8 out[MLX5_ST_SZ_BYTES(modify_hca_vport_context_out)];
+        int is_group_manager;
+        void *in;
+        int err;
+        void *ctx;
+
+        mlx5_core_dbg(dev, "vf %d\n", vf);
+        is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
+        in = kzalloc(in_sz, GFP_KERNEL);
+        if (!in)
+                return -ENOMEM;
+
+        memset(out, 0, sizeof(out));
+        MLX5_SET(modify_hca_vport_context_in, in, opcode, MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT);
+        if (other_vport) {
+                if (is_group_manager) {
+                        MLX5_SET(modify_hca_vport_context_in, in, other_vport, 1);
+                        MLX5_SET(modify_hca_vport_context_in, in, vport_number, vf);
+                } else {
+                        err = -EPERM;
+                        goto ex;
+                }
+        }
+
+        if (MLX5_CAP_GEN(dev, num_ports) > 1)
+                MLX5_SET(modify_hca_vport_context_in, in, port_num, port_num);
+
+        ctx = MLX5_ADDR_OF(modify_hca_vport_context_in, in, hca_vport_context);
+        MLX5_SET(hca_vport_context, ctx, field_select, req->field_select);
+        MLX5_SET(hca_vport_context, ctx, sm_virt_aware, req->sm_virt_aware);
+        MLX5_SET(hca_vport_context, ctx, has_smi, req->has_smi);
+        MLX5_SET(hca_vport_context, ctx, has_raw, req->has_raw);
+        MLX5_SET(hca_vport_context, ctx, vport_state_policy, req->policy);
+        MLX5_SET(hca_vport_context, ctx, port_physical_state, req->phys_state);
+        MLX5_SET(hca_vport_context, ctx, vport_state, req->vport_state);
+        MLX5_SET64(hca_vport_context, ctx, port_guid, req->port_guid);
+        MLX5_SET64(hca_vport_context, ctx, node_guid, req->node_guid);
+        MLX5_SET(hca_vport_context, ctx, cap_mask1, req->cap_mask1);
+        MLX5_SET(hca_vport_context, ctx, cap_mask1_field_select, req->cap_mask1_perm);
+        MLX5_SET(hca_vport_context, ctx, cap_mask2, req->cap_mask2);
+        MLX5_SET(hca_vport_context, ctx, cap_mask2_field_select, req->cap_mask2_perm);
+        MLX5_SET(hca_vport_context, ctx, lid, req->lid);
+        MLX5_SET(hca_vport_context, ctx, init_type_reply, req->init_type_reply);
+        MLX5_SET(hca_vport_context, ctx, lmc, req->lmc);
+        MLX5_SET(hca_vport_context, ctx, subnet_timeout, req->subnet_timeout);
+        MLX5_SET(hca_vport_context, ctx, sm_lid, req->sm_lid);
+        MLX5_SET(hca_vport_context, ctx, sm_sl, req->sm_sl);
+        MLX5_SET(hca_vport_context, ctx, qkey_violation_counter, req->qkey_violation_counter);
+        MLX5_SET(hca_vport_context, ctx, pkey_violation_counter, req->pkey_violation_counter);
+        err = mlx5_cmd_exec(dev, in, in_sz, out, sizeof(out));
+        if (err)
+                goto ex;
+
+        err = mlx5_cmd_status_to_err_v2(out);
+
+ex:
+        kfree(in);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx5_core_modify_hca_vport_context);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/Kconfig b/drivers/net/ethernet/mellanox/mlxsw/Kconfig
index 2ad7f67854d5..5989f7cb5462 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/Kconfig
+++ b/drivers/net/ethernet/mellanox/mlxsw/Kconfig
@@ -50,3 +50,11 @@ config MLXSW_SPECTRUM
 
           To compile this driver as a module, choose M here: the
           module will be called mlxsw_spectrum.
+
+config MLXSW_SPECTRUM_DCB
+        bool "Data Center Bridging (DCB) support"
+        depends on MLXSW_SPECTRUM && DCB
+        default y
+        ---help---
+          Say Y here if you want to use Data Center Bridging (DCB) in the
+          driver.
diff --git a/drivers/net/ethernet/mellanox/mlxsw/Makefile b/drivers/net/ethernet/mellanox/mlxsw/Makefile
index 584cac444852..9b5ebf84c051 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/Makefile
+++ b/drivers/net/ethernet/mellanox/mlxsw/Makefile
@@ -8,3 +8,4 @@ mlxsw_switchx2-objs		:= switchx2.o
 obj-$(CONFIG_MLXSW_SPECTRUM)    += mlxsw_spectrum.o
 mlxsw_spectrum-objs             := spectrum.o spectrum_buffers.o \
                                    spectrum_switchdev.o
+mlxsw_spectrum-$(CONFIG_MLXSW_SPECTRUM_DCB)     += spectrum_dcb.o
diff --git a/drivers/net/ethernet/mellanox/mlxsw/core.c b/drivers/net/ethernet/mellanox/mlxsw/core.c
index f69f6280519f..3958195526d1 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/core.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/core.c
@@ -114,6 +114,12 @@ struct mlxsw_core {
         /* driver_priv has to be always the last item */
 };
 
+void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core)
+{
+        return mlxsw_core->driver_priv;
+}
+EXPORT_SYMBOL(mlxsw_core_driver_priv);
+
 struct mlxsw_rx_listener_item {
         struct list_head list;
         struct mlxsw_rx_listener rxl;
@@ -381,7 +387,7 @@ static int __mlxsw_emad_transmit(struct mlxsw_core *mlxsw_core,
 
         mlxsw_core->emad.trans_active = true;
 
-        err = mlxsw_core_skb_transmit(mlxsw_core->driver_priv, skb, tx_info);
+        err = mlxsw_core_skb_transmit(mlxsw_core, skb, tx_info);
         if (err) {
                 dev_err(mlxsw_core->bus_info->dev, "Failed to transmit EMAD (tid=%llx)\n",
                         mlxsw_core->emad.tid);
@@ -795,8 +801,7 @@ static int mlxsw_devlink_port_split(struct devlink *devlink,
                 return -EINVAL;
         if (!mlxsw_core->driver->port_split)
                 return -EOPNOTSUPP;
-        return mlxsw_core->driver->port_split(mlxsw_core->driver_priv,
-                                              port_index, count);
+        return mlxsw_core->driver->port_split(mlxsw_core, port_index, count);
 }
 
 static int mlxsw_devlink_port_unsplit(struct devlink *devlink,
@@ -808,8 +813,7 @@ static int mlxsw_devlink_port_unsplit(struct devlink *devlink,
                 return -EINVAL;
         if (!mlxsw_core->driver->port_unsplit)
                 return -EOPNOTSUPP;
-        return mlxsw_core->driver->port_unsplit(mlxsw_core->driver_priv,
-                                                port_index);
+        return mlxsw_core->driver->port_unsplit(mlxsw_core, port_index);
 }
 
 static const struct devlink_ops mlxsw_devlink_ops = {
@@ -880,8 +884,7 @@ int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
         if (err)
                 goto err_devlink_register;
 
-        err = mlxsw_driver->init(mlxsw_core->driver_priv, mlxsw_core,
-                                 mlxsw_bus_info);
+        err = mlxsw_driver->init(mlxsw_core, mlxsw_bus_info);
         if (err)
                 goto err_driver_init;
 
@@ -892,7 +895,7 @@ int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info,
         return 0;
 
 err_debugfs_init:
-        mlxsw_core->driver->fini(mlxsw_core->driver_priv);
+        mlxsw_core->driver->fini(mlxsw_core);
 err_driver_init:
         devlink_unregister(devlink);
 err_devlink_register:
@@ -918,7 +921,7 @@ void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core)
         struct devlink *devlink = priv_to_devlink(mlxsw_core);
 
         mlxsw_core_debugfs_fini(mlxsw_core);
-        mlxsw_core->driver->fini(mlxsw_core->driver_priv);
+        mlxsw_core->driver->fini(mlxsw_core);
         devlink_unregister(devlink);
         mlxsw_emad_fini(mlxsw_core);
         mlxsw_core->bus->fini(mlxsw_core->bus_priv);
@@ -929,26 +932,17 @@ void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core)
 }
 EXPORT_SYMBOL(mlxsw_core_bus_device_unregister);
 
-static struct mlxsw_core *__mlxsw_core_get(void *driver_priv)
-{
-        return container_of(driver_priv, struct mlxsw_core, driver_priv);
-}
-
-bool mlxsw_core_skb_transmit_busy(void *driver_priv,
+bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core,
                                   const struct mlxsw_tx_info *tx_info)
 {
-        struct mlxsw_core *mlxsw_core = __mlxsw_core_get(driver_priv);
-
         return mlxsw_core->bus->skb_transmit_busy(mlxsw_core->bus_priv,
                                                   tx_info);
 }
 EXPORT_SYMBOL(mlxsw_core_skb_transmit_busy);
 
-int mlxsw_core_skb_transmit(void *driver_priv, struct sk_buff *skb,
+int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
                             const struct mlxsw_tx_info *tx_info)
 {
-        struct mlxsw_core *mlxsw_core = __mlxsw_core_get(driver_priv);
-
         return mlxsw_core->bus->skb_transmit(mlxsw_core->bus_priv, skb,
                                              tx_info);
 }
@@ -1358,6 +1352,28 @@ void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
 }
 EXPORT_SYMBOL(mlxsw_core_lag_mapping_clear);
 
+int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core,
+                         struct mlxsw_core_port *mlxsw_core_port, u8 local_port,
+                         struct net_device *dev, bool split, u32 split_group)
+{
+        struct devlink *devlink = priv_to_devlink(mlxsw_core);
+        struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;
+
+        if (split)
+                devlink_port_split_set(devlink_port, split_group);
+        devlink_port_type_eth_set(devlink_port, dev);
+        return devlink_port_register(devlink, devlink_port, local_port);
+}
+EXPORT_SYMBOL(mlxsw_core_port_init);
+
+void mlxsw_core_port_fini(struct mlxsw_core_port *mlxsw_core_port)
+{
+        struct devlink_port *devlink_port = &mlxsw_core_port->devlink_port;
+
+        devlink_port_unregister(devlink_port);
+}
+EXPORT_SYMBOL(mlxsw_core_port_fini);
+
 int mlxsw_cmd_exec(struct mlxsw_core *mlxsw_core, u16 opcode, u8 opcode_mod,
                    u32 in_mod, bool out_mbox_direct,
                    char *in_mbox, size_t in_mbox_size,
diff --git a/drivers/net/ethernet/mellanox/mlxsw/core.h b/drivers/net/ethernet/mellanox/mlxsw/core.h
index c73d1c0792a6..f3cebef9c31c 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/core.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/core.h
@@ -43,6 +43,7 @@
 #include <linux/gfp.h>
 #include <linux/types.h>
 #include <linux/skbuff.h>
+#include <net/devlink.h>
 
 #include "trap.h"
 #include "reg.h"
@@ -61,6 +62,8 @@ struct mlxsw_driver;
 struct mlxsw_bus;
 struct mlxsw_bus_info;
 
+void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core);
+
 int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver);
 void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver);
 
@@ -74,10 +77,9 @@ struct mlxsw_tx_info {
         bool is_emad;
 };
 
-bool mlxsw_core_skb_transmit_busy(void *driver_priv,
+bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core,
                                   const struct mlxsw_tx_info *tx_info);
-
-int mlxsw_core_skb_transmit(void *driver_priv, struct sk_buff *skb,
+int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb,
                             const struct mlxsw_tx_info *tx_info);
 
 struct mlxsw_rx_listener {
@@ -131,6 +133,15 @@ u8 mlxsw_core_lag_mapping_get(struct mlxsw_core *mlxsw_core,
 void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core,
                                   u16 lag_id, u8 local_port);
 
+struct mlxsw_core_port {
+        struct devlink_port devlink_port;
+};
+
+int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core,
+                         struct mlxsw_core_port *mlxsw_core_port, u8 local_port,
+                         struct net_device *dev, bool split, u32 split_group);
+void mlxsw_core_port_fini(struct mlxsw_core_port *mlxsw_core_port);
+
 #define MLXSW_CONFIG_PROFILE_SWID_COUNT 8
 
 struct mlxsw_swid_config {
@@ -183,11 +194,12 @@ struct mlxsw_driver {
         const char *kind;
         struct module *owner;
         size_t priv_size;
-        int (*init)(void *driver_priv, struct mlxsw_core *mlxsw_core,
+        int (*init)(struct mlxsw_core *mlxsw_core,
                     const struct mlxsw_bus_info *mlxsw_bus_info);
-        void (*fini)(void *driver_priv);
-        int (*port_split)(void *driver_priv, u8 local_port, unsigned int count);
-        int (*port_unsplit)(void *driver_priv, u8 local_port);
+        void (*fini)(struct mlxsw_core *mlxsw_core);
+        int (*port_split)(struct mlxsw_core *mlxsw_core, u8 local_port,
+                          unsigned int count);
+        int (*port_unsplit)(struct mlxsw_core *mlxsw_core, u8 local_port);
         void (*txhdr_construct)(struct sk_buff *skb,
                                 const struct mlxsw_tx_info *tx_info);
         u8 txhdr_len;
diff --git a/drivers/net/ethernet/mellanox/mlxsw/reg.h b/drivers/net/ethernet/mellanox/mlxsw/reg.h
index ffe4c0305733..57e4a6337ae3 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/reg.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/reg.h
@@ -1805,6 +1805,184 @@ static inline void mlxsw_reg_spvmlr_pack(char *payload, u8 local_port,
         }
 }
 
+/* QTCT - QoS Switch Traffic Class Table
+ * -------------------------------------
+ * Configures the mapping between the packet switch priority and the
+ * traffic class on the transmit port.
+ */
+#define MLXSW_REG_QTCT_ID 0x400A
+#define MLXSW_REG_QTCT_LEN 0x08
+
+static const struct mlxsw_reg_info mlxsw_reg_qtct = {
+        .id = MLXSW_REG_QTCT_ID,
+        .len = MLXSW_REG_QTCT_LEN,
+};
+
+/* reg_qtct_local_port
+ * Local port number.
+ * Access: Index
+ *
+ * Note: CPU port is not supported.
+ */
+MLXSW_ITEM32(reg, qtct, local_port, 0x00, 16, 8);
+
+/* reg_qtct_sub_port
+ * Virtual port within the physical port.
+ * Should be set to 0 when virtual ports are not enabled on the port.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, qtct, sub_port, 0x00, 8, 8);
+
+/* reg_qtct_switch_prio
+ * Switch priority.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, qtct, switch_prio, 0x00, 0, 4);
+
+/* reg_qtct_tclass
+ * Traffic class.
+ * Default values:
+ * switch_prio 0 : tclass 1
+ * switch_prio 1 : tclass 0
+ * switch_prio i : tclass i, for i > 1
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qtct, tclass, 0x04, 0, 4);
+
+static inline void mlxsw_reg_qtct_pack(char *payload, u8 local_port,
+                                       u8 switch_prio, u8 tclass)
+{
+        MLXSW_REG_ZERO(qtct, payload);
+        mlxsw_reg_qtct_local_port_set(payload, local_port);
+        mlxsw_reg_qtct_switch_prio_set(payload, switch_prio);
+        mlxsw_reg_qtct_tclass_set(payload, tclass);
+}
+
+/* QEEC - QoS ETS Element Configuration Register
+ * ---------------------------------------------
+ * Configures the ETS elements.
+ */
+#define MLXSW_REG_QEEC_ID 0x400D
+#define MLXSW_REG_QEEC_LEN 0x1C
+
+static const struct mlxsw_reg_info mlxsw_reg_qeec = {
+        .id = MLXSW_REG_QEEC_ID,
+        .len = MLXSW_REG_QEEC_LEN,
+};
+
+/* reg_qeec_local_port
+ * Local port number.
+ * Access: Index
+ *
+ * Note: CPU port is supported.
+ */
+MLXSW_ITEM32(reg, qeec, local_port, 0x00, 16, 8);
+
+enum mlxsw_reg_qeec_hr {
+        MLXSW_REG_QEEC_HIERARCY_PORT,
+        MLXSW_REG_QEEC_HIERARCY_GROUP,
+        MLXSW_REG_QEEC_HIERARCY_SUBGROUP,
+        MLXSW_REG_QEEC_HIERARCY_TC,
+};
+
+/* reg_qeec_element_hierarchy
+ * 0 - Port
+ * 1 - Group
+ * 2 - Subgroup
+ * 3 - Traffic Class
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, qeec, element_hierarchy, 0x04, 16, 4);
+
+/* reg_qeec_element_index
+ * The index of the element in the hierarchy.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, qeec, element_index, 0x04, 0, 8);
+
+/* reg_qeec_next_element_index
+ * The index of the next (lower) element in the hierarchy.
+ * Access: RW
+ *
+ * Note: Reserved for element_hierarchy 0.
+ */
+MLXSW_ITEM32(reg, qeec, next_element_index, 0x08, 0, 8);
+
+enum {
+        MLXSW_REG_QEEC_BYTES_MODE,
+        MLXSW_REG_QEEC_PACKETS_MODE,
+};
+
+/* reg_qeec_pb
+ * Packets or bytes mode.
+ * 0 - Bytes mode
+ * 1 - Packets mode
+ * Access: RW
+ *
+ * Note: Used for max shaper configuration. For Spectrum, packets mode
+ * is supported only for traffic classes of CPU port.
+ */
+MLXSW_ITEM32(reg, qeec, pb, 0x0C, 28, 1);
+
+/* reg_qeec_mase
+ * Max shaper configuration enable. Enables configuration of the max
+ * shaper on this ETS element.
+ * 0 - Disable
+ * 1 - Enable
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qeec, mase, 0x10, 31, 1);
+
+/* A large max rate will disable the max shaper. */
+#define MLXSW_REG_QEEC_MAS_DIS  200000000       /* Kbps */
+
+/* reg_qeec_max_shaper_rate
+ * Max shaper information rate.
+ * For CPU port, can only be configured for port hierarchy.
+ * When in bytes mode, value is specified in units of 1000bps.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qeec, max_shaper_rate, 0x10, 0, 28);
+
+/* reg_qeec_de
+ * DWRR configuration enable. Enables configuration of the dwrr and
+ * dwrr_weight.
+ * 0 - Disable
+ * 1 - Enable
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qeec, de, 0x18, 31, 1);
+
+/* reg_qeec_dwrr
+ * Transmission selection algorithm to use on the link going down from
+ * the ETS element.
+ * 0 - Strict priority
+ * 1 - DWRR
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qeec, dwrr, 0x18, 15, 1);
+
+/* reg_qeec_dwrr_weight
+ * DWRR weight on the link going down from the ETS element. The
+ * percentage of bandwidth guaranteed to an ETS element within
+ * its hierarchy. The sum of all weights across all ETS elements
+ * within one hierarchy should be equal to 100. Reserved when
+ * transmission selection algorithm is strict priority.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, qeec, dwrr_weight, 0x18, 0, 8);
+
+static inline void mlxsw_reg_qeec_pack(char *payload, u8 local_port,
+                                       enum mlxsw_reg_qeec_hr hr, u8 index,
+                                       u8 next_index)
+{
+        MLXSW_REG_ZERO(qeec, payload);
+        mlxsw_reg_qeec_local_port_set(payload, local_port);
+        mlxsw_reg_qeec_element_hierarchy_set(payload, hr);
+        mlxsw_reg_qeec_element_index_set(payload, index);
+        mlxsw_reg_qeec_next_element_index_set(payload, next_index);
+}
+
 /* PMLP - Ports Module to Local Port Register
  * ------------------------------------------
  * Configures the assignment of modules to local ports.
@@ -2141,6 +2319,145 @@ static inline void mlxsw_reg_paos_pack(char *payload, u8 local_port,
         mlxsw_reg_paos_e_set(payload, 1);
 }
 
+/* PFCC - Ports Flow Control Configuration Register
+ * ------------------------------------------------
+ * Configures and retrieves the per port flow control configuration.
+ */
+#define MLXSW_REG_PFCC_ID 0x5007
+#define MLXSW_REG_PFCC_LEN 0x20
+
+static const struct mlxsw_reg_info mlxsw_reg_pfcc = {
+        .id = MLXSW_REG_PFCC_ID,
+        .len = MLXSW_REG_PFCC_LEN,
+};
+
+/* reg_pfcc_local_port
+ * Local port number.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, pfcc, local_port, 0x00, 16, 8);
+
+/* reg_pfcc_pnat
+ * Port number access type. Determines the way local_port is interpreted:
+ * 0 - Local port number.
+ * 1 - IB / label port number.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, pfcc, pnat, 0x00, 14, 2);
+
+/* reg_pfcc_shl_cap
+ * Send to higher layers capabilities:
+ * 0 - No capability of sending Pause and PFC frames to higher layers.
+ * 1 - Device has capability of sending Pause and PFC frames to higher
+ *     layers.
+ * Access: RO
+ */
+MLXSW_ITEM32(reg, pfcc, shl_cap, 0x00, 1, 1);
+
+/* reg_pfcc_shl_opr
+ * Send to higher layers operation:
+ * 0 - Pause and PFC frames are handled by the port (default).
+ * 1 - Pause and PFC frames are handled by the port and also sent to
+ *     higher layers. Only valid if shl_cap = 1.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pfcc, shl_opr, 0x00, 0, 1);
+
+/* reg_pfcc_ppan
+ * Pause policy auto negotiation.
+ * 0 - Disabled. Generate / ignore Pause frames based on pptx / pprtx.
+ * 1 - Enabled. When auto-negotiation is performed, set the Pause policy
+ *     based on the auto-negotiation resolution.
+ * Access: RW
+ *
+ * Note: The auto-negotiation advertisement is set according to pptx and
+ * pprtx. When PFC is set on Tx / Rx, ppan must be set to 0.
+ */
+MLXSW_ITEM32(reg, pfcc, ppan, 0x04, 28, 4);
+
+/* reg_pfcc_prio_mask_tx
+ * Bit per priority indicating if Tx flow control policy should be
+ * updated based on bit pfctx.
+ * Access: WO
+ */
+MLXSW_ITEM32(reg, pfcc, prio_mask_tx, 0x04, 16, 8);
+
+/* reg_pfcc_prio_mask_rx
+ * Bit per priority indicating if Rx flow control policy should be
+ * updated based on bit pfcrx.
+ * Access: WO
+ */
+MLXSW_ITEM32(reg, pfcc, prio_mask_rx, 0x04, 0, 8);
+
+/* reg_pfcc_pptx
+ * Admin Pause policy on Tx.
+ * 0 - Never generate Pause frames (default).
+ * 1 - Generate Pause frames according to Rx buffer threshold.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pfcc, pptx, 0x08, 31, 1);
+
+/* reg_pfcc_aptx
+ * Active (operational) Pause policy on Tx.
+ * 0 - Never generate Pause frames.
+ * 1 - Generate Pause frames according to Rx buffer threshold.
+ * Access: RO
+ */
+MLXSW_ITEM32(reg, pfcc, aptx, 0x08, 30, 1);
+
+/* reg_pfcc_pfctx
+ * Priority based flow control policy on Tx[7:0]. Per-priority bit mask:
+ * 0 - Never generate priority Pause frames on the specified priority
+ *     (default).
+ * 1 - Generate priority Pause frames according to Rx buffer threshold on
+ *     the specified priority.
+ * Access: RW
+ *
+ * Note: pfctx and pptx must be mutually exclusive.
+ */
+MLXSW_ITEM32(reg, pfcc, pfctx, 0x08, 16, 8);
+
+/* reg_pfcc_pprx
+ * Admin Pause policy on Rx.
+ * 0 - Ignore received Pause frames (default).
+ * 1 - Respect received Pause frames.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pfcc, pprx, 0x0C, 31, 1);
+
+/* reg_pfcc_aprx
+ * Active (operational) Pause policy on Rx.
+ * 0 - Ignore received Pause frames.
+ * 1 - Respect received Pause frames.
+ * Access: RO
+ */
+MLXSW_ITEM32(reg, pfcc, aprx, 0x0C, 30, 1);
+
+/* reg_pfcc_pfcrx
+ * Priority based flow control policy on Rx[7:0]. Per-priority bit mask:
+ * 0 - Ignore incoming priority Pause frames on the specified priority
+ *     (default).
+ * 1 - Respect incoming priority Pause frames on the specified priority.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pfcc, pfcrx, 0x0C, 16, 8);
+
+#define MLXSW_REG_PFCC_ALL_PRIO 0xFF
+
+static inline void mlxsw_reg_pfcc_prio_pack(char *payload, u8 pfc_en)
+{
+        mlxsw_reg_pfcc_prio_mask_tx_set(payload, MLXSW_REG_PFCC_ALL_PRIO);
+        mlxsw_reg_pfcc_prio_mask_rx_set(payload, MLXSW_REG_PFCC_ALL_PRIO);
+        mlxsw_reg_pfcc_pfctx_set(payload, pfc_en);
+        mlxsw_reg_pfcc_pfcrx_set(payload, pfc_en);
+}
+
+static inline void mlxsw_reg_pfcc_pack(char *payload, u8 local_port)
+{
+        MLXSW_REG_ZERO(pfcc, payload);
+        mlxsw_reg_pfcc_local_port_set(payload, local_port);
+}
+
 /* PPCNT - Ports Performance Counters Register
  * -------------------------------------------
  * The PPCNT register retrieves per port performance counters.
@@ -2180,6 +2497,11 @@ MLXSW_ITEM32(reg, ppcnt, local_port, 0x00, 16, 8);
  */
 MLXSW_ITEM32(reg, ppcnt, pnat, 0x00, 14, 2);
 
+enum mlxsw_reg_ppcnt_grp {
+        MLXSW_REG_PPCNT_IEEE_8023_CNT = 0x0,
+        MLXSW_REG_PPCNT_PRIO_CNT = 0x10,
+};
+
 /* reg_ppcnt_grp
  * Performance counter group.
  * Group 63 indicates all groups. Only valid on Set() operation with
@@ -2215,6 +2537,8 @@ MLXSW_ITEM32(reg, ppcnt, clr, 0x04, 31, 1);
  */
 MLXSW_ITEM32(reg, ppcnt, prio_tc, 0x04, 0, 5);
 
+/* Ethernet IEEE 802.3 Counter Group */
+
 /* reg_ppcnt_a_frames_transmitted_ok
  * Access: RO
  */
@@ -2329,15 +2653,145 @@ MLXSW_ITEM64(reg, ppcnt, a_pause_mac_ctrl_frames_received,
 MLXSW_ITEM64(reg, ppcnt, a_pause_mac_ctrl_frames_transmitted,
              0x08 + 0x90, 0, 64);
 
-static inline void mlxsw_reg_ppcnt_pack(char *payload, u8 local_port)
+/* Ethernet Per Priority Group Counters */
+
+/* reg_ppcnt_rx_octets
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, rx_octets, 0x08 + 0x00, 0, 64);
+
+/* reg_ppcnt_rx_frames
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, rx_frames, 0x08 + 0x20, 0, 64);
+
+/* reg_ppcnt_tx_octets
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, tx_octets, 0x08 + 0x28, 0, 64);
+
+/* reg_ppcnt_tx_frames
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, tx_frames, 0x08 + 0x48, 0, 64);
+
+/* reg_ppcnt_rx_pause
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, rx_pause, 0x08 + 0x50, 0, 64);
+
+/* reg_ppcnt_rx_pause_duration
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, rx_pause_duration, 0x08 + 0x58, 0, 64);
+
+/* reg_ppcnt_tx_pause
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, tx_pause, 0x08 + 0x60, 0, 64);
+
+/* reg_ppcnt_tx_pause_duration
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, tx_pause_duration, 0x08 + 0x68, 0, 64);
+
+/* reg_ppcnt_rx_pause_transition
+ * Access: RO
+ */
+MLXSW_ITEM64(reg, ppcnt, tx_pause_transition, 0x08 + 0x70, 0, 64);
+
+static inline void mlxsw_reg_ppcnt_pack(char *payload, u8 local_port,
+                                        enum mlxsw_reg_ppcnt_grp grp,
+                                        u8 prio_tc)
 {
         MLXSW_REG_ZERO(ppcnt, payload);
         mlxsw_reg_ppcnt_swid_set(payload, 0);
         mlxsw_reg_ppcnt_local_port_set(payload, local_port);
         mlxsw_reg_ppcnt_pnat_set(payload, 0);
-        mlxsw_reg_ppcnt_grp_set(payload, 0);
+        mlxsw_reg_ppcnt_grp_set(payload, grp);
         mlxsw_reg_ppcnt_clr_set(payload, 0);
-        mlxsw_reg_ppcnt_prio_tc_set(payload, 0);
+        mlxsw_reg_ppcnt_prio_tc_set(payload, prio_tc);
+}
+
+/* PPTB - Port Prio To Buffer Register
+ * -----------------------------------
+ * Configures the switch priority to buffer table.
+ */
+#define MLXSW_REG_PPTB_ID 0x500B
+#define MLXSW_REG_PPTB_LEN 0x0C
+
+static const struct mlxsw_reg_info mlxsw_reg_pptb = {
+        .id = MLXSW_REG_PPTB_ID,
+        .len = MLXSW_REG_PPTB_LEN,
+};
+
+enum {
+        MLXSW_REG_PPTB_MM_UM,
+        MLXSW_REG_PPTB_MM_UNICAST,
+        MLXSW_REG_PPTB_MM_MULTICAST,
+};
+
+/* reg_pptb_mm
+ * Mapping mode.
+ * 0 - Map both unicast and multicast packets to the same buffer.
+ * 1 - Map only unicast packets.
+ * 2 - Map only multicast packets.
+ * Access: Index
+ *
+ * Note: SwitchX-2 only supports the first option.
+ */
+MLXSW_ITEM32(reg, pptb, mm, 0x00, 28, 2);
+
+/* reg_pptb_local_port
+ * Local port number.
+ * Access: Index
+ */
+MLXSW_ITEM32(reg, pptb, local_port, 0x00, 16, 8);
+
+/* reg_pptb_um
+ * Enables the update of the untagged_buf field.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pptb, um, 0x00, 8, 1);
+
+/* reg_pptb_pm
+ * Enables the update of the prio_to_buff field.
+ * Bit <i> is a flag for updating the mapping for switch priority <i>.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pptb, pm, 0x00, 0, 8);
+
+/* reg_pptb_prio_to_buff
+ * Mapping of switch priority <i> to one of the allocated receive port
+ * buffers.
+ * Access: RW
+ */
+MLXSW_ITEM_BIT_ARRAY(reg, pptb, prio_to_buff, 0x04, 0x04, 4);
+
+/* reg_pptb_pm_msb
+ * Enables the update of the prio_to_buff field.
+ * Bit <i> is a flag for updating the mapping for switch priority <i+8>.
+ * Access: RW
+ */
+MLXSW_ITEM32(reg, pptb, pm_msb, 0x08, 24, 8);
+
+/* reg_pptb_untagged_buff
+ * Mapping of untagged frames to one of the allocated receive port buffers.
+ * Access: RW
+ *
+ * Note: In SwitchX-2 this field must be mapped to buffer 8. Reserved for
+ * Spectrum, as it maps untagged packets based on the default switch priority.
+ */
+MLXSW_ITEM32(reg, pptb, untagged_buff, 0x08, 0, 4);
+
+#define MLXSW_REG_PPTB_ALL_PRIO 0xFF
+
+static inline void mlxsw_reg_pptb_pack(char *payload, u8 local_port)
+{
+        MLXSW_REG_ZERO(pptb, payload);
+        mlxsw_reg_pptb_mm_set(payload, MLXSW_REG_PPTB_MM_UM);
+        mlxsw_reg_pptb_local_port_set(payload, local_port);
+        mlxsw_reg_pptb_pm_set(payload, MLXSW_REG_PPTB_ALL_PRIO);
 }
 
 /* PBMC - Port Buffer Management Control Register
@@ -2346,7 +2800,7 @@ static inline void mlxsw_reg_ppcnt_pack(char *payload, u8 local_port)
  * allocation for different Prios, and the Pause threshold management.
  */
 #define MLXSW_REG_PBMC_ID 0x500C
-#define MLXSW_REG_PBMC_LEN 0x68
+#define MLXSW_REG_PBMC_LEN 0x6C
 
 static const struct mlxsw_reg_info mlxsw_reg_pbmc = {
         .id = MLXSW_REG_PBMC_ID,
@@ -2374,6 +2828,8 @@ MLXSW_ITEM32(reg, pbmc, xoff_timer_value, 0x04, 16, 16);
  */
 MLXSW_ITEM32(reg, pbmc, xoff_refresh, 0x04, 0, 16);
 
+#define MLXSW_REG_PBMC_PORT_SHARED_BUF_IDX 11
+
 /* reg_pbmc_buf_lossy
  * The field indicates if the buffer is lossy.
  * 0 - Lossless
@@ -2398,6 +2854,30 @@ MLXSW_ITEM32_INDEXED(reg, pbmc, buf_epsb, 0x0C, 24, 1, 0x08, 0x00, false);
  */
 MLXSW_ITEM32_INDEXED(reg, pbmc, buf_size, 0x0C, 0, 16, 0x08, 0x00, false);
 
+/* reg_pbmc_buf_xoff_threshold
+ * Once the amount of data in the buffer goes above this value, device
+ * starts sending PFC frames for all priorities associated with the
+ * buffer. Units are represented in cells. Reserved in case of lossy
+ * buffer.
+ * Access: RW
+ *
+ * Note: In Spectrum, reserved for buffer[9].
+ */
+MLXSW_ITEM32_INDEXED(reg, pbmc, buf_xoff_threshold, 0x0C, 16, 16,
+                     0x08, 0x04, false);
+
+/* reg_pbmc_buf_xon_threshold
+ * When the amount of data in the buffer goes below this value, device
+ * stops sending PFC frames for the priorities associated with the
+ * buffer. Units are represented in cells. Reserved in case of lossy
+ * buffer.
+ * Access: RW
+ *
+ * Note: In Spectrum, reserved for buffer[9].
+ */
+MLXSW_ITEM32_INDEXED(reg, pbmc, buf_xon_threshold, 0x0C, 0, 16,
+                     0x08, 0x04, false);
+
 static inline void mlxsw_reg_pbmc_pack(char *payload, u8 local_port,
                                        u16 xoff_timer_value, u16 xoff_refresh)
 {
@@ -2416,6 +2896,17 @@ static inline void mlxsw_reg_pbmc_lossy_buffer_pack(char *payload,
         mlxsw_reg_pbmc_buf_size_set(payload, buf_index, size);
 }
 
+static inline void mlxsw_reg_pbmc_lossless_buffer_pack(char *payload,
+                                                       int buf_index, u16 size,
+                                                       u16 threshold)
+{
+        mlxsw_reg_pbmc_buf_lossy_set(payload, buf_index, 0);
+        mlxsw_reg_pbmc_buf_epsb_set(payload, buf_index, 0);
+        mlxsw_reg_pbmc_buf_size_set(payload, buf_index, size);
+        mlxsw_reg_pbmc_buf_xoff_threshold_set(payload, buf_index, threshold);
+        mlxsw_reg_pbmc_buf_xon_threshold_set(payload, buf_index, threshold);
+}
+
 /* PSPA - Port Switch Partition Allocation
  * ---------------------------------------
  * Controls the association of a port with a switch partition and enables
@@ -2985,9 +3476,10 @@ static const struct mlxsw_reg_info mlxsw_reg_sbpr = {
         .len = MLXSW_REG_SBPR_LEN,
 };
 
-enum mlxsw_reg_sbpr_dir {
-        MLXSW_REG_SBPR_DIR_INGRESS,
-        MLXSW_REG_SBPR_DIR_EGRESS,
+/* shared direstion enum for SBPR, SBCM, SBPM */
+enum mlxsw_reg_sbxx_dir {
+        MLXSW_REG_SBXX_DIR_INGRESS,
+        MLXSW_REG_SBXX_DIR_EGRESS,
 };
 
 /* reg_sbpr_dir
@@ -3020,7 +3512,7 @@ enum mlxsw_reg_sbpr_mode {
 MLXSW_ITEM32(reg, sbpr, mode, 0x08, 0, 4);
 
 static inline void mlxsw_reg_sbpr_pack(char *payload, u8 pool,
-                                       enum mlxsw_reg_sbpr_dir dir,
+                                       enum mlxsw_reg_sbxx_dir dir,
                                        enum mlxsw_reg_sbpr_mode mode, u32 size)
 {
         MLXSW_REG_ZERO(sbpr, payload);
@@ -3062,11 +3554,6 @@ MLXSW_ITEM32(reg, sbcm, local_port, 0x00, 16, 8);
  */
 MLXSW_ITEM32(reg, sbcm, pg_buff, 0x00, 8, 6);
 
-enum mlxsw_reg_sbcm_dir {
-        MLXSW_REG_SBCM_DIR_INGRESS,
-        MLXSW_REG_SBCM_DIR_EGRESS,
-};
-
 /* reg_sbcm_dir
  * Direction.
  * Access: Index
@@ -3099,7 +3586,7 @@ MLXSW_ITEM32(reg, sbcm, max_buff, 0x1C, 0, 24);
 MLXSW_ITEM32(reg, sbcm, pool, 0x24, 0, 4);
 
 static inline void mlxsw_reg_sbcm_pack(char *payload, u8 local_port, u8 pg_buff,
-                                       enum mlxsw_reg_sbcm_dir dir,
+                                       enum mlxsw_reg_sbxx_dir dir,
                                        u32 min_buff, u32 max_buff, u8 pool)
 {
         MLXSW_REG_ZERO(sbcm, payload);
@@ -3111,8 +3598,8 @@ static inline void mlxsw_reg_sbcm_pack(char *payload, u8 local_port, u8 pg_buff,
         mlxsw_reg_sbcm_pool_set(payload, pool);
 }
 
-/* SBPM - Shared Buffer Class Management Register
- * ----------------------------------------------
+/* SBPM - Shared Buffer Port Management Register
+ * ---------------------------------------------
  * The SBPM register configures and retrieves the shared buffer allocation
  * and configuration according to Port-Pool, including the definition
  * of the associated quota.
@@ -3139,11 +3626,6 @@ MLXSW_ITEM32(reg, sbpm, local_port, 0x00, 16, 8);
  */
 MLXSW_ITEM32(reg, sbpm, pool, 0x00, 8, 4);
 
-enum mlxsw_reg_sbpm_dir {
-        MLXSW_REG_SBPM_DIR_INGRESS,
-        MLXSW_REG_SBPM_DIR_EGRESS,
-};
-
 /* reg_sbpm_dir
  * Direction.
  * Access: Index
@@ -3170,7 +3652,7 @@ MLXSW_ITEM32(reg, sbpm, min_buff, 0x18, 0, 24);
 MLXSW_ITEM32(reg, sbpm, max_buff, 0x1C, 0, 24);
 
 static inline void mlxsw_reg_sbpm_pack(char *payload, u8 local_port, u8 pool,
-                                       enum mlxsw_reg_sbpm_dir dir,
+                                       enum mlxsw_reg_sbxx_dir dir,
                                        u32 min_buff, u32 max_buff)
 {
         MLXSW_REG_ZERO(sbpm, payload);
@@ -3283,6 +3765,10 @@ static inline const char *mlxsw_reg_id_str(u16 reg_id)
                 return "SFMR";
         case MLXSW_REG_SPVMLR_ID:
                 return "SPVMLR";
+        case MLXSW_REG_QTCT_ID:
+                return "QTCT";
+        case MLXSW_REG_QEEC_ID:
+                return "QEEC";
         case MLXSW_REG_PMLP_ID:
                 return "PMLP";
         case MLXSW_REG_PMTU_ID:
@@ -3293,8 +3779,12 @@ static inline const char *mlxsw_reg_id_str(u16 reg_id)
                 return "PPAD";
         case MLXSW_REG_PAOS_ID:
                 return "PAOS";
+        case MLXSW_REG_PFCC_ID:
+                return "PFCC";
         case MLXSW_REG_PPCNT_ID:
                 return "PPCNT";
+        case MLXSW_REG_PPTB_ID:
+                return "PPTB";
         case MLXSW_REG_PBMC_ID:
                 return "PBMC";
         case MLXSW_REG_PSPA_ID:
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index 4afbc3e9e381..19b3c144abc6 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -49,7 +49,7 @@
 #include <linux/jiffies.h>
 #include <linux/bitops.h>
 #include <linux/list.h>
-#include <net/devlink.h>
+#include <linux/dcbnl.h>
 #include <net/switchdev.h>
 #include <generated/utsrelease.h>
 
@@ -305,9 +305,9 @@ mlxsw_sp_port_system_port_mapping_set(struct mlxsw_sp_port *mlxsw_sp_port)
         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sspr), sspr_pl);
 }
 
-static int mlxsw_sp_port_module_info_get(struct mlxsw_sp *mlxsw_sp,
-                                         u8 local_port, u8 *p_module,
-                                         u8 *p_width)
+static int __mlxsw_sp_port_module_info_get(struct mlxsw_sp *mlxsw_sp,
+                                           u8 local_port, u8 *p_module,
+                                           u8 *p_width, u8 *p_lane)
 {
         char pmlp_pl[MLXSW_REG_PMLP_LEN];
         int err;
@@ -318,9 +318,20 @@ static int mlxsw_sp_port_module_info_get(struct mlxsw_sp *mlxsw_sp,
                 return err;
         *p_module = mlxsw_reg_pmlp_module_get(pmlp_pl, 0);
         *p_width = mlxsw_reg_pmlp_width_get(pmlp_pl);
+        *p_lane = mlxsw_reg_pmlp_tx_lane_get(pmlp_pl, 0);
         return 0;
 }
 
+static int mlxsw_sp_port_module_info_get(struct mlxsw_sp *mlxsw_sp,
+                                         u8 local_port, u8 *p_module,
+                                         u8 *p_width)
+{
+        u8 lane;
+
+        return __mlxsw_sp_port_module_info_get(mlxsw_sp, local_port, p_module,
+                                               p_width, &lane);
+}
+
 static int mlxsw_sp_port_module_map(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                     u8 module, u8 width, u8 lane)
 {
@@ -379,7 +390,7 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
         u64 len;
         int err;
 
-        if (mlxsw_core_skb_transmit_busy(mlxsw_sp, &tx_info))
+        if (mlxsw_core_skb_transmit_busy(mlxsw_sp->core, &tx_info))
                 return NETDEV_TX_BUSY;
 
         if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
@@ -403,7 +414,7 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
         /* Due to a race we might fail here because of a full queue. In that
          * unlikely case we simply drop the packet.
          */
-        err = mlxsw_core_skb_transmit(mlxsw_sp, skb, &tx_info);
+        err = mlxsw_core_skb_transmit(mlxsw_sp->core, skb, &tx_info);
 
         if (!err) {
                 pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats);
@@ -438,16 +449,89 @@ static int mlxsw_sp_port_set_mac_address(struct net_device *dev, void *p)
         return 0;
 }
 
+static void mlxsw_sp_pg_buf_pack(char *pbmc_pl, int pg_index, int mtu,
+                                 bool pause_en, bool pfc_en, u16 delay)
+{
+        u16 pg_size = 2 * MLXSW_SP_BYTES_TO_CELLS(mtu);
+
+        delay = pfc_en ? mlxsw_sp_pfc_delay_get(mtu, delay) :
+                         MLXSW_SP_PAUSE_DELAY;
+
+        if (pause_en || pfc_en)
+                mlxsw_reg_pbmc_lossless_buffer_pack(pbmc_pl, pg_index,
+                                                    pg_size + delay, pg_size);
+        else
+                mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl, pg_index, pg_size);
+}
+
+int __mlxsw_sp_port_headroom_set(struct mlxsw_sp_port *mlxsw_sp_port, int mtu,
+                                 u8 *prio_tc, bool pause_en,
+                                 struct ieee_pfc *my_pfc)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        u8 pfc_en = !!my_pfc ? my_pfc->pfc_en : 0;
+        u16 delay = !!my_pfc ? my_pfc->delay : 0;
+        char pbmc_pl[MLXSW_REG_PBMC_LEN];
+        int i, j, err;
+
+        mlxsw_reg_pbmc_pack(pbmc_pl, mlxsw_sp_port->local_port, 0, 0);
+        err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(pbmc), pbmc_pl);
+        if (err)
+                return err;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                bool configure = false;
+                bool pfc = false;
+
+                for (j = 0; j < IEEE_8021QAZ_MAX_TCS; j++) {
+                        if (prio_tc[j] == i) {
+                                pfc = pfc_en & BIT(j);
+                                configure = true;
+                                break;
+                        }
+                }
+
+                if (!configure)
+                        continue;
+                mlxsw_sp_pg_buf_pack(pbmc_pl, i, mtu, pause_en, pfc, delay);
+        }
+
+        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pbmc), pbmc_pl);
+}
+
+static int mlxsw_sp_port_headroom_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                      int mtu, bool pause_en)
+{
+        u8 def_prio_tc[IEEE_8021QAZ_MAX_TCS] = {0};
+        bool dcb_en = !!mlxsw_sp_port->dcb.ets;
+        struct ieee_pfc *my_pfc;
+        u8 *prio_tc;
+
+        prio_tc = dcb_en ? mlxsw_sp_port->dcb.ets->prio_tc : def_prio_tc;
+        my_pfc = dcb_en ? mlxsw_sp_port->dcb.pfc : NULL;
+
+        return __mlxsw_sp_port_headroom_set(mlxsw_sp_port, mtu, prio_tc,
+                                            pause_en, my_pfc);
+}
+
 static int mlxsw_sp_port_change_mtu(struct net_device *dev, int mtu)
 {
         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        bool pause_en = mlxsw_sp_port_is_pause_en(mlxsw_sp_port);
         int err;
 
-        err = mlxsw_sp_port_mtu_set(mlxsw_sp_port, mtu);
+        err = mlxsw_sp_port_headroom_set(mlxsw_sp_port, mtu, pause_en);
         if (err)
                 return err;
+        err = mlxsw_sp_port_mtu_set(mlxsw_sp_port, mtu);
+        if (err)
+                goto err_port_mtu_set;
         dev->mtu = mtu;
         return 0;
+
+err_port_mtu_set:
+        mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu, pause_en);
+        return err;
 }
 
 static struct rtnl_link_stats64 *
@@ -861,6 +945,33 @@ int mlxsw_sp_port_kill_vid(struct net_device *dev,
         return 0;
 }
 
+static int mlxsw_sp_port_get_phys_port_name(struct net_device *dev, char *name,
+                                            size_t len)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        u8 module, width, lane;
+        int err;
+
+        err = __mlxsw_sp_port_module_info_get(mlxsw_sp_port->mlxsw_sp,
+                                              mlxsw_sp_port->local_port,
+                                              &module, &width, &lane);
+        if (err) {
+                netdev_err(dev, "Failed to retrieve module information\n");
+                return err;
+        }
+
+        if (!mlxsw_sp_port->split)
+                err = snprintf(name, len, "p%d", module + 1);
+        else
+                err = snprintf(name, len, "p%ds%d", module + 1,
+                               lane / width);
+
+        if (err >= len)
+                return -EINVAL;
+
+        return 0;
+}
+
 static const struct net_device_ops mlxsw_sp_port_netdev_ops = {
         .ndo_open               = mlxsw_sp_port_open,
         .ndo_stop               = mlxsw_sp_port_stop,
@@ -877,6 +988,7 @@ static const struct net_device_ops mlxsw_sp_port_netdev_ops = {
         .ndo_bridge_setlink     = switchdev_port_bridge_setlink,
         .ndo_bridge_getlink     = switchdev_port_bridge_getlink,
         .ndo_bridge_dellink     = switchdev_port_bridge_dellink,
+        .ndo_get_phys_port_name = mlxsw_sp_port_get_phys_port_name,
 };
 
 static void mlxsw_sp_port_get_drvinfo(struct net_device *dev,
@@ -897,6 +1009,68 @@ static void mlxsw_sp_port_get_drvinfo(struct net_device *dev,
                 sizeof(drvinfo->bus_info));
 }
 
+static void mlxsw_sp_port_get_pauseparam(struct net_device *dev,
+                                         struct ethtool_pauseparam *pause)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+
+        pause->rx_pause = mlxsw_sp_port->link.rx_pause;
+        pause->tx_pause = mlxsw_sp_port->link.tx_pause;
+}
+
+static int mlxsw_sp_port_pause_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                   struct ethtool_pauseparam *pause)
+{
+        char pfcc_pl[MLXSW_REG_PFCC_LEN];
+
+        mlxsw_reg_pfcc_pack(pfcc_pl, mlxsw_sp_port->local_port);
+        mlxsw_reg_pfcc_pprx_set(pfcc_pl, pause->rx_pause);
+        mlxsw_reg_pfcc_pptx_set(pfcc_pl, pause->tx_pause);
+
+        return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(pfcc),
+                               pfcc_pl);
+}
+
+static int mlxsw_sp_port_set_pauseparam(struct net_device *dev,
+                                        struct ethtool_pauseparam *pause)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        bool pause_en = pause->tx_pause || pause->rx_pause;
+        int err;
+
+        if (mlxsw_sp_port->dcb.pfc && mlxsw_sp_port->dcb.pfc->pfc_en) {
+                netdev_err(dev, "PFC already enabled on port\n");
+                return -EINVAL;
+        }
+
+        if (pause->autoneg) {
+                netdev_err(dev, "PAUSE frames autonegotiation isn't supported\n");
+                return -EINVAL;
+        }
+
+        err = mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu, pause_en);
+        if (err) {
+                netdev_err(dev, "Failed to configure port's headroom\n");
+                return err;
+        }
+
+        err = mlxsw_sp_port_pause_set(mlxsw_sp_port, pause);
+        if (err) {
+                netdev_err(dev, "Failed to set PAUSE parameters\n");
+                goto err_port_pause_configure;
+        }
+
+        mlxsw_sp_port->link.rx_pause = pause->rx_pause;
+        mlxsw_sp_port->link.tx_pause = pause->tx_pause;
+
+        return 0;
+
+err_port_pause_configure:
+        pause_en = mlxsw_sp_port_is_pause_en(mlxsw_sp_port);
+        mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu, pause_en);
+        return err;
+}
+
 struct mlxsw_sp_port_hw_stats {
         char str[ETH_GSTRING_LEN];
         u64 (*getter)(char *payload);
@@ -1032,7 +1206,8 @@ static void mlxsw_sp_port_get_stats(struct net_device *dev,
         int i;
         int err;
 
-        mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sp_port->local_port);
+        mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sp_port->local_port,
+                             MLXSW_REG_PPCNT_IEEE_8023_CNT, 0);
         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ppcnt), ppcnt_pl);
         for (i = 0; i < MLXSW_SP_PORT_HW_STATS_LEN; i++)
                 data[i] = !err ? mlxsw_sp_port_hw_stats[i].getter(ppcnt_pl) : 0;
@@ -1380,6 +1555,8 @@ static int mlxsw_sp_port_set_settings(struct net_device *dev,
 static const struct ethtool_ops mlxsw_sp_port_ethtool_ops = {
         .get_drvinfo            = mlxsw_sp_port_get_drvinfo,
         .get_link               = ethtool_op_get_link,
+        .get_pauseparam         = mlxsw_sp_port_get_pauseparam,
+        .set_pauseparam         = mlxsw_sp_port_set_pauseparam,
         .get_strings            = mlxsw_sp_port_get_strings,
         .set_phys_id            = mlxsw_sp_port_set_phys_id,
         .get_ethtool_stats      = mlxsw_sp_port_get_stats,
@@ -1402,12 +1579,112 @@ mlxsw_sp_port_speed_by_width_set(struct mlxsw_sp_port *mlxsw_sp_port, u8 width)
         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptys), ptys_pl);
 }
 
+int mlxsw_sp_port_ets_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                          enum mlxsw_reg_qeec_hr hr, u8 index, u8 next_index,
+                          bool dwrr, u8 dwrr_weight)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        char qeec_pl[MLXSW_REG_QEEC_LEN];
+
+        mlxsw_reg_qeec_pack(qeec_pl, mlxsw_sp_port->local_port, hr, index,
+                            next_index);
+        mlxsw_reg_qeec_de_set(qeec_pl, true);
+        mlxsw_reg_qeec_dwrr_set(qeec_pl, dwrr);
+        mlxsw_reg_qeec_dwrr_weight_set(qeec_pl, dwrr_weight);
+        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(qeec), qeec_pl);
+}
+
+int mlxsw_sp_port_ets_maxrate_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                  enum mlxsw_reg_qeec_hr hr, u8 index,
+                                  u8 next_index, u32 maxrate)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        char qeec_pl[MLXSW_REG_QEEC_LEN];
+
+        mlxsw_reg_qeec_pack(qeec_pl, mlxsw_sp_port->local_port, hr, index,
+                            next_index);
+        mlxsw_reg_qeec_mase_set(qeec_pl, true);
+        mlxsw_reg_qeec_max_shaper_rate_set(qeec_pl, maxrate);
+        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(qeec), qeec_pl);
+}
+
+int mlxsw_sp_port_prio_tc_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                              u8 switch_prio, u8 tclass)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        char qtct_pl[MLXSW_REG_QTCT_LEN];
+
+        mlxsw_reg_qtct_pack(qtct_pl, mlxsw_sp_port->local_port, switch_prio,
+                            tclass);
+        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(qtct), qtct_pl);
+}
+
+static int mlxsw_sp_port_ets_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        int err, i;
+
+        /* Setup the elements hierarcy, so that each TC is linked to
+         * one subgroup, which are all member in the same group.
+         */
+        err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
+                                    MLXSW_REG_QEEC_HIERARCY_GROUP, 0, 0, false,
+                                    0);
+        if (err)
+                return err;
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
+                                            MLXSW_REG_QEEC_HIERARCY_SUBGROUP, i,
+                                            0, false, 0);
+                if (err)
+                        return err;
+        }
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
+                                            MLXSW_REG_QEEC_HIERARCY_TC, i, i,
+                                            false, 0);
+                if (err)
+                        return err;
+        }
+
+        /* Make sure the max shaper is disabled in all hierarcies that
+         * support it.
+         */
+        err = mlxsw_sp_port_ets_maxrate_set(mlxsw_sp_port,
+                                            MLXSW_REG_QEEC_HIERARCY_PORT, 0, 0,
+                                            MLXSW_REG_QEEC_MAS_DIS);
+        if (err)
+                return err;
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_ets_maxrate_set(mlxsw_sp_port,
+                                                    MLXSW_REG_QEEC_HIERARCY_SUBGROUP,
+                                                    i, 0,
+                                                    MLXSW_REG_QEEC_MAS_DIS);
+                if (err)
+                        return err;
+        }
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_ets_maxrate_set(mlxsw_sp_port,
+                                                    MLXSW_REG_QEEC_HIERARCY_TC,
+                                                    i, i,
+                                                    MLXSW_REG_QEEC_MAS_DIS);
+                if (err)
+                        return err;
+        }
+
+        /* Map all priorities to traffic class 0. */
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_prio_tc_set(mlxsw_sp_port, i, 0);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
 static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                   bool split, u8 module, u8 width)
 {
-        struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
         struct mlxsw_sp_port *mlxsw_sp_port;
-        struct devlink_port *devlink_port;
         struct net_device *dev;
         size_t bytes;
         int err;
@@ -1460,16 +1737,6 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
          */
         dev->hard_header_len += MLXSW_TXHDR_LEN;
 
-        devlink_port = &mlxsw_sp_port->devlink_port;
-        if (mlxsw_sp_port->split)
-                devlink_port_split_set(devlink_port, module);
-        err = devlink_port_register(devlink, devlink_port, local_port);
-        if (err) {
-                dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to register devlink port\n",
-                        mlxsw_sp_port->local_port);
-                goto err_devlink_port_register;
-        }
-
         err = mlxsw_sp_port_system_port_mapping_set(mlxsw_sp_port);
         if (err) {
                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set system port mapping\n",
@@ -1509,6 +1776,21 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                 goto err_port_buffers_init;
         }
 
+        err = mlxsw_sp_port_ets_init(mlxsw_sp_port);
+        if (err) {
+                dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to initialize ETS\n",
+                        mlxsw_sp_port->local_port);
+                goto err_port_ets_init;
+        }
+
+        /* ETS and buffers must be initialized before DCB. */
+        err = mlxsw_sp_port_dcb_init(mlxsw_sp_port);
+        if (err) {
+                dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to initialize DCB\n",
+                        mlxsw_sp_port->local_port);
+                goto err_port_dcb_init;
+        }
+
         mlxsw_sp_port_switchdev_init(mlxsw_sp_port);
         err = register_netdev(dev);
         if (err) {
@@ -1517,7 +1799,14 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                 goto err_register_netdev;
         }
 
-        devlink_port_type_eth_set(devlink_port, dev);
+        err = mlxsw_core_port_init(mlxsw_sp->core, &mlxsw_sp_port->core_port,
+                                   mlxsw_sp_port->local_port, dev,
+                                   mlxsw_sp_port->split, module);
+        if (err) {
+                dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to init core port\n",
+                        mlxsw_sp_port->local_port);
+                goto err_core_port_init;
+        }
 
         err = mlxsw_sp_port_vlan_init(mlxsw_sp_port);
         if (err)
@@ -1527,16 +1816,18 @@ static int __mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port,
         return 0;
 
 err_port_vlan_init:
+        mlxsw_core_port_fini(&mlxsw_sp_port->core_port);
+err_core_port_init:
         unregister_netdev(dev);
 err_register_netdev:
+err_port_dcb_init:
+err_port_ets_init:
 err_port_buffers_init:
 err_port_admin_status_set:
 err_port_mtu_set:
 err_port_speed_by_width_set:
 err_port_swid_set:
 err_port_system_port_mapping_set:
-        devlink_port_unregister(&mlxsw_sp_port->devlink_port);
-err_devlink_port_register:
 err_dev_addr_init:
         free_percpu(mlxsw_sp_port->pcpu_stats);
 err_alloc_stats:
@@ -1590,15 +1881,13 @@ static void mlxsw_sp_port_vports_fini(struct mlxsw_sp_port *mlxsw_sp_port)
 static void mlxsw_sp_port_remove(struct mlxsw_sp *mlxsw_sp, u8 local_port)
 {
         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp->ports[local_port];
-        struct devlink_port *devlink_port;
 
         if (!mlxsw_sp_port)
                 return;
         mlxsw_sp->ports[local_port] = NULL;
-        devlink_port = &mlxsw_sp_port->devlink_port;
-        devlink_port_type_clear(devlink_port);
+        mlxsw_core_port_fini(&mlxsw_sp_port->core_port);
         unregister_netdev(mlxsw_sp_port->dev); /* This calls ndo_stop */
-        devlink_port_unregister(devlink_port);
+        mlxsw_sp_port_dcb_fini(mlxsw_sp_port);
         mlxsw_sp_port_vports_fini(mlxsw_sp_port);
         mlxsw_sp_port_switchdev_fini(mlxsw_sp_port);
         mlxsw_sp_port_swid_set(mlxsw_sp_port, MLXSW_PORT_SWID_DISABLED_PORT);
@@ -1659,9 +1948,10 @@ static u8 mlxsw_sp_cluster_base_port_get(u8 local_port)
         return local_port - offset;
 }
 
-static int mlxsw_sp_port_split(void *priv, u8 local_port, unsigned int count)
+static int mlxsw_sp_port_split(struct mlxsw_core *mlxsw_core, u8 local_port,
+                               unsigned int count)
 {
-        struct mlxsw_sp *mlxsw_sp = priv;
+        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
         struct mlxsw_sp_port *mlxsw_sp_port;
         u8 width = MLXSW_PORT_MODULE_MAX_WIDTH / count;
         u8 module, cur_width, base_port;
@@ -1733,9 +2023,9 @@ err_port_create:
         return err;
 }
 
-static int mlxsw_sp_port_unsplit(void *priv, u8 local_port)
+static int mlxsw_sp_port_unsplit(struct mlxsw_core *mlxsw_core, u8 local_port)
 {
-        struct mlxsw_sp *mlxsw_sp = priv;
+        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
         struct mlxsw_sp_port *mlxsw_sp_port;
         u8 module, cur_width, base_port;
         unsigned int count;
@@ -2080,10 +2370,10 @@ static int mlxsw_sp_lag_init(struct mlxsw_sp *mlxsw_sp)
         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcr), slcr_pl);
 }
 
-static int mlxsw_sp_init(void *priv, struct mlxsw_core *mlxsw_core,
+static int mlxsw_sp_init(struct mlxsw_core *mlxsw_core,
                          const struct mlxsw_bus_info *mlxsw_bus_info)
 {
-        struct mlxsw_sp *mlxsw_sp = priv;
+        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
         int err;
 
         mlxsw_sp->core = mlxsw_core;
@@ -2154,9 +2444,9 @@ err_event_register:
         return err;
 }
 
-static void mlxsw_sp_fini(void *priv)
+static void mlxsw_sp_fini(struct mlxsw_core *mlxsw_core)
 {
-        struct mlxsw_sp *mlxsw_sp = priv;
+        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 
         mlxsw_sp_switchdev_fini(mlxsw_sp);
         mlxsw_sp_traps_fini(mlxsw_sp);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
index 4b8abaf06321..361b0c270b56 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
@@ -42,15 +42,15 @@
 #include <linux/bitops.h>
 #include <linux/if_vlan.h>
 #include <linux/list.h>
+#include <linux/dcbnl.h>
 #include <net/switchdev.h>
-#include <net/devlink.h>
 
 #include "port.h"
 #include "core.h"
 
 #define MLXSW_SP_VFID_BASE VLAN_N_VID
 #define MLXSW_SP_VFID_PORT_MAX 512      /* Non-bridged VLAN interfaces */
-#define MLXSW_SP_VFID_BR_MAX 8192       /* Bridged VLAN interfaces */
+#define MLXSW_SP_VFID_BR_MAX 6144       /* Bridged VLAN interfaces */
 #define MLXSW_SP_VFID_MAX (MLXSW_SP_VFID_PORT_MAX + MLXSW_SP_VFID_BR_MAX)
 
 #define MLXSW_SP_LAG_MAX 64
@@ -62,6 +62,23 @@
 
 #define MLXSW_SP_PORT_BASE_SPEED 25000  /* Mb/s */
 
+#define MLXSW_SP_BYTES_PER_CELL 96
+
+#define MLXSW_SP_BYTES_TO_CELLS(b) DIV_ROUND_UP(b, MLXSW_SP_BYTES_PER_CELL)
+
+/* Maximum delay buffer needed in case of PAUSE frames, in cells.
+ * Assumes 100m cable and maximum MTU.
+ */
+#define MLXSW_SP_PAUSE_DELAY 612
+
+#define MLXSW_SP_CELL_FACTOR 2  /* 2 * cell_size / (IPG + cell_size + 1) */
+
+static inline u16 mlxsw_sp_pfc_delay_get(int mtu, u16 delay)
+{
+        delay = MLXSW_SP_BYTES_TO_CELLS(DIV_ROUND_UP(delay, BITS_PER_BYTE));
+        return MLXSW_SP_CELL_FACTOR * delay + MLXSW_SP_BYTES_TO_CELLS(mtu);
+}
+
 struct mlxsw_sp_port;
 
 struct mlxsw_sp_upper {
@@ -148,6 +165,7 @@ struct mlxsw_sp_port_pcpu_stats {
 };
 
 struct mlxsw_sp_port {
+        struct mlxsw_core_port core_port; /* must be first */
         struct net_device *dev;
         struct mlxsw_sp_port_pcpu_stats __percpu *pcpu_stats;
         struct mlxsw_sp *mlxsw_sp;
@@ -166,14 +184,28 @@ struct mlxsw_sp_port {
                 struct mlxsw_sp_vfid *vfid;
                 u16 vid;
         } vport;
+        struct {
+                u8 tx_pause:1,
+                   rx_pause:1;
+        } link;
+        struct {
+                struct ieee_ets *ets;
+                struct ieee_maxrate *maxrate;
+                struct ieee_pfc *pfc;
+        } dcb;
         /* 802.1Q bridge VLANs */
         unsigned long *active_vlans;
         unsigned long *untagged_vlans;
         /* VLAN interfaces */
         struct list_head vports_list;
-        struct devlink_port devlink_port;
 };
 
+static inline bool
+mlxsw_sp_port_is_pause_en(const struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        return mlxsw_sp_port->link.tx_pause || mlxsw_sp_port->link.rx_pause;
+}
+
 static inline struct mlxsw_sp_port *
 mlxsw_sp_port_lagged_get(struct mlxsw_sp *mlxsw_sp, u16 lag_id, u8 port_index)
 {
@@ -265,5 +297,33 @@ int mlxsw_sp_vport_flood_set(struct mlxsw_sp_port *mlxsw_sp_vport, u16 vfid,
                              bool set, bool only_uc);
 void mlxsw_sp_port_active_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port);
 int mlxsw_sp_port_pvid_set(struct mlxsw_sp_port *mlxsw_sp_port, u16 vid);
+int mlxsw_sp_port_ets_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                          enum mlxsw_reg_qeec_hr hr, u8 index, u8 next_index,
+                          bool dwrr, u8 dwrr_weight);
+int mlxsw_sp_port_prio_tc_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                              u8 switch_prio, u8 tclass);
+int __mlxsw_sp_port_headroom_set(struct mlxsw_sp_port *mlxsw_sp_port, int mtu,
+                                 u8 *prio_tc, bool pause_en,
+                                 struct ieee_pfc *my_pfc);
+int mlxsw_sp_port_ets_maxrate_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                  enum mlxsw_reg_qeec_hr hr, u8 index,
+                                  u8 next_index, u32 maxrate);
+
+#ifdef CONFIG_MLXSW_SPECTRUM_DCB
+
+int mlxsw_sp_port_dcb_init(struct mlxsw_sp_port *mlxsw_sp_port);
+void mlxsw_sp_port_dcb_fini(struct mlxsw_sp_port *mlxsw_sp_port);
+
+#else
+
+static inline int mlxsw_sp_port_dcb_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        return 0;
+}
+
+static inline void mlxsw_sp_port_dcb_fini(struct mlxsw_sp_port *mlxsw_sp_port)
+{}
+
+#endif
 
 #endif
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
index d59195e3f7fb..f58b1d3a619a 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
@@ -34,6 +34,8 @@
 
 #include <linux/kernel.h>
 #include <linux/types.h>
+#include <linux/dcbnl.h>
+#include <linux/if_ether.h>
 
 #include "spectrum.h"
 #include "core.h"
@@ -52,15 +54,15 @@ struct mlxsw_sp_pb {
         }
 
 static const struct mlxsw_sp_pb mlxsw_sp_pbs[] = {
-        MLXSW_SP_PB(0, 208),
-        MLXSW_SP_PB(1, 208),
-        MLXSW_SP_PB(2, 208),
-        MLXSW_SP_PB(3, 208),
-        MLXSW_SP_PB(4, 208),
-        MLXSW_SP_PB(5, 208),
-        MLXSW_SP_PB(6, 208),
-        MLXSW_SP_PB(7, 208),
-        MLXSW_SP_PB(9, 208),
+        MLXSW_SP_PB(0, 2 * MLXSW_SP_BYTES_TO_CELLS(ETH_FRAME_LEN)),
+        MLXSW_SP_PB(1, 0),
+        MLXSW_SP_PB(2, 0),
+        MLXSW_SP_PB(3, 0),
+        MLXSW_SP_PB(4, 0),
+        MLXSW_SP_PB(5, 0),
+        MLXSW_SP_PB(6, 0),
+        MLXSW_SP_PB(7, 0),
+        MLXSW_SP_PB(9, 2 * MLXSW_SP_BYTES_TO_CELLS(MLXSW_PORT_MAX_MTU)),
 };
 
 #define MLXSW_SP_PBS_LEN ARRAY_SIZE(mlxsw_sp_pbs)
@@ -78,25 +80,45 @@ static int mlxsw_sp_port_pb_init(struct mlxsw_sp_port *mlxsw_sp_port)
                 pb = &mlxsw_sp_pbs[i];
                 mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl, pb->index, pb->size);
         }
+        mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl,
+                                         MLXSW_REG_PBMC_PORT_SHARED_BUF_IDX, 0);
         return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core,
                                MLXSW_REG(pbmc), pbmc_pl);
 }
 
-#define MLXSW_SP_SB_BYTES_PER_CELL 96
+static int mlxsw_sp_port_pb_prio_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        char pptb_pl[MLXSW_REG_PPTB_LEN];
+        int i;
+
+        mlxsw_reg_pptb_pack(pptb_pl, mlxsw_sp_port->local_port);
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
+                mlxsw_reg_pptb_prio_to_buff_set(pptb_pl, i, 0);
+        return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(pptb),
+                               pptb_pl);
+}
+
+static int mlxsw_sp_port_headroom_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        int err;
+
+        err = mlxsw_sp_port_pb_init(mlxsw_sp_port);
+        if (err)
+                return err;
+        return mlxsw_sp_port_pb_prio_init(mlxsw_sp_port);
+}
 
 struct mlxsw_sp_sb_pool {
         u8 pool;
-        enum mlxsw_reg_sbpr_dir dir;
+        enum mlxsw_reg_sbxx_dir dir;
         enum mlxsw_reg_sbpr_mode mode;
         u32 size;
 };
 
 #define MLXSW_SP_SB_POOL_INGRESS_SIZE                           \
-        ((15000000 - (2 * 20000 * MLXSW_PORT_MAX_PORTS)) /      \
-         MLXSW_SP_SB_BYTES_PER_CELL)
+        (15000000 - (2 * 20000 * MLXSW_PORT_MAX_PORTS))
 #define MLXSW_SP_SB_POOL_EGRESS_SIZE                            \
-        ((14000000 - (8 * 1500 * MLXSW_PORT_MAX_PORTS)) /       \
-         MLXSW_SP_SB_BYTES_PER_CELL)
+        (14000000 - (8 * 1500 * MLXSW_PORT_MAX_PORTS))
 
 #define MLXSW_SP_SB_POOL(_pool, _dir, _mode, _size)             \
         {                                                       \
@@ -107,22 +129,22 @@ struct mlxsw_sp_sb_pool {
         }
 
 #define MLXSW_SP_SB_POOL_INGRESS(_pool, _size)                  \
-        MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBPR_DIR_INGRESS,     \
+        MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBXX_DIR_INGRESS,     \
                          MLXSW_REG_SBPR_MODE_DYNAMIC, _size)
 
 #define MLXSW_SP_SB_POOL_EGRESS(_pool, _size)                   \
-        MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBPR_DIR_EGRESS,      \
+        MLXSW_SP_SB_POOL(_pool, MLXSW_REG_SBXX_DIR_EGRESS,      \
                          MLXSW_REG_SBPR_MODE_DYNAMIC, _size)
 
 static const struct mlxsw_sp_sb_pool mlxsw_sp_sb_pools[] = {
-        MLXSW_SP_SB_POOL_INGRESS(0, MLXSW_SP_SB_POOL_INGRESS_SIZE),
+        MLXSW_SP_SB_POOL_INGRESS(0, MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_POOL_INGRESS_SIZE)),
         MLXSW_SP_SB_POOL_INGRESS(1, 0),
         MLXSW_SP_SB_POOL_INGRESS(2, 0),
         MLXSW_SP_SB_POOL_INGRESS(3, 0),
-        MLXSW_SP_SB_POOL_EGRESS(0, MLXSW_SP_SB_POOL_EGRESS_SIZE),
+        MLXSW_SP_SB_POOL_EGRESS(0, MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_POOL_EGRESS_SIZE)),
         MLXSW_SP_SB_POOL_EGRESS(1, 0),
         MLXSW_SP_SB_POOL_EGRESS(2, 0),
-        MLXSW_SP_SB_POOL_EGRESS(2, MLXSW_SP_SB_POOL_EGRESS_SIZE),
+        MLXSW_SP_SB_POOL_EGRESS(2, MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_POOL_EGRESS_SIZE)),
 };
 
 #define MLXSW_SP_SB_POOLS_LEN ARRAY_SIZE(mlxsw_sp_sb_pools)
@@ -151,7 +173,7 @@ struct mlxsw_sp_sb_cm {
                 u8 pg;
                 u8 tc;
         } u;
-        enum mlxsw_reg_sbcm_dir dir;
+        enum mlxsw_reg_sbxx_dir dir;
         u32 min_buff;
         u32 max_buff;
         u8 pool;
@@ -167,18 +189,18 @@ struct mlxsw_sp_sb_cm {
         }
 
 #define MLXSW_SP_SB_CM_INGRESS(_pg, _min_buff, _max_buff)               \
-        MLXSW_SP_SB_CM(_pg, MLXSW_REG_SBCM_DIR_INGRESS,                 \
+        MLXSW_SP_SB_CM(_pg, MLXSW_REG_SBXX_DIR_INGRESS,                 \
                        _min_buff, _max_buff, 0)
 
 #define MLXSW_SP_SB_CM_EGRESS(_tc, _min_buff, _max_buff)                \
-        MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBCM_DIR_EGRESS,                  \
+        MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBXX_DIR_EGRESS,                  \
                        _min_buff, _max_buff, 0)
 
 #define MLXSW_SP_CPU_PORT_SB_CM_EGRESS(_tc)                             \
-        MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBCM_DIR_EGRESS, 104, 2, 3)
+        MLXSW_SP_SB_CM(_tc, MLXSW_REG_SBXX_DIR_EGRESS, 104, 2, 3)
 
 static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms[] = {
-        MLXSW_SP_SB_CM_INGRESS(0, 10000 / MLXSW_SP_SB_BYTES_PER_CELL, 8),
+        MLXSW_SP_SB_CM_INGRESS(0, MLXSW_SP_BYTES_TO_CELLS(10000), 8),
         MLXSW_SP_SB_CM_INGRESS(1, 0, 0),
         MLXSW_SP_SB_CM_INGRESS(2, 0, 0),
         MLXSW_SP_SB_CM_INGRESS(3, 0, 0),
@@ -186,15 +208,15 @@ static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms[] = {
         MLXSW_SP_SB_CM_INGRESS(5, 0, 0),
         MLXSW_SP_SB_CM_INGRESS(6, 0, 0),
         MLXSW_SP_SB_CM_INGRESS(7, 0, 0),
-        MLXSW_SP_SB_CM_INGRESS(9, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff),
-        MLXSW_SP_SB_CM_EGRESS(0, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(1, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(2, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(3, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(4, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(5, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(6, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
-        MLXSW_SP_SB_CM_EGRESS(7, 1500 / MLXSW_SP_SB_BYTES_PER_CELL, 9),
+        MLXSW_SP_SB_CM_INGRESS(9, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff),
+        MLXSW_SP_SB_CM_EGRESS(0, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(1, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(2, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(3, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(4, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(5, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(6, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
+        MLXSW_SP_SB_CM_EGRESS(7, MLXSW_SP_BYTES_TO_CELLS(1500), 9),
         MLXSW_SP_SB_CM_EGRESS(8, 0, 0),
         MLXSW_SP_SB_CM_EGRESS(9, 0, 0),
         MLXSW_SP_SB_CM_EGRESS(10, 0, 0),
@@ -282,7 +304,7 @@ static int mlxsw_sp_cpu_port_sb_cms_init(struct mlxsw_sp *mlxsw_sp)
 
 struct mlxsw_sp_sb_pm {
         u8 pool;
-        enum mlxsw_reg_sbpm_dir dir;
+        enum mlxsw_reg_sbxx_dir dir;
         u32 min_buff;
         u32 max_buff;
 };
@@ -296,11 +318,11 @@ struct mlxsw_sp_sb_pm {
         }
 
 #define MLXSW_SP_SB_PM_INGRESS(_pool, _min_buff, _max_buff)     \
-        MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBPM_DIR_INGRESS,       \
+        MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBXX_DIR_INGRESS,       \
                        _min_buff, _max_buff)
 
 #define MLXSW_SP_SB_PM_EGRESS(_pool, _min_buff, _max_buff)      \
-        MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBPM_DIR_EGRESS,        \
+        MLXSW_SP_SB_PM(_pool, MLXSW_REG_SBXX_DIR_EGRESS,        \
                        _min_buff, _max_buff)
 
 static const struct mlxsw_sp_sb_pm mlxsw_sp_sb_pms[] = {
@@ -353,21 +375,21 @@ struct mlxsw_sp_sb_mm {
         }
 
 static const struct mlxsw_sp_sb_mm mlxsw_sp_sb_mms[] = {
-        MLXSW_SP_SB_MM(0, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(1, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(2, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(3, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(4, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(5, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(6, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(7, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(8, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(9, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(10, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(11, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(12, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(13, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
-        MLXSW_SP_SB_MM(14, 20000 / MLXSW_SP_SB_BYTES_PER_CELL, 0xff, 0),
+        MLXSW_SP_SB_MM(0, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(1, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(2, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(3, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(4, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(5, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(6, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(7, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(8, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(9, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(10, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(11, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(12, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(13, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
+        MLXSW_SP_SB_MM(14, MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 };
 
 #define MLXSW_SP_SB_MMS_LEN ARRAY_SIZE(mlxsw_sp_sb_mms)
@@ -410,7 +432,7 @@ int mlxsw_sp_port_buffers_init(struct mlxsw_sp_port *mlxsw_sp_port)
 {
         int err;
 
-        err = mlxsw_sp_port_pb_init(mlxsw_sp_port);
+        err = mlxsw_sp_port_headroom_init(mlxsw_sp_port);
         if (err)
                 return err;
         err = mlxsw_sp_port_sb_cms_init(mlxsw_sp_port);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c
new file mode 100644
index 000000000000..0b323661c0b6
--- /dev/null
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c
@@ -0,0 +1,480 @@
+/*
+ * drivers/net/ethernet/mellanox/mlxsw/spectrum_dcb.c
+ * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2016 Ido Schimmel <idosch@mellanox.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <linux/netdevice.h>
+#include <linux/string.h>
+#include <linux/bitops.h>
+#include <net/dcbnl.h>
+
+#include "spectrum.h"
+#include "reg.h"
+
+static u8 mlxsw_sp_dcbnl_getdcbx(struct net_device __always_unused *dev)
+{
+        return DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE;
+}
+
+static u8 mlxsw_sp_dcbnl_setdcbx(struct net_device __always_unused *dev,
+                                 u8 mode)
+{
+        return (mode != (DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE)) ? 1 : 0;
+}
+
+static int mlxsw_sp_dcbnl_ieee_getets(struct net_device *dev,
+                                      struct ieee_ets *ets)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+
+        memcpy(ets, mlxsw_sp_port->dcb.ets, sizeof(*ets));
+
+        return 0;
+}
+
+static int mlxsw_sp_port_ets_validate(struct mlxsw_sp_port *mlxsw_sp_port,
+                                      struct ieee_ets *ets)
+{
+        struct net_device *dev = mlxsw_sp_port->dev;
+        bool has_ets_tc = false;
+        int i, tx_bw_sum = 0;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                switch (ets->tc_tsa[i]) {
+                case IEEE_8021QAZ_TSA_STRICT:
+                        break;
+                case IEEE_8021QAZ_TSA_ETS:
+                        has_ets_tc = true;
+                        tx_bw_sum += ets->tc_tx_bw[i];
+                        break;
+                default:
+                        netdev_err(dev, "Only strict priority and ETS are supported\n");
+                        return -EINVAL;
+                }
+
+                if (ets->prio_tc[i] >= IEEE_8021QAZ_MAX_TCS) {
+                        netdev_err(dev, "Invalid TC\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (has_ets_tc && tx_bw_sum != 100) {
+                netdev_err(dev, "Total ETS bandwidth should equal 100\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int mlxsw_sp_port_pg_prio_map(struct mlxsw_sp_port *mlxsw_sp_port,
+                                     u8 *prio_tc)
+{
+        char pptb_pl[MLXSW_REG_PPTB_LEN];
+        int i;
+
+        mlxsw_reg_pptb_pack(pptb_pl, mlxsw_sp_port->local_port);
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
+                mlxsw_reg_pptb_prio_to_buff_set(pptb_pl, i, prio_tc[i]);
+        return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(pptb),
+                               pptb_pl);
+}
+
+static bool mlxsw_sp_ets_has_pg(u8 *prio_tc, u8 pg)
+{
+        int i;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
+                if (prio_tc[i] == pg)
+                        return true;
+        return false;
+}
+
+static int mlxsw_sp_port_pg_destroy(struct mlxsw_sp_port *mlxsw_sp_port,
+                                    u8 *old_prio_tc, u8 *new_prio_tc)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        char pbmc_pl[MLXSW_REG_PBMC_LEN];
+        int err, i;
+
+        mlxsw_reg_pbmc_pack(pbmc_pl, mlxsw_sp_port->local_port, 0, 0);
+        err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(pbmc), pbmc_pl);
+        if (err)
+                return err;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                u8 pg = old_prio_tc[i];
+
+                if (!mlxsw_sp_ets_has_pg(new_prio_tc, pg))
+                        mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl, pg, 0);
+        }
+
+        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pbmc), pbmc_pl);
+}
+
+static int mlxsw_sp_port_headroom_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                      struct ieee_ets *ets)
+{
+        bool pause_en = mlxsw_sp_port_is_pause_en(mlxsw_sp_port);
+        struct ieee_ets *my_ets = mlxsw_sp_port->dcb.ets;
+        struct net_device *dev = mlxsw_sp_port->dev;
+        int err;
+
+        /* Create the required PGs, but don't destroy existing ones, as
+         * traffic is still directed to them.
+         */
+        err = __mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu,
+                                           ets->prio_tc, pause_en,
+                                           mlxsw_sp_port->dcb.pfc);
+        if (err) {
+                netdev_err(dev, "Failed to configure port's headroom\n");
+                return err;
+        }
+
+        err = mlxsw_sp_port_pg_prio_map(mlxsw_sp_port, ets->prio_tc);
+        if (err) {
+                netdev_err(dev, "Failed to set PG-priority mapping\n");
+                goto err_port_prio_pg_map;
+        }
+
+        err = mlxsw_sp_port_pg_destroy(mlxsw_sp_port, my_ets->prio_tc,
+                                       ets->prio_tc);
+        if (err)
+                netdev_warn(dev, "Failed to remove ununsed PGs\n");
+
+        return 0;
+
+err_port_prio_pg_map:
+        mlxsw_sp_port_pg_destroy(mlxsw_sp_port, ets->prio_tc, my_ets->prio_tc);
+        return err;
+}
+
+static int __mlxsw_sp_dcbnl_ieee_setets(struct mlxsw_sp_port *mlxsw_sp_port,
+                                        struct ieee_ets *ets)
+{
+        struct ieee_ets *my_ets = mlxsw_sp_port->dcb.ets;
+        struct net_device *dev = mlxsw_sp_port->dev;
+        int i, err;
+
+        /* Egress configuration. */
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                bool dwrr = ets->tc_tsa[i] == IEEE_8021QAZ_TSA_ETS;
+                u8 weight = ets->tc_tx_bw[i];
+
+                err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
+                                            MLXSW_REG_QEEC_HIERARCY_SUBGROUP, i,
+                                            0, dwrr, weight);
+                if (err) {
+                        netdev_err(dev, "Failed to link subgroup ETS element %d to group\n",
+                                   i);
+                        goto err_port_ets_set;
+                }
+        }
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_prio_tc_set(mlxsw_sp_port, i,
+                                                ets->prio_tc[i]);
+                if (err) {
+                        netdev_err(dev, "Failed to map prio %d to TC %d\n", i,
+                                   ets->prio_tc[i]);
+                        goto err_port_prio_tc_set;
+                }
+        }
+
+        /* Ingress configuration. */
+        err = mlxsw_sp_port_headroom_set(mlxsw_sp_port, ets);
+        if (err)
+                goto err_port_headroom_set;
+
+        return 0;
+
+err_port_headroom_set:
+        i = IEEE_8021QAZ_MAX_TCS;
+err_port_prio_tc_set:
+        for (i--; i >= 0; i--)
+                mlxsw_sp_port_prio_tc_set(mlxsw_sp_port, i, my_ets->prio_tc[i]);
+        i = IEEE_8021QAZ_MAX_TCS;
+err_port_ets_set:
+        for (i--; i >= 0; i--) {
+                bool dwrr = my_ets->tc_tsa[i] == IEEE_8021QAZ_TSA_ETS;
+                u8 weight = my_ets->tc_tx_bw[i];
+
+                err = mlxsw_sp_port_ets_set(mlxsw_sp_port,
+                                            MLXSW_REG_QEEC_HIERARCY_SUBGROUP, i,
+                                            0, dwrr, weight);
+        }
+        return err;
+}
+
+static int mlxsw_sp_dcbnl_ieee_setets(struct net_device *dev,
+                                      struct ieee_ets *ets)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        int err;
+
+        err = mlxsw_sp_port_ets_validate(mlxsw_sp_port, ets);
+        if (err)
+                return err;
+
+        err = __mlxsw_sp_dcbnl_ieee_setets(mlxsw_sp_port, ets);
+        if (err)
+                return err;
+
+        memcpy(mlxsw_sp_port->dcb.ets, ets, sizeof(*ets));
+
+        return 0;
+}
+
+static int mlxsw_sp_dcbnl_ieee_getmaxrate(struct net_device *dev,
+                                          struct ieee_maxrate *maxrate)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+
+        memcpy(maxrate, mlxsw_sp_port->dcb.maxrate, sizeof(*maxrate));
+
+        return 0;
+}
+
+static int mlxsw_sp_dcbnl_ieee_setmaxrate(struct net_device *dev,
+                                          struct ieee_maxrate *maxrate)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        struct ieee_maxrate *my_maxrate = mlxsw_sp_port->dcb.maxrate;
+        int err, i;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_ets_maxrate_set(mlxsw_sp_port,
+                                                    MLXSW_REG_QEEC_HIERARCY_SUBGROUP,
+                                                    i, 0,
+                                                    maxrate->tc_maxrate[i]);
+                if (err) {
+                        netdev_err(dev, "Failed to set maxrate for TC %d\n", i);
+                        goto err_port_ets_maxrate_set;
+                }
+        }
+
+        memcpy(mlxsw_sp_port->dcb.maxrate, maxrate, sizeof(*maxrate));
+
+        return 0;
+
+err_port_ets_maxrate_set:
+        for (i--; i >= 0; i--)
+                mlxsw_sp_port_ets_maxrate_set(mlxsw_sp_port,
+                                              MLXSW_REG_QEEC_HIERARCY_SUBGROUP,
+                                              i, 0, my_maxrate->tc_maxrate[i]);
+        return err;
+}
+
+static int mlxsw_sp_port_pfc_cnt_get(struct mlxsw_sp_port *mlxsw_sp_port,
+                                     u8 prio)
+{
+        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
+        struct ieee_pfc *my_pfc = mlxsw_sp_port->dcb.pfc;
+        char ppcnt_pl[MLXSW_REG_PPCNT_LEN];
+        int err;
+
+        mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sp_port->local_port,
+                             MLXSW_REG_PPCNT_PRIO_CNT, prio);
+        err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ppcnt), ppcnt_pl);
+        if (err)
+                return err;
+
+        my_pfc->requests[prio] = mlxsw_reg_ppcnt_tx_pause_get(ppcnt_pl);
+        my_pfc->indications[prio] = mlxsw_reg_ppcnt_rx_pause_get(ppcnt_pl);
+
+        return 0;
+}
+
+static int mlxsw_sp_dcbnl_ieee_getpfc(struct net_device *dev,
+                                      struct ieee_pfc *pfc)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        int err, i;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
+                err = mlxsw_sp_port_pfc_cnt_get(mlxsw_sp_port, i);
+                if (err) {
+                        netdev_err(dev, "Failed to get PFC count for priority %d\n",
+                                   i);
+                        return err;
+                }
+        }
+
+        memcpy(pfc, mlxsw_sp_port->dcb.pfc, sizeof(*pfc));
+
+        return 0;
+}
+
+static int mlxsw_sp_port_pfc_set(struct mlxsw_sp_port *mlxsw_sp_port,
+                                 struct ieee_pfc *pfc)
+{
+        char pfcc_pl[MLXSW_REG_PFCC_LEN];
+
+        mlxsw_reg_pfcc_pack(pfcc_pl, mlxsw_sp_port->local_port);
+        mlxsw_reg_pfcc_prio_pack(pfcc_pl, pfc->pfc_en);
+
+        return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(pfcc),
+                               pfcc_pl);
+}
+
+static int mlxsw_sp_dcbnl_ieee_setpfc(struct net_device *dev,
+                                      struct ieee_pfc *pfc)
+{
+        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
+        int err;
+
+        if (mlxsw_sp_port->link.tx_pause || mlxsw_sp_port->link.rx_pause) {
+                netdev_err(dev, "PAUSE frames already enabled on port\n");
+                return -EINVAL;
+        }
+
+        err = __mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu,
+                                           mlxsw_sp_port->dcb.ets->prio_tc,
+                                           false, pfc);
+        if (err) {
+                netdev_err(dev, "Failed to configure port's headroom for PFC\n");
+                return err;
+        }
+
+        err = mlxsw_sp_port_pfc_set(mlxsw_sp_port, pfc);
+        if (err) {
+                netdev_err(dev, "Failed to configure PFC\n");
+                goto err_port_pfc_set;
+        }
+
+        memcpy(mlxsw_sp_port->dcb.pfc, pfc, sizeof(*pfc));
+
+        return 0;
+
+err_port_pfc_set:
+        __mlxsw_sp_port_headroom_set(mlxsw_sp_port, dev->mtu,
+                                     mlxsw_sp_port->dcb.ets->prio_tc, false,
+                                     mlxsw_sp_port->dcb.pfc);
+        return err;
+}
+
+static const struct dcbnl_rtnl_ops mlxsw_sp_dcbnl_ops = {
+        .ieee_getets            = mlxsw_sp_dcbnl_ieee_getets,
+        .ieee_setets            = mlxsw_sp_dcbnl_ieee_setets,
+        .ieee_getmaxrate        = mlxsw_sp_dcbnl_ieee_getmaxrate,
+        .ieee_setmaxrate        = mlxsw_sp_dcbnl_ieee_setmaxrate,
+        .ieee_getpfc            = mlxsw_sp_dcbnl_ieee_getpfc,
+        .ieee_setpfc            = mlxsw_sp_dcbnl_ieee_setpfc,
+
+        .getdcbx                = mlxsw_sp_dcbnl_getdcbx,
+        .setdcbx                = mlxsw_sp_dcbnl_setdcbx,
+};
+
+static int mlxsw_sp_port_ets_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        mlxsw_sp_port->dcb.ets = kzalloc(sizeof(*mlxsw_sp_port->dcb.ets),
+                                         GFP_KERNEL);
+        if (!mlxsw_sp_port->dcb.ets)
+                return -ENOMEM;
+
+        mlxsw_sp_port->dcb.ets->ets_cap = IEEE_8021QAZ_MAX_TCS;
+
+        return 0;
+}
+
+static void mlxsw_sp_port_ets_fini(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        kfree(mlxsw_sp_port->dcb.ets);
+}
+
+static int mlxsw_sp_port_maxrate_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        int i;
+
+        mlxsw_sp_port->dcb.maxrate = kmalloc(sizeof(*mlxsw_sp_port->dcb.maxrate),
+                                             GFP_KERNEL);
+        if (!mlxsw_sp_port->dcb.maxrate)
+                return -ENOMEM;
+
+        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
+                mlxsw_sp_port->dcb.maxrate->tc_maxrate[i] = MLXSW_REG_QEEC_MAS_DIS;
+
+        return 0;
+}
+
+static void mlxsw_sp_port_maxrate_fini(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        kfree(mlxsw_sp_port->dcb.maxrate);
+}
+
+static int mlxsw_sp_port_pfc_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        mlxsw_sp_port->dcb.pfc = kzalloc(sizeof(*mlxsw_sp_port->dcb.pfc),
+                                         GFP_KERNEL);
+        if (!mlxsw_sp_port->dcb.pfc)
+                return -ENOMEM;
+
+        mlxsw_sp_port->dcb.pfc->pfc_cap = IEEE_8021QAZ_MAX_TCS;
+
+        return 0;
+}
+
+static void mlxsw_sp_port_pfc_fini(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        kfree(mlxsw_sp_port->dcb.pfc);
+}
+
+int mlxsw_sp_port_dcb_init(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        int err;
+
+        err = mlxsw_sp_port_ets_init(mlxsw_sp_port);
+        if (err)
+                return err;
+        err = mlxsw_sp_port_maxrate_init(mlxsw_sp_port);
+        if (err)
+                goto err_port_maxrate_init;
+        err = mlxsw_sp_port_pfc_init(mlxsw_sp_port);
+        if (err)
+                goto err_port_pfc_init;
+
+        mlxsw_sp_port->dev->dcbnl_ops = &mlxsw_sp_dcbnl_ops;
+
+        return 0;
+
+err_port_pfc_init:
+        mlxsw_sp_port_maxrate_fini(mlxsw_sp_port);
+err_port_maxrate_init:
+        mlxsw_sp_port_ets_fini(mlxsw_sp_port);
+        return err;
+}
+
+void mlxsw_sp_port_dcb_fini(struct mlxsw_sp_port *mlxsw_sp_port)
+{
+        mlxsw_sp_port_pfc_fini(mlxsw_sp_port);
+        mlxsw_sp_port_maxrate_fini(mlxsw_sp_port);
+        mlxsw_sp_port_ets_fini(mlxsw_sp_port);
+}
diff --git a/drivers/net/ethernet/mellanox/mlxsw/switchx2.c b/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
index 7a60a26759b6..3842eab9449a 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/switchx2.c
@@ -43,7 +43,6 @@
 #include <linux/device.h>
 #include <linux/skbuff.h>
 #include <linux/if_vlan.h>
-#include <net/devlink.h>
 #include <net/switchdev.h>
 #include <generated/utsrelease.h>
 
@@ -75,11 +74,11 @@ struct mlxsw_sx_port_pcpu_stats {
 };
 
 struct mlxsw_sx_port {
+        struct mlxsw_core_port core_port; /* must be first */
         struct net_device *dev;
         struct mlxsw_sx_port_pcpu_stats __percpu *pcpu_stats;
         struct mlxsw_sx *mlxsw_sx;
         u8 local_port;
-        struct devlink_port devlink_port;
 };
 
 /* tx_hdr_version
@@ -303,7 +302,7 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
         u64 len;
         int err;
 
-        if (mlxsw_core_skb_transmit_busy(mlxsw_sx, &tx_info))
+        if (mlxsw_core_skb_transmit_busy(mlxsw_sx->core, &tx_info))
                 return NETDEV_TX_BUSY;
 
         if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
@@ -321,7 +320,7 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
         /* Due to a race we might fail here because of a full queue. In that
          * unlikely case we simply drop the packet.
          */
-        err = mlxsw_core_skb_transmit(mlxsw_sx, skb, &tx_info);
+        err = mlxsw_core_skb_transmit(mlxsw_sx->core, skb, &tx_info);
 
         if (!err) {
                 pcpu_stats = this_cpu_ptr(mlxsw_sx_port->pcpu_stats);
@@ -518,7 +517,8 @@ static void mlxsw_sx_port_get_stats(struct net_device *dev,
         int i;
         int err;
 
-        mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sx_port->local_port);
+        mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sx_port->local_port,
+                             MLXSW_REG_PPCNT_IEEE_8023_CNT, 0);
         err = mlxsw_reg_query(mlxsw_sx->core, MLXSW_REG(ppcnt), ppcnt_pl);
         for (i = 0; i < MLXSW_SX_PORT_HW_STATS_LEN; i++)
                 data[i] = !err ? mlxsw_sx_port_hw_stats[i].getter(ppcnt_pl) : 0;
@@ -955,9 +955,7 @@ mlxsw_sx_port_mac_learning_mode_set(struct mlxsw_sx_port *mlxsw_sx_port,
 
 static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
 {
-        struct devlink *devlink = priv_to_devlink(mlxsw_sx->core);
         struct mlxsw_sx_port *mlxsw_sx_port;
-        struct devlink_port *devlink_port;
         struct net_device *dev;
         bool usable;
         int err;
@@ -1011,14 +1009,6 @@ static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
                 goto port_not_usable;
         }
 
-        devlink_port = &mlxsw_sx_port->devlink_port;
-        err = devlink_port_register(devlink, devlink_port, local_port);
-        if (err) {
-                dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to register devlink port\n",
-                        mlxsw_sx_port->local_port);
-                goto err_devlink_port_register;
-        }
-
         err = mlxsw_sx_port_system_port_mapping_set(mlxsw_sx_port);
         if (err) {
                 dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to set system port mapping\n",
@@ -1076,11 +1066,19 @@ static int mlxsw_sx_port_create(struct mlxsw_sx *mlxsw_sx, u8 local_port)
                 goto err_register_netdev;
         }
 
-        devlink_port_type_eth_set(devlink_port, dev);
+        err = mlxsw_core_port_init(mlxsw_sx->core, &mlxsw_sx_port->core_port,
+                                   mlxsw_sx_port->local_port, dev, false, 0);
+        if (err) {
+                dev_err(mlxsw_sx->bus_info->dev, "Port %d: Failed to init core port\n",
+                        mlxsw_sx_port->local_port);
+                goto err_core_port_init;
+        }
 
         mlxsw_sx->ports[local_port] = mlxsw_sx_port;
         return 0;
 
+err_core_port_init:
+        unregister_netdev(dev);
 err_register_netdev:
 err_port_mac_learning_mode_set:
 err_port_stp_state_set:
@@ -1089,8 +1087,6 @@ err_port_mtu_set:
 err_port_speed_set:
 err_port_swid_set:
 err_port_system_port_mapping_set:
-        devlink_port_unregister(&mlxsw_sx_port->devlink_port);
-err_devlink_port_register:
 port_not_usable:
 err_port_module_check:
 err_dev_addr_get:
@@ -1103,15 +1099,12 @@ err_alloc_stats:
 static void mlxsw_sx_port_remove(struct mlxsw_sx *mlxsw_sx, u8 local_port)
 {
         struct mlxsw_sx_port *mlxsw_sx_port = mlxsw_sx->ports[local_port];
-        struct devlink_port *devlink_port;
 
         if (!mlxsw_sx_port)
                 return;
-        devlink_port = &mlxsw_sx_port->devlink_port;
-        devlink_port_type_clear(devlink_port);
+        mlxsw_core_port_fini(&mlxsw_sx_port->core_port);
         unregister_netdev(mlxsw_sx_port->dev); /* This calls ndo_stop */
         mlxsw_sx_port_swid_set(mlxsw_sx_port, MLXSW_PORT_SWID_DISABLED_PORT);
-        devlink_port_unregister(devlink_port);
         free_percpu(mlxsw_sx_port->pcpu_stats);
         free_netdev(mlxsw_sx_port->dev);
 }
@@ -1454,10 +1447,10 @@ static int mlxsw_sx_flood_init(struct mlxsw_sx *mlxsw_sx)
         return mlxsw_reg_write(mlxsw_sx->core, MLXSW_REG(sgcr), sgcr_pl);
 }
 
-static int mlxsw_sx_init(void *priv, struct mlxsw_core *mlxsw_core,
+static int mlxsw_sx_init(struct mlxsw_core *mlxsw_core,
                          const struct mlxsw_bus_info *mlxsw_bus_info)
 {
-        struct mlxsw_sx *mlxsw_sx = priv;
+        struct mlxsw_sx *mlxsw_sx = mlxsw_core_driver_priv(mlxsw_core);
         int err;
 
         mlxsw_sx->core = mlxsw_core;
@@ -1504,9 +1497,9 @@ err_event_register:
         return err;
 }
 
-static void mlxsw_sx_fini(void *priv)
+static void mlxsw_sx_fini(struct mlxsw_core *mlxsw_core)
 {
-        struct mlxsw_sx *mlxsw_sx = priv;
+        struct mlxsw_sx *mlxsw_sx = mlxsw_core_driver_priv(mlxsw_core);
 
         mlxsw_sx_traps_fini(mlxsw_sx);
         mlxsw_sx_event_unregister(mlxsw_sx, MLXSW_TRAP_ID_PUDE);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net.h b/drivers/net/ethernet/netronome/nfp/nfp_net.h
index ab264e1bccd0..3d53fcf323eb 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net.h
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net.h
@@ -45,7 +45,7 @@
 #include <linux/interrupt.h>
 #include <linux/netdevice.h>
 #include <linux/pci.h>
-#include <asm-generic/io-64-nonatomic-hi-lo.h>
+#include <linux/io-64-nonatomic-hi-lo.h>
 
 #include "nfp_net_ctrl.h"
 
@@ -298,6 +298,8 @@ struct nfp_net_rx_buf {
  * @rxds:       Virtual address of FL/RX ring in host memory
  * @dma:        DMA address of the FL/RX ring
  * @size:       Size, in bytes, of the FL/RX ring (needed to free)
+ * @bufsz:      Buffer allocation size for convenience of management routines
+ *              (NOTE: this is in second cache line, do not use on fast path!)
  */
 struct nfp_net_rx_ring {
         struct nfp_net_r_vector *r_vec;
@@ -319,6 +321,7 @@ struct nfp_net_rx_ring {
 
         dma_addr_t dma;
         unsigned int size;
+        unsigned int bufsz;
 } ____cacheline_aligned;
 
 /**
@@ -472,6 +475,9 @@ struct nfp_net {
 
         u32 rx_offset;
 
+        struct nfp_net_tx_ring *tx_rings;
+        struct nfp_net_rx_ring *rx_rings;
+
 #ifdef CONFIG_PCI_IOV
         unsigned int num_vfs;
         struct vf_data_storage *vfinfo;
@@ -504,9 +510,6 @@ struct nfp_net {
         int txd_cnt;
         int rxd_cnt;
 
-        struct nfp_net_tx_ring tx_rings[NFP_NET_MAX_TX_RINGS];
-        struct nfp_net_rx_ring rx_rings[NFP_NET_MAX_RX_RINGS];
-
         u8 num_irqs;
         u8 num_r_vecs;
         struct nfp_net_r_vector r_vecs[NFP_NET_MAX_TX_RINGS];
@@ -721,6 +724,7 @@ void nfp_net_rss_write_key(struct nfp_net *nn);
 void nfp_net_coalesce_write_cfg(struct nfp_net *nn);
 int nfp_net_irqs_alloc(struct nfp_net *nn);
 void nfp_net_irqs_disable(struct nfp_net *nn);
+int nfp_net_set_ring_size(struct nfp_net *nn, u32 rxd_cnt, u32 txd_cnt);
 
 #ifdef CONFIG_NFP_NET_DEBUG
 void nfp_net_debugfs_create(void);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index 43c618bafdb6..0bdff390c958 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -347,12 +347,18 @@ static irqreturn_t nfp_net_irq_exn(int irq, void *data)
 /**
  * nfp_net_tx_ring_init() - Fill in the boilerplate for a TX ring
  * @tx_ring:  TX ring structure
+ * @r_vec:    IRQ vector servicing this ring
+ * @idx:      Ring index
  */
-static void nfp_net_tx_ring_init(struct nfp_net_tx_ring *tx_ring)
+static void
+nfp_net_tx_ring_init(struct nfp_net_tx_ring *tx_ring,
+                     struct nfp_net_r_vector *r_vec, unsigned int idx)
 {
-        struct nfp_net_r_vector *r_vec = tx_ring->r_vec;
         struct nfp_net *nn = r_vec->nfp_net;
 
+        tx_ring->idx = idx;
+        tx_ring->r_vec = r_vec;
+
         tx_ring->qcidx = tx_ring->idx * nn->stride_tx;
         tx_ring->qcp_q = nn->tx_bar + NFP_QCP_QUEUE_OFF(tx_ring->qcidx);
 }
@@ -360,12 +366,18 @@ static void nfp_net_tx_ring_init(struct nfp_net_tx_ring *tx_ring)
 /**
  * nfp_net_rx_ring_init() - Fill in the boilerplate for a RX ring
  * @rx_ring:  RX ring structure
+ * @r_vec:    IRQ vector servicing this ring
+ * @idx:      Ring index
  */
-static void nfp_net_rx_ring_init(struct nfp_net_rx_ring *rx_ring)
+static void
+nfp_net_rx_ring_init(struct nfp_net_rx_ring *rx_ring,
+                     struct nfp_net_r_vector *r_vec, unsigned int idx)
 {
-        struct nfp_net_r_vector *r_vec = rx_ring->r_vec;
         struct nfp_net *nn = r_vec->nfp_net;
 
+        rx_ring->idx = idx;
+        rx_ring->r_vec = r_vec;
+
         rx_ring->fl_qcidx = rx_ring->idx * nn->stride_rx;
         rx_ring->rx_qcidx = rx_ring->fl_qcidx + (nn->stride_rx - 1);
 
@@ -401,16 +413,6 @@ static void nfp_net_irqs_assign(struct net_device *netdev)
                 r_vec->irq_idx = NFP_NET_NON_Q_VECTORS + r;
 
                 cpumask_set_cpu(r, &r_vec->affinity_mask);
-
-                r_vec->tx_ring = &nn->tx_rings[r];
-                nn->tx_rings[r].idx = r;
-                nn->tx_rings[r].r_vec = r_vec;
-                nfp_net_tx_ring_init(r_vec->tx_ring);
-
-                r_vec->rx_ring = &nn->rx_rings[r];
-                nn->rx_rings[r].idx = r;
-                nn->rx_rings[r].r_vec = r_vec;
-                nfp_net_rx_ring_init(r_vec->rx_ring);
         }
 }
 
@@ -865,61 +867,59 @@ static void nfp_net_tx_complete(struct nfp_net_tx_ring *tx_ring)
 }
 
 /**
- * nfp_net_tx_flush() - Free any untransmitted buffers currently on the TX ring
- * @tx_ring:     TX ring structure
+ * nfp_net_tx_ring_reset() - Free any untransmitted buffers and reset pointers
+ * @nn:         NFP Net device
+ * @tx_ring:    TX ring structure
  *
  * Assumes that the device is stopped
  */
-static void nfp_net_tx_flush(struct nfp_net_tx_ring *tx_ring)
+static void
+nfp_net_tx_ring_reset(struct nfp_net *nn, struct nfp_net_tx_ring *tx_ring)
 {
-        struct nfp_net_r_vector *r_vec = tx_ring->r_vec;
-        struct nfp_net *nn = r_vec->nfp_net;
-        struct pci_dev *pdev = nn->pdev;
         const struct skb_frag_struct *frag;
         struct netdev_queue *nd_q;
-        struct sk_buff *skb;
-        int nr_frags;
-        int fidx;
-        int idx;
+        struct pci_dev *pdev = nn->pdev;
 
         while (tx_ring->rd_p != tx_ring->wr_p) {
-                idx = tx_ring->rd_p % tx_ring->cnt;
+                int nr_frags, fidx, idx;
+                struct sk_buff *skb;
 
+                idx = tx_ring->rd_p % tx_ring->cnt;
                 skb = tx_ring->txbufs[idx].skb;
-                if (skb) {
-                        nr_frags = skb_shinfo(skb)->nr_frags;
-                        fidx = tx_ring->txbufs[idx].fidx;
-
-                        if (fidx == -1) {
-                                /* unmap head */
-                                dma_unmap_single(&pdev->dev,
-                                                 tx_ring->txbufs[idx].dma_addr,
-                                                 skb_headlen(skb),
-                                                 DMA_TO_DEVICE);
-                        } else {
-                                /* unmap fragment */
-                                frag = &skb_shinfo(skb)->frags[fidx];
-                                dma_unmap_page(&pdev->dev,
-                                               tx_ring->txbufs[idx].dma_addr,
-                                               skb_frag_size(frag),
-                                               DMA_TO_DEVICE);
-                        }
-
-                        /* check for last gather fragment */
-                        if (fidx == nr_frags - 1)
-                                dev_kfree_skb_any(skb);
-
-                        tx_ring->txbufs[idx].dma_addr = 0;
-                        tx_ring->txbufs[idx].skb = NULL;
-                        tx_ring->txbufs[idx].fidx = -2;
+                nr_frags = skb_shinfo(skb)->nr_frags;
+                fidx = tx_ring->txbufs[idx].fidx;
+
+                if (fidx == -1) {
+                        /* unmap head */
+                        dma_unmap_single(&pdev->dev,
+                                         tx_ring->txbufs[idx].dma_addr,
+                                         skb_headlen(skb), DMA_TO_DEVICE);
+                } else {
+                        /* unmap fragment */
+                        frag = &skb_shinfo(skb)->frags[fidx];
+                        dma_unmap_page(&pdev->dev,
+                                       tx_ring->txbufs[idx].dma_addr,
+                                       skb_frag_size(frag), DMA_TO_DEVICE);
                 }
 
-                memset(&tx_ring->txds[idx], 0, sizeof(tx_ring->txds[idx]));
+                /* check for last gather fragment */
+                if (fidx == nr_frags - 1)
+                        dev_kfree_skb_any(skb);
+
+                tx_ring->txbufs[idx].dma_addr = 0;
+                tx_ring->txbufs[idx].skb = NULL;
+                tx_ring->txbufs[idx].fidx = -2;
 
                 tx_ring->qcp_rd_p++;
                 tx_ring->rd_p++;
         }
 
+        memset(tx_ring->txds, 0, sizeof(*tx_ring->txds) * tx_ring->cnt);
+        tx_ring->wr_p = 0;
+        tx_ring->rd_p = 0;
+        tx_ring->qcp_rd_p = 0;
+        tx_ring->wr_ptr_add = 0;
+
         nd_q = netdev_get_tx_queue(nn->netdev, tx_ring->idx);
         netdev_tx_reset_queue(nd_q);
 }
@@ -957,25 +957,27 @@ static inline int nfp_net_rx_space(struct nfp_net_rx_ring *rx_ring)
  * nfp_net_rx_alloc_one() - Allocate and map skb for RX
  * @rx_ring:    RX ring structure of the skb
  * @dma_addr:   Pointer to storage for DMA address (output param)
+ * @fl_bufsz:   size of freelist buffers
  *
  * This function will allcate a new skb, map it for DMA.
  *
  * Return: allocated skb or NULL on failure.
  */
 static struct sk_buff *
-nfp_net_rx_alloc_one(struct nfp_net_rx_ring *rx_ring, dma_addr_t *dma_addr)
+nfp_net_rx_alloc_one(struct nfp_net_rx_ring *rx_ring, dma_addr_t *dma_addr,
+                     unsigned int fl_bufsz)
 {
         struct nfp_net *nn = rx_ring->r_vec->nfp_net;
         struct sk_buff *skb;
 
-        skb = netdev_alloc_skb(nn->netdev, nn->fl_bufsz);
+        skb = netdev_alloc_skb(nn->netdev, fl_bufsz);
         if (!skb) {
                 nn_warn_ratelimit(nn, "Failed to alloc receive SKB\n");
                 return NULL;
         }
 
         *dma_addr = dma_map_single(&nn->pdev->dev, skb->data,
-                                  nn->fl_bufsz, DMA_FROM_DEVICE);
+                                   fl_bufsz, DMA_FROM_DEVICE);
         if (dma_mapping_error(&nn->pdev->dev, *dma_addr)) {
                 dev_kfree_skb_any(skb);
                 nn_warn_ratelimit(nn, "Failed to map DMA RX buffer\n");
@@ -1020,62 +1022,101 @@ static void nfp_net_rx_give_one(struct nfp_net_rx_ring *rx_ring,
 }
 
 /**
- * nfp_net_rx_flush() - Free any buffers currently on the RX ring
- * @rx_ring:  RX ring to remove buffers from
+ * nfp_net_rx_ring_reset() - Reflect in SW state of freelist after disable
+ * @rx_ring:    RX ring structure
  *
- * Assumes that the device is stopped
+ * Warning: Do *not* call if ring buffers were never put on the FW freelist
+ *          (i.e. device was not enabled)!
  */
-static void nfp_net_rx_flush(struct nfp_net_rx_ring *rx_ring)
+static void nfp_net_rx_ring_reset(struct nfp_net_rx_ring *rx_ring)
 {
-        struct nfp_net *nn = rx_ring->r_vec->nfp_net;
-        struct pci_dev *pdev = nn->pdev;
-        int idx;
+        unsigned int wr_idx, last_idx;
 
-        while (rx_ring->rd_p != rx_ring->wr_p) {
-                idx = rx_ring->rd_p % rx_ring->cnt;
+        /* Move the empty entry to the end of the list */
+        wr_idx = rx_ring->wr_p % rx_ring->cnt;
+        last_idx = rx_ring->cnt - 1;
+        rx_ring->rxbufs[wr_idx].dma_addr = rx_ring->rxbufs[last_idx].dma_addr;
+        rx_ring->rxbufs[wr_idx].skb = rx_ring->rxbufs[last_idx].skb;
+        rx_ring->rxbufs[last_idx].dma_addr = 0;
+        rx_ring->rxbufs[last_idx].skb = NULL;
 
-                if (rx_ring->rxbufs[idx].skb) {
-                        dma_unmap_single(&pdev->dev,
-                                         rx_ring->rxbufs[idx].dma_addr,
-                                         nn->fl_bufsz, DMA_FROM_DEVICE);
-                        dev_kfree_skb_any(rx_ring->rxbufs[idx].skb);
-                        rx_ring->rxbufs[idx].dma_addr = 0;
-                        rx_ring->rxbufs[idx].skb = NULL;
-                }
+        memset(rx_ring->rxds, 0, sizeof(*rx_ring->rxds) * rx_ring->cnt);
+        rx_ring->wr_p = 0;
+        rx_ring->rd_p = 0;
+        rx_ring->wr_ptr_add = 0;
+}
 
-                memset(&rx_ring->rxds[idx], 0, sizeof(rx_ring->rxds[idx]));
+/**
+ * nfp_net_rx_ring_bufs_free() - Free any buffers currently on the RX ring
+ * @nn:         NFP Net device
+ * @rx_ring:    RX ring to remove buffers from
+ *
+ * Assumes that the device is stopped and buffers are in [0, ring->cnt - 1)
+ * entries.  After device is disabled nfp_net_rx_ring_reset() must be called
+ * to restore required ring geometry.
+ */
+static void
+nfp_net_rx_ring_bufs_free(struct nfp_net *nn, struct nfp_net_rx_ring *rx_ring)
+{
+        struct pci_dev *pdev = nn->pdev;
+        unsigned int i;
 
-                rx_ring->rd_p++;
+        for (i = 0; i < rx_ring->cnt - 1; i++) {
+                /* NULL skb can only happen when initial filling of the ring
+                 * fails to allocate enough buffers and calls here to free
+                 * already allocated ones.
+                 */
+                if (!rx_ring->rxbufs[i].skb)
+                        continue;
+
+                dma_unmap_single(&pdev->dev, rx_ring->rxbufs[i].dma_addr,
+                                 rx_ring->bufsz, DMA_FROM_DEVICE);
+                dev_kfree_skb_any(rx_ring->rxbufs[i].skb);
+                rx_ring->rxbufs[i].dma_addr = 0;
+                rx_ring->rxbufs[i].skb = NULL;
         }
 }
 
 /**
- * nfp_net_rx_fill_freelist() - Attempt filling freelist with RX buffers
- * @rx_ring: RX ring to fill
- *
- * Try to fill as many buffers as possible into freelist.  Return
- * number of buffers added.
- *
- * Return: Number of freelist buffers added.
+ * nfp_net_rx_ring_bufs_alloc() - Fill RX ring with buffers (don't give to FW)
+ * @nn:         NFP Net device
+ * @rx_ring:    RX ring to remove buffers from
  */
-static int nfp_net_rx_fill_freelist(struct nfp_net_rx_ring *rx_ring)
+static int
+nfp_net_rx_ring_bufs_alloc(struct nfp_net *nn, struct nfp_net_rx_ring *rx_ring)
 {
-        struct sk_buff *skb;
-        dma_addr_t dma_addr;
+        struct nfp_net_rx_buf *rxbufs;
+        unsigned int i;
+
+        rxbufs = rx_ring->rxbufs;
 
-        while (nfp_net_rx_space(rx_ring)) {
-                skb = nfp_net_rx_alloc_one(rx_ring, &dma_addr);
-                if (!skb) {
-                        nfp_net_rx_flush(rx_ring);
+        for (i = 0; i < rx_ring->cnt - 1; i++) {
+                rxbufs[i].skb =
+                        nfp_net_rx_alloc_one(rx_ring, &rxbufs[i].dma_addr,
+                                             rx_ring->bufsz);
+                if (!rxbufs[i].skb) {
+                        nfp_net_rx_ring_bufs_free(nn, rx_ring);
                         return -ENOMEM;
                 }
-                nfp_net_rx_give_one(rx_ring, skb, dma_addr);
         }
 
         return 0;
 }
 
 /**
+ * nfp_net_rx_ring_fill_freelist() - Give buffers from the ring to FW
+ * @rx_ring: RX ring to fill
+ */
+static void nfp_net_rx_ring_fill_freelist(struct nfp_net_rx_ring *rx_ring)
+{
+        unsigned int i;
+
+        for (i = 0; i < rx_ring->cnt - 1; i++)
+                nfp_net_rx_give_one(rx_ring, rx_ring->rxbufs[i].skb,
+                                    rx_ring->rxbufs[i].dma_addr);
+}
+
+/**
  * nfp_net_rx_csum_has_errors() - group check if rxd has any csum errors
  * @flags: RX descriptor flags field in CPU byte order
  */
@@ -1240,7 +1281,8 @@ static int nfp_net_rx(struct nfp_net_rx_ring *rx_ring, int budget)
 
                 skb = rx_ring->rxbufs[idx].skb;
 
-                new_skb = nfp_net_rx_alloc_one(rx_ring, &new_dma_addr);
+                new_skb = nfp_net_rx_alloc_one(rx_ring, &new_dma_addr,
+                                               nn->fl_bufsz);
                 if (!new_skb) {
                         nfp_net_rx_give_one(rx_ring, rx_ring->rxbufs[idx].skb,
                                             rx_ring->rxbufs[idx].dma_addr);
@@ -1349,10 +1391,6 @@ static void nfp_net_tx_ring_free(struct nfp_net_tx_ring *tx_ring)
         struct nfp_net *nn = r_vec->nfp_net;
         struct pci_dev *pdev = nn->pdev;
 
-        nn_writeq(nn, NFP_NET_CFG_TXR_ADDR(tx_ring->idx), 0);
-        nn_writeb(nn, NFP_NET_CFG_TXR_SZ(tx_ring->idx), 0);
-        nn_writeb(nn, NFP_NET_CFG_TXR_VEC(tx_ring->idx), 0);
-
         kfree(tx_ring->txbufs);
 
         if (tx_ring->txds)
@@ -1360,11 +1398,6 @@ static void nfp_net_tx_ring_free(struct nfp_net_tx_ring *tx_ring)
                                   tx_ring->txds, tx_ring->dma);
 
         tx_ring->cnt = 0;
-        tx_ring->wr_p = 0;
-        tx_ring->rd_p = 0;
-        tx_ring->qcp_rd_p = 0;
-        tx_ring->wr_ptr_add = 0;
-
         tx_ring->txbufs = NULL;
         tx_ring->txds = NULL;
         tx_ring->dma = 0;
@@ -1374,17 +1407,18 @@ static void nfp_net_tx_ring_free(struct nfp_net_tx_ring *tx_ring)
 /**
  * nfp_net_tx_ring_alloc() - Allocate resource for a TX ring
  * @tx_ring:   TX Ring structure to allocate
+ * @cnt:       Ring buffer count
  *
  * Return: 0 on success, negative errno otherwise.
  */
-static int nfp_net_tx_ring_alloc(struct nfp_net_tx_ring *tx_ring)
+static int nfp_net_tx_ring_alloc(struct nfp_net_tx_ring *tx_ring, u32 cnt)
 {
         struct nfp_net_r_vector *r_vec = tx_ring->r_vec;
         struct nfp_net *nn = r_vec->nfp_net;
         struct pci_dev *pdev = nn->pdev;
         int sz;
 
-        tx_ring->cnt = nn->txd_cnt;
+        tx_ring->cnt = cnt;
 
         tx_ring->size = sizeof(*tx_ring->txds) * tx_ring->cnt;
         tx_ring->txds = dma_zalloc_coherent(&pdev->dev, tx_ring->size,
@@ -1397,11 +1431,6 @@ static int nfp_net_tx_ring_alloc(struct nfp_net_tx_ring *tx_ring)
         if (!tx_ring->txbufs)
                 goto err_alloc;
 
-        /* Write the DMA address, size and MSI-X info to the device */
-        nn_writeq(nn, NFP_NET_CFG_TXR_ADDR(tx_ring->idx), tx_ring->dma);
-        nn_writeb(nn, NFP_NET_CFG_TXR_SZ(tx_ring->idx), ilog2(tx_ring->cnt));
-        nn_writeb(nn, NFP_NET_CFG_TXR_VEC(tx_ring->idx), r_vec->irq_idx);
-
         netif_set_xps_queue(nn->netdev, &r_vec->affinity_mask, tx_ring->idx);
 
         nn_dbg(nn, "TxQ%02d: QCidx=%02d cnt=%d dma=%#llx host=%p\n",
@@ -1415,6 +1444,59 @@ err_alloc:
         return -ENOMEM;
 }
 
+static struct nfp_net_tx_ring *
+nfp_net_shadow_tx_rings_prepare(struct nfp_net *nn, u32 buf_cnt)
+{
+        struct nfp_net_tx_ring *rings;
+        unsigned int r;
+
+        rings = kcalloc(nn->num_tx_rings, sizeof(*rings), GFP_KERNEL);
+        if (!rings)
+                return NULL;
+
+        for (r = 0; r < nn->num_tx_rings; r++) {
+                nfp_net_tx_ring_init(&rings[r], nn->tx_rings[r].r_vec, r);
+
+                if (nfp_net_tx_ring_alloc(&rings[r], buf_cnt))
+                        goto err_free_prev;
+        }
+
+        return rings;
+
+err_free_prev:
+        while (r--)
+                nfp_net_tx_ring_free(&rings[r]);
+        kfree(rings);
+        return NULL;
+}
+
+static struct nfp_net_tx_ring *
+nfp_net_shadow_tx_rings_swap(struct nfp_net *nn, struct nfp_net_tx_ring *rings)
+{
+        struct nfp_net_tx_ring *old = nn->tx_rings;
+        unsigned int r;
+
+        for (r = 0; r < nn->num_tx_rings; r++)
+                old[r].r_vec->tx_ring = &rings[r];
+
+        nn->tx_rings = rings;
+        return old;
+}
+
+static void
+nfp_net_shadow_tx_rings_free(struct nfp_net *nn, struct nfp_net_tx_ring *rings)
+{
+        unsigned int r;
+
+        if (!rings)
+                return;
+
+        for (r = 0; r < nn->num_tx_rings; r++)
+                nfp_net_tx_ring_free(&rings[r]);
+
+        kfree(rings);
+}
+
 /**
  * nfp_net_rx_ring_free() - Free resources allocated to a RX ring
  * @rx_ring:  RX ring to free
@@ -1425,10 +1507,6 @@ static void nfp_net_rx_ring_free(struct nfp_net_rx_ring *rx_ring)
         struct nfp_net *nn = r_vec->nfp_net;
         struct pci_dev *pdev = nn->pdev;
 
-        nn_writeq(nn, NFP_NET_CFG_RXR_ADDR(rx_ring->idx), 0);
-        nn_writeb(nn, NFP_NET_CFG_RXR_SZ(rx_ring->idx), 0);
-        nn_writeb(nn, NFP_NET_CFG_RXR_VEC(rx_ring->idx), 0);
-
         kfree(rx_ring->rxbufs);
 
         if (rx_ring->rxds)
@@ -1436,10 +1514,6 @@ static void nfp_net_rx_ring_free(struct nfp_net_rx_ring *rx_ring)
                                   rx_ring->rxds, rx_ring->dma);
 
         rx_ring->cnt = 0;
-        rx_ring->wr_p = 0;
-        rx_ring->rd_p = 0;
-        rx_ring->wr_ptr_add = 0;
-
         rx_ring->rxbufs = NULL;
         rx_ring->rxds = NULL;
         rx_ring->dma = 0;
@@ -1449,17 +1523,22 @@ static void nfp_net_rx_ring_free(struct nfp_net_rx_ring *rx_ring)
 /**
  * nfp_net_rx_ring_alloc() - Allocate resource for a RX ring
  * @rx_ring:  RX ring to allocate
+ * @fl_bufsz: Size of buffers to allocate
+ * @cnt:      Ring buffer count
  *
  * Return: 0 on success, negative errno otherwise.
  */
-static int nfp_net_rx_ring_alloc(struct nfp_net_rx_ring *rx_ring)
+static int
+nfp_net_rx_ring_alloc(struct nfp_net_rx_ring *rx_ring, unsigned int fl_bufsz,
+                      u32 cnt)
 {
         struct nfp_net_r_vector *r_vec = rx_ring->r_vec;
         struct nfp_net *nn = r_vec->nfp_net;
         struct pci_dev *pdev = nn->pdev;
         int sz;
 
-        rx_ring->cnt = nn->rxd_cnt;
+        rx_ring->cnt = cnt;
+        rx_ring->bufsz = fl_bufsz;
 
         rx_ring->size = sizeof(*rx_ring->rxds) * rx_ring->cnt;
         rx_ring->rxds = dma_zalloc_coherent(&pdev->dev, rx_ring->size,
@@ -1472,11 +1551,6 @@ static int nfp_net_rx_ring_alloc(struct nfp_net_rx_ring *rx_ring)
         if (!rx_ring->rxbufs)
                 goto err_alloc;
 
-        /* Write the DMA address, size and MSI-X info to the device */
-        nn_writeq(nn, NFP_NET_CFG_RXR_ADDR(rx_ring->idx), rx_ring->dma);
-        nn_writeb(nn, NFP_NET_CFG_RXR_SZ(rx_ring->idx), ilog2(rx_ring->cnt));
-        nn_writeb(nn, NFP_NET_CFG_RXR_VEC(rx_ring->idx), r_vec->irq_idx);
-
         nn_dbg(nn, "RxQ%02d: FlQCidx=%02d RxQCidx=%02d cnt=%d dma=%#llx host=%p\n",
                rx_ring->idx, rx_ring->fl_qcidx, rx_ring->rx_qcidx,
                rx_ring->cnt, (unsigned long long)rx_ring->dma, rx_ring->rxds);
@@ -1488,91 +1562,109 @@ err_alloc:
         return -ENOMEM;
 }
 
-static void __nfp_net_free_rings(struct nfp_net *nn, unsigned int n_free)
+static struct nfp_net_rx_ring *
+nfp_net_shadow_rx_rings_prepare(struct nfp_net *nn, unsigned int fl_bufsz,
+                                u32 buf_cnt)
 {
-        struct nfp_net_r_vector *r_vec;
-        struct msix_entry *entry;
+        struct nfp_net_rx_ring *rings;
+        unsigned int r;
 
-        while (n_free--) {
-                r_vec = &nn->r_vecs[n_free];
-                entry = &nn->irq_entries[r_vec->irq_idx];
+        rings = kcalloc(nn->num_rx_rings, sizeof(*rings), GFP_KERNEL);
+        if (!rings)
+                return NULL;
 
-                nfp_net_rx_ring_free(r_vec->rx_ring);
-                nfp_net_tx_ring_free(r_vec->tx_ring);
+        for (r = 0; r < nn->num_rx_rings; r++) {
+                nfp_net_rx_ring_init(&rings[r], nn->rx_rings[r].r_vec, r);
 
-                irq_set_affinity_hint(entry->vector, NULL);
-                free_irq(entry->vector, r_vec);
+                if (nfp_net_rx_ring_alloc(&rings[r], fl_bufsz, buf_cnt))
+                        goto err_free_prev;
 
-                netif_napi_del(&r_vec->napi);
+                if (nfp_net_rx_ring_bufs_alloc(nn, &rings[r]))
+                        goto err_free_ring;
+        }
+
+        return rings;
+
+err_free_prev:
+        while (r--) {
+                nfp_net_rx_ring_bufs_free(nn, &rings[r]);
+err_free_ring:
+                nfp_net_rx_ring_free(&rings[r]);
         }
+        kfree(rings);
+        return NULL;
 }
 
-/**
- * nfp_net_free_rings() - Free all ring resources
- * @nn:      NFP Net device to reconfigure
- */
-static void nfp_net_free_rings(struct nfp_net *nn)
+static struct nfp_net_rx_ring *
+nfp_net_shadow_rx_rings_swap(struct nfp_net *nn, struct nfp_net_rx_ring *rings)
 {
-        __nfp_net_free_rings(nn, nn->num_r_vecs);
+        struct nfp_net_rx_ring *old = nn->rx_rings;
+        unsigned int r;
+
+        for (r = 0; r < nn->num_rx_rings; r++)
+                old[r].r_vec->rx_ring = &rings[r];
+
+        nn->rx_rings = rings;
+        return old;
 }
 
-/**
- * nfp_net_alloc_rings() - Allocate resources for RX and TX rings
- * @nn:      NFP Net device to reconfigure
- *
- * Return: 0 on success or negative errno on error.
- */
-static int nfp_net_alloc_rings(struct nfp_net *nn)
+static void
+nfp_net_shadow_rx_rings_free(struct nfp_net *nn, struct nfp_net_rx_ring *rings)
 {
-        struct nfp_net_r_vector *r_vec;
-        struct msix_entry *entry;
-        int err;
-        int r;
+        unsigned int r;
+
+        if (!rings)
+                return;
 
         for (r = 0; r < nn->num_r_vecs; r++) {
-                r_vec = &nn->r_vecs[r];
-                entry = &nn->irq_entries[r_vec->irq_idx];
-
-                /* Setup NAPI */
-                netif_napi_add(nn->netdev, &r_vec->napi,
-                               nfp_net_poll, NAPI_POLL_WEIGHT);
-
-                snprintf(r_vec->name, sizeof(r_vec->name),
-                         "%s-rxtx-%d", nn->netdev->name, r);
-                err = request_irq(entry->vector, r_vec->handler, 0,
-                                  r_vec->name, r_vec);
-                if (err) {
-                        nn_dbg(nn, "Error requesting IRQ %d\n", entry->vector);
-                        goto err_napi_del;
-                }
+                nfp_net_rx_ring_bufs_free(nn, &rings[r]);
+                nfp_net_rx_ring_free(&rings[r]);
+        }
 
-                irq_set_affinity_hint(entry->vector, &r_vec->affinity_mask);
+        kfree(rings);
+}
 
-                nn_dbg(nn, "RV%02d: irq=%03d/%03d\n",
-                       r, entry->vector, entry->entry);
+static int
+nfp_net_prepare_vector(struct nfp_net *nn, struct nfp_net_r_vector *r_vec,
+                       int idx)
+{
+        struct msix_entry *entry = &nn->irq_entries[r_vec->irq_idx];
+        int err;
 
-                /* Allocate TX ring resources */
-                err = nfp_net_tx_ring_alloc(r_vec->tx_ring);
-                if (err)
-                        goto err_free_irq;
+        r_vec->tx_ring = &nn->tx_rings[idx];
+        nfp_net_tx_ring_init(r_vec->tx_ring, r_vec, idx);
 
-                /* Allocate RX ring resources */
-                err = nfp_net_rx_ring_alloc(r_vec->rx_ring);
-                if (err)
-                        goto err_free_tx;
+        r_vec->rx_ring = &nn->rx_rings[idx];
+        nfp_net_rx_ring_init(r_vec->rx_ring, r_vec, idx);
+
+        snprintf(r_vec->name, sizeof(r_vec->name),
+                 "%s-rxtx-%d", nn->netdev->name, idx);
+        err = request_irq(entry->vector, r_vec->handler, 0, r_vec->name, r_vec);
+        if (err) {
+                nn_err(nn, "Error requesting IRQ %d\n", entry->vector);
+                return err;
         }
+        disable_irq(entry->vector);
+
+        /* Setup NAPI */
+        netif_napi_add(nn->netdev, &r_vec->napi,
+                       nfp_net_poll, NAPI_POLL_WEIGHT);
+
+        irq_set_affinity_hint(entry->vector, &r_vec->affinity_mask);
+
+        nn_dbg(nn, "RV%02d: irq=%03d/%03d\n", idx, entry->vector, entry->entry);
 
         return 0;
+}
+
+static void
+nfp_net_cleanup_vector(struct nfp_net *nn, struct nfp_net_r_vector *r_vec)
+{
+        struct msix_entry *entry = &nn->irq_entries[r_vec->irq_idx];
 
-err_free_tx:
-        nfp_net_tx_ring_free(r_vec->tx_ring);
-err_free_irq:
         irq_set_affinity_hint(entry->vector, NULL);
-        free_irq(entry->vector, r_vec);
-err_napi_del:
         netif_napi_del(&r_vec->napi);
-        __nfp_net_free_rings(nn, r);
-        return err;
+        free_irq(entry->vector, r_vec);
 }
 
 /**
@@ -1646,6 +1738,17 @@ static void nfp_net_write_mac_addr(struct nfp_net *nn, const u8 *mac)
                   get_unaligned_be16(nn->netdev->dev_addr + 4) << 16);
 }
 
+static void nfp_net_vec_clear_ring_data(struct nfp_net *nn, unsigned int idx)
+{
+        nn_writeq(nn, NFP_NET_CFG_RXR_ADDR(idx), 0);
+        nn_writeb(nn, NFP_NET_CFG_RXR_SZ(idx), 0);
+        nn_writeb(nn, NFP_NET_CFG_RXR_VEC(idx), 0);
+
+        nn_writeq(nn, NFP_NET_CFG_TXR_ADDR(idx), 0);
+        nn_writeb(nn, NFP_NET_CFG_TXR_SZ(idx), 0);
+        nn_writeb(nn, NFP_NET_CFG_TXR_VEC(idx), 0);
+}
+
 /**
  * nfp_net_clear_config_and_disable() - Clear control BAR and disable NFP
  * @nn:      NFP Net device to reconfigure
@@ -1653,6 +1756,7 @@ static void nfp_net_write_mac_addr(struct nfp_net *nn, const u8 *mac)
 static void nfp_net_clear_config_and_disable(struct nfp_net *nn)
 {
         u32 new_ctrl, update;
+        unsigned int r;
         int err;
 
         new_ctrl = nn->ctrl;
@@ -1669,79 +1773,40 @@ static void nfp_net_clear_config_and_disable(struct nfp_net *nn)
 
         nn_writel(nn, NFP_NET_CFG_CTRL, new_ctrl);
         err = nfp_net_reconfig(nn, update);
-        if (err) {
+        if (err)
                 nn_err(nn, "Could not disable device: %d\n", err);
-                return;
+
+        for (r = 0; r < nn->num_r_vecs; r++) {
+                nfp_net_rx_ring_reset(nn->r_vecs[r].rx_ring);
+                nfp_net_tx_ring_reset(nn, nn->r_vecs[r].tx_ring);
+                nfp_net_vec_clear_ring_data(nn, r);
         }
 
         nn->ctrl = new_ctrl;
 }
 
-/**
- * nfp_net_start_vec() - Start ring vector
- * @nn:      NFP Net device structure
- * @r_vec:   Ring vector to be started
- */
-static int nfp_net_start_vec(struct nfp_net *nn, struct nfp_net_r_vector *r_vec)
+static void
+nfp_net_vec_write_ring_data(struct nfp_net *nn, struct nfp_net_r_vector *r_vec,
+                            unsigned int idx)
 {
-        unsigned int irq_vec;
-        int err = 0;
-
-        irq_vec = nn->irq_entries[r_vec->irq_idx].vector;
-
-        disable_irq(irq_vec);
-
-        err = nfp_net_rx_fill_freelist(r_vec->rx_ring);
-        if (err) {
-                nn_err(nn, "RV%02d: couldn't allocate enough buffers\n",
-                       r_vec->irq_idx);
-                goto out;
-        }
-
-        napi_enable(&r_vec->napi);
-out:
-        enable_irq(irq_vec);
+        /* Write the DMA address, size and MSI-X info to the device */
+        nn_writeq(nn, NFP_NET_CFG_RXR_ADDR(idx), r_vec->rx_ring->dma);
+        nn_writeb(nn, NFP_NET_CFG_RXR_SZ(idx), ilog2(r_vec->rx_ring->cnt));
+        nn_writeb(nn, NFP_NET_CFG_RXR_VEC(idx), r_vec->irq_idx);
 
-        return err;
+        nn_writeq(nn, NFP_NET_CFG_TXR_ADDR(idx), r_vec->tx_ring->dma);
+        nn_writeb(nn, NFP_NET_CFG_TXR_SZ(idx), ilog2(r_vec->tx_ring->cnt));
+        nn_writeb(nn, NFP_NET_CFG_TXR_VEC(idx), r_vec->irq_idx);
 }
 
-static int nfp_net_netdev_open(struct net_device *netdev)
+static int __nfp_net_set_config_and_enable(struct nfp_net *nn)
 {
-        struct nfp_net *nn = netdev_priv(netdev);
-        int err, r;
-        u32 update = 0;
-        u32 new_ctrl;
-
-        if (nn->ctrl & NFP_NET_CFG_CTRL_ENABLE) {
-                nn_err(nn, "Dev is already enabled: 0x%08x\n", nn->ctrl);
-                return -EBUSY;
-        }
+        u32 new_ctrl, update = 0;
+        unsigned int r;
+        int err;
 
         new_ctrl = nn->ctrl;
 
-        /* Step 1: Allocate resources for rings and the like
-         * - Request interrupts
-         * - Allocate RX and TX ring resources
-         * - Setup initial RSS table
-         */
-        err = nfp_net_aux_irq_request(nn, NFP_NET_CFG_EXN, "%s-exn",
-                                      nn->exn_name, sizeof(nn->exn_name),
-                                      NFP_NET_IRQ_EXN_IDX, nn->exn_handler);
-        if (err)
-                return err;
-
-        err = nfp_net_alloc_rings(nn);
-        if (err)
-                goto err_free_exn;
-
-        err = netif_set_real_num_tx_queues(netdev, nn->num_tx_rings);
-        if (err)
-                goto err_free_rings;
-
-        err = netif_set_real_num_rx_queues(netdev, nn->num_rx_rings);
-        if (err)
-                goto err_free_rings;
-
         if (nn->cap & NFP_NET_CFG_CTRL_RSS) {
                 nfp_net_rss_write_key(nn);
                 nfp_net_rss_write_itbl(nn);
@@ -1756,22 +1821,18 @@ static int nfp_net_netdev_open(struct net_device *netdev)
                 update |= NFP_NET_CFG_UPDATE_IRQMOD;
         }
 
-        /* Step 2: Configure the NFP
-         * - Enable rings from 0 to tx_rings/rx_rings - 1.
-         * - Write MAC address (in case it changed)
-         * - Set the MTU
-         * - Set the Freelist buffer size
-         * - Enable the FW
-         */
+        for (r = 0; r < nn->num_r_vecs; r++)
+                nfp_net_vec_write_ring_data(nn, &nn->r_vecs[r], r);
+
         nn_writeq(nn, NFP_NET_CFG_TXRS_ENABLE, nn->num_tx_rings == 64 ?
                   0xffffffffffffffffULL : ((u64)1 << nn->num_tx_rings) - 1);
 
         nn_writeq(nn, NFP_NET_CFG_RXRS_ENABLE, nn->num_rx_rings == 64 ?
                   0xffffffffffffffffULL : ((u64)1 << nn->num_rx_rings) - 1);
 
-        nfp_net_write_mac_addr(nn, netdev->dev_addr);
+        nfp_net_write_mac_addr(nn, nn->netdev->dev_addr);
 
-        nn_writel(nn, NFP_NET_CFG_MTU, netdev->mtu);
+        nn_writel(nn, NFP_NET_CFG_MTU, nn->netdev->mtu);
         nn_writel(nn, NFP_NET_CFG_FLBUFSZ, nn->fl_bufsz);
 
         /* Enable device */
@@ -1784,69 +1845,213 @@ static int nfp_net_netdev_open(struct net_device *netdev)
 
         nn_writel(nn, NFP_NET_CFG_CTRL, new_ctrl);
         err = nfp_net_reconfig(nn, update);
-        if (err)
-                goto err_clear_config;
 
         nn->ctrl = new_ctrl;
 
+        for (r = 0; r < nn->num_r_vecs; r++)
+                nfp_net_rx_ring_fill_freelist(nn->r_vecs[r].rx_ring);
+
         /* Since reconfiguration requests while NFP is down are ignored we
          * have to wipe the entire VXLAN configuration and reinitialize it.
          */
         if (nn->ctrl & NFP_NET_CFG_CTRL_VXLAN) {
                 memset(&nn->vxlan_ports, 0, sizeof(nn->vxlan_ports));
                 memset(&nn->vxlan_usecnt, 0, sizeof(nn->vxlan_usecnt));
-                vxlan_get_rx_port(netdev);
+                vxlan_get_rx_port(nn->netdev);
         }
 
-        /* Step 3: Enable for kernel
-         * - put some freelist descriptors on each RX ring
-         * - enable NAPI on each ring
-         * - enable all TX queues
-         * - set link state
-         */
+        return err;
+}
+
+/**
+ * nfp_net_set_config_and_enable() - Write control BAR and enable NFP
+ * @nn:      NFP Net device to reconfigure
+ */
+static int nfp_net_set_config_and_enable(struct nfp_net *nn)
+{
+        int err;
+
+        err = __nfp_net_set_config_and_enable(nn);
+        if (err)
+                nfp_net_clear_config_and_disable(nn);
+
+        return err;
+}
+
+/**
+ * nfp_net_open_stack() - Start the device from stack's perspective
+ * @nn:      NFP Net device to reconfigure
+ */
+static void nfp_net_open_stack(struct nfp_net *nn)
+{
+        unsigned int r;
+
         for (r = 0; r < nn->num_r_vecs; r++) {
-                err = nfp_net_start_vec(nn, &nn->r_vecs[r]);
-                if (err)
-                        goto err_disable_napi;
+                napi_enable(&nn->r_vecs[r].napi);
+                enable_irq(nn->irq_entries[nn->r_vecs[r].irq_idx].vector);
         }
 
-        netif_tx_wake_all_queues(netdev);
+        netif_tx_wake_all_queues(nn->netdev);
+
+        enable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
+        nfp_net_read_link_status(nn);
+}
 
+static int nfp_net_netdev_open(struct net_device *netdev)
+{
+        struct nfp_net *nn = netdev_priv(netdev);
+        int err, r;
+
+        if (nn->ctrl & NFP_NET_CFG_CTRL_ENABLE) {
+                nn_err(nn, "Dev is already enabled: 0x%08x\n", nn->ctrl);
+                return -EBUSY;
+        }
+
+        /* Step 1: Allocate resources for rings and the like
+         * - Request interrupts
+         * - Allocate RX and TX ring resources
+         * - Setup initial RSS table
+         */
+        err = nfp_net_aux_irq_request(nn, NFP_NET_CFG_EXN, "%s-exn",
+                                      nn->exn_name, sizeof(nn->exn_name),
+                                      NFP_NET_IRQ_EXN_IDX, nn->exn_handler);
+        if (err)
+                return err;
         err = nfp_net_aux_irq_request(nn, NFP_NET_CFG_LSC, "%s-lsc",
                                       nn->lsc_name, sizeof(nn->lsc_name),
                                       NFP_NET_IRQ_LSC_IDX, nn->lsc_handler);
         if (err)
-                goto err_stop_tx;
-        nfp_net_read_link_status(nn);
+                goto err_free_exn;
+        disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
 
-        return 0;
+        nn->rx_rings = kcalloc(nn->num_rx_rings, sizeof(*nn->rx_rings),
+                               GFP_KERNEL);
+        if (!nn->rx_rings)
+                goto err_free_lsc;
+        nn->tx_rings = kcalloc(nn->num_tx_rings, sizeof(*nn->tx_rings),
+                               GFP_KERNEL);
+        if (!nn->tx_rings)
+                goto err_free_rx_rings;
 
-err_stop_tx:
-        netif_tx_disable(netdev);
-        for (r = 0; r < nn->num_r_vecs; r++)
-                nfp_net_tx_flush(nn->r_vecs[r].tx_ring);
-err_disable_napi:
-        while (r--) {
-                napi_disable(&nn->r_vecs[r].napi);
-                nfp_net_rx_flush(nn->r_vecs[r].rx_ring);
+        for (r = 0; r < nn->num_r_vecs; r++) {
+                err = nfp_net_prepare_vector(nn, &nn->r_vecs[r], r);
+                if (err)
+                        goto err_free_prev_vecs;
+
+                err = nfp_net_tx_ring_alloc(nn->r_vecs[r].tx_ring, nn->txd_cnt);
+                if (err)
+                        goto err_cleanup_vec_p;
+
+                err = nfp_net_rx_ring_alloc(nn->r_vecs[r].rx_ring,
+                                            nn->fl_bufsz, nn->rxd_cnt);
+                if (err)
+                        goto err_free_tx_ring_p;
+
+                err = nfp_net_rx_ring_bufs_alloc(nn, nn->r_vecs[r].rx_ring);
+                if (err)
+                        goto err_flush_rx_ring_p;
         }
-err_clear_config:
-        nfp_net_clear_config_and_disable(nn);
+
+        err = netif_set_real_num_tx_queues(netdev, nn->num_tx_rings);
+        if (err)
+                goto err_free_rings;
+
+        err = netif_set_real_num_rx_queues(netdev, nn->num_rx_rings);
+        if (err)
+                goto err_free_rings;
+
+        /* Step 2: Configure the NFP
+         * - Enable rings from 0 to tx_rings/rx_rings - 1.
+         * - Write MAC address (in case it changed)
+         * - Set the MTU
+         * - Set the Freelist buffer size
+         * - Enable the FW
+         */
+        err = nfp_net_set_config_and_enable(nn);
+        if (err)
+                goto err_free_rings;
+
+        /* Step 3: Enable for kernel
+         * - put some freelist descriptors on each RX ring
+         * - enable NAPI on each ring
+         * - enable all TX queues
+         * - set link state
+         */
+        nfp_net_open_stack(nn);
+
+        return 0;
+
 err_free_rings:
-        nfp_net_free_rings(nn);
+        r = nn->num_r_vecs;
+err_free_prev_vecs:
+        while (r--) {
+                nfp_net_rx_ring_bufs_free(nn, nn->r_vecs[r].rx_ring);
+err_flush_rx_ring_p:
+                nfp_net_rx_ring_free(nn->r_vecs[r].rx_ring);
+err_free_tx_ring_p:
+                nfp_net_tx_ring_free(nn->r_vecs[r].tx_ring);
+err_cleanup_vec_p:
+                nfp_net_cleanup_vector(nn, &nn->r_vecs[r]);
+        }
+        kfree(nn->tx_rings);
+err_free_rx_rings:
+        kfree(nn->rx_rings);
+err_free_lsc:
+        nfp_net_aux_irq_free(nn, NFP_NET_CFG_LSC, NFP_NET_IRQ_LSC_IDX);
 err_free_exn:
         nfp_net_aux_irq_free(nn, NFP_NET_CFG_EXN, NFP_NET_IRQ_EXN_IDX);
         return err;
 }
 
 /**
+ * nfp_net_close_stack() - Quiescent the stack (part of close)
+ * @nn:      NFP Net device to reconfigure
+ */
+static void nfp_net_close_stack(struct nfp_net *nn)
+{
+        unsigned int r;
+
+        disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
+        netif_carrier_off(nn->netdev);
+        nn->link_up = false;
+
+        for (r = 0; r < nn->num_r_vecs; r++) {
+                disable_irq(nn->irq_entries[nn->r_vecs[r].irq_idx].vector);
+                napi_disable(&nn->r_vecs[r].napi);
+        }
+
+        netif_tx_disable(nn->netdev);
+}
+
+/**
+ * nfp_net_close_free_all() - Free all runtime resources
+ * @nn:      NFP Net device to reconfigure
+ */
+static void nfp_net_close_free_all(struct nfp_net *nn)
+{
+        unsigned int r;
+
+        for (r = 0; r < nn->num_r_vecs; r++) {
+                nfp_net_rx_ring_bufs_free(nn, nn->r_vecs[r].rx_ring);
+                nfp_net_rx_ring_free(nn->r_vecs[r].rx_ring);
+                nfp_net_tx_ring_free(nn->r_vecs[r].tx_ring);
+                nfp_net_cleanup_vector(nn, &nn->r_vecs[r]);
+        }
+
+        kfree(nn->rx_rings);
+        kfree(nn->tx_rings);
+
+        nfp_net_aux_irq_free(nn, NFP_NET_CFG_LSC, NFP_NET_IRQ_LSC_IDX);
+        nfp_net_aux_irq_free(nn, NFP_NET_CFG_EXN, NFP_NET_IRQ_EXN_IDX);
+}
+
+/**
  * nfp_net_netdev_close() - Called when the device is downed
  * @netdev:      netdev structure
  */
 static int nfp_net_netdev_close(struct net_device *netdev)
 {
         struct nfp_net *nn = netdev_priv(netdev);
-        int r;
 
         if (!(nn->ctrl & NFP_NET_CFG_CTRL_ENABLE)) {
                 nn_err(nn, "Dev is not up: 0x%08x\n", nn->ctrl);
@@ -1855,14 +2060,7 @@ static int nfp_net_netdev_close(struct net_device *netdev)
 
         /* Step 1: Disable RX and TX rings from the Linux kernel perspective
          */
-        nfp_net_aux_irq_free(nn, NFP_NET_CFG_LSC, NFP_NET_IRQ_LSC_IDX);
-        netif_carrier_off(netdev);
-        nn->link_up = false;
-
-        for (r = 0; r < nn->num_r_vecs; r++)
-                napi_disable(&nn->r_vecs[r].napi);
-
-        netif_tx_disable(netdev);
+        nfp_net_close_stack(nn);
 
         /* Step 2: Tell NFP
          */
@@ -1870,13 +2068,7 @@ static int nfp_net_netdev_close(struct net_device *netdev)
 
         /* Step 3: Free resources
          */
-        for (r = 0; r < nn->num_r_vecs; r++) {
-                nfp_net_rx_flush(nn->r_vecs[r].rx_ring);
-                nfp_net_tx_flush(nn->r_vecs[r].tx_ring);
-        }
-
-        nfp_net_free_rings(nn);
-        nfp_net_aux_irq_free(nn, NFP_NET_CFG_EXN, NFP_NET_IRQ_EXN_IDX);
+        nfp_net_close_free_all(nn);
 
         nn_dbg(nn, "%s down", netdev->name);
         return 0;
@@ -1910,29 +2102,132 @@ static void nfp_net_set_rx_mode(struct net_device *netdev)
 
 static int nfp_net_change_mtu(struct net_device *netdev, int new_mtu)
 {
+        unsigned int old_mtu, old_fl_bufsz, new_fl_bufsz;
         struct nfp_net *nn = netdev_priv(netdev);
-        u32 tmp;
-
-        nn_dbg(nn, "New MTU = %d\n", new_mtu);
+        struct nfp_net_rx_ring *tmp_rings;
+        int err;
 
         if (new_mtu < 68 || new_mtu > nn->max_mtu) {
                 nn_err(nn, "New MTU (%d) is not valid\n", new_mtu);
                 return -EINVAL;
         }
 
+        old_mtu = netdev->mtu;
+        old_fl_bufsz = nn->fl_bufsz;
+        new_fl_bufsz = NFP_NET_MAX_PREPEND + ETH_HLEN + VLAN_HLEN * 2 + new_mtu;
+
+        if (!netif_running(netdev)) {
+                netdev->mtu = new_mtu;
+                nn->fl_bufsz = new_fl_bufsz;
+                return 0;
+        }
+
+        /* Prepare new rings */
+        tmp_rings = nfp_net_shadow_rx_rings_prepare(nn, new_fl_bufsz,
+                                                    nn->rxd_cnt);
+        if (!tmp_rings)
+                return -ENOMEM;
+
+        /* Stop device, swap in new rings, try to start the firmware */
+        nfp_net_close_stack(nn);
+        nfp_net_clear_config_and_disable(nn);
+
+        tmp_rings = nfp_net_shadow_rx_rings_swap(nn, tmp_rings);
+
         netdev->mtu = new_mtu;
+        nn->fl_bufsz = new_fl_bufsz;
 
-        /* Freelist buffer size rounded up to the nearest 1K */
-        tmp = new_mtu + ETH_HLEN + VLAN_HLEN + NFP_NET_MAX_PREPEND;
-        nn->fl_bufsz = roundup(tmp, 1024);
+        err = nfp_net_set_config_and_enable(nn);
+        if (err) {
+                const int err_new = err;
+
+                /* Try with old configuration and old rings */
+                tmp_rings = nfp_net_shadow_rx_rings_swap(nn, tmp_rings);
+
+                netdev->mtu = old_mtu;
+                nn->fl_bufsz = old_fl_bufsz;
 
-        /* restart if running */
-        if (netif_running(netdev)) {
-                nfp_net_netdev_close(netdev);
-                nfp_net_netdev_open(netdev);
+                err = __nfp_net_set_config_and_enable(nn);
+                if (err)
+                        nn_err(nn, "Can't restore MTU - FW communication failed (%d,%d)\n",
+                               err_new, err);
         }
 
-        return 0;
+        nfp_net_shadow_rx_rings_free(nn, tmp_rings);
+
+        nfp_net_open_stack(nn);
+
+        return err;
+}
+
+int nfp_net_set_ring_size(struct nfp_net *nn, u32 rxd_cnt, u32 txd_cnt)
+{
+        struct nfp_net_tx_ring *tx_rings = NULL;
+        struct nfp_net_rx_ring *rx_rings = NULL;
+        u32 old_rxd_cnt, old_txd_cnt;
+        int err;
+
+        if (!netif_running(nn->netdev)) {
+                nn->rxd_cnt = rxd_cnt;
+                nn->txd_cnt = txd_cnt;
+                return 0;
+        }
+
+        old_rxd_cnt = nn->rxd_cnt;
+        old_txd_cnt = nn->txd_cnt;
+
+        /* Prepare new rings */
+        if (nn->rxd_cnt != rxd_cnt) {
+                rx_rings = nfp_net_shadow_rx_rings_prepare(nn, nn->fl_bufsz,
+                                                           rxd_cnt);
+                if (!rx_rings)
+                        return -ENOMEM;
+        }
+        if (nn->txd_cnt != txd_cnt) {
+                tx_rings = nfp_net_shadow_tx_rings_prepare(nn, txd_cnt);
+                if (!tx_rings) {
+                        nfp_net_shadow_rx_rings_free(nn, rx_rings);
+                        return -ENOMEM;
+                }
+        }
+
+        /* Stop device, swap in new rings, try to start the firmware */
+        nfp_net_close_stack(nn);
+        nfp_net_clear_config_and_disable(nn);
+
+        if (rx_rings)
+                rx_rings = nfp_net_shadow_rx_rings_swap(nn, rx_rings);
+        if (tx_rings)
+                tx_rings = nfp_net_shadow_tx_rings_swap(nn, tx_rings);
+
+        nn->rxd_cnt = rxd_cnt;
+        nn->txd_cnt = txd_cnt;
+
+        err = nfp_net_set_config_and_enable(nn);
+        if (err) {
+                const int err_new = err;
+
+                /* Try with old configuration and old rings */
+                if (rx_rings)
+                        rx_rings = nfp_net_shadow_rx_rings_swap(nn, rx_rings);
+                if (tx_rings)
+                        tx_rings = nfp_net_shadow_tx_rings_swap(nn, tx_rings);
+
+                nn->rxd_cnt = old_rxd_cnt;
+                nn->txd_cnt = old_txd_cnt;
+
+                err = __nfp_net_set_config_and_enable(nn);
+                if (err)
+                        nn_err(nn, "Can't restore ring config - FW communication failed (%d,%d)\n",
+                               err_new, err);
+        }
+
+        nfp_net_shadow_rx_rings_free(nn, rx_rings);
+        nfp_net_shadow_tx_rings_free(nn, tx_rings);
+
+        nfp_net_open_stack(nn);
+
+        return err;
 }
 
 static struct rtnl_link_stats64 *nfp_net_stat64(struct net_device *netdev,
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_debugfs.c b/drivers/net/ethernet/netronome/nfp/nfp_net_debugfs.c
index 4c97c713121c..f86a1f13d27b 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_debugfs.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_debugfs.c
@@ -40,8 +40,9 @@ static struct dentry *nfp_dir;
 
 static int nfp_net_debugfs_rx_q_read(struct seq_file *file, void *data)
 {
-        struct nfp_net_rx_ring *rx_ring = file->private;
         int fl_rd_p, fl_wr_p, rx_rd_p, rx_wr_p, rxd_cnt;
+        struct nfp_net_r_vector *r_vec = file->private;
+        struct nfp_net_rx_ring *rx_ring;
         struct nfp_net_rx_desc *rxd;
         struct sk_buff *skb;
         struct nfp_net *nn;
@@ -49,9 +50,10 @@ static int nfp_net_debugfs_rx_q_read(struct seq_file *file, void *data)
 
         rtnl_lock();
 
-        if (!rx_ring->r_vec || !rx_ring->r_vec->nfp_net)
+        if (!r_vec->nfp_net || !r_vec->rx_ring)
                 goto out;
-        nn = rx_ring->r_vec->nfp_net;
+        nn = r_vec->nfp_net;
+        rx_ring = r_vec->rx_ring;
         if (!netif_running(nn->netdev))
                 goto out;
 
@@ -115,7 +117,8 @@ static const struct file_operations nfp_rx_q_fops = {
 
 static int nfp_net_debugfs_tx_q_read(struct seq_file *file, void *data)
 {
-        struct nfp_net_tx_ring *tx_ring = file->private;
+        struct nfp_net_r_vector *r_vec = file->private;
+        struct nfp_net_tx_ring *tx_ring;
         struct nfp_net_tx_desc *txd;
         int d_rd_p, d_wr_p, txd_cnt;
         struct sk_buff *skb;
@@ -124,9 +127,10 @@ static int nfp_net_debugfs_tx_q_read(struct seq_file *file, void *data)
 
         rtnl_lock();
 
-        if (!tx_ring->r_vec || !tx_ring->r_vec->nfp_net)
+        if (!r_vec->nfp_net || !r_vec->tx_ring)
                 goto out;
-        nn = tx_ring->r_vec->nfp_net;
+        nn = r_vec->nfp_net;
+        tx_ring = r_vec->tx_ring;
         if (!netif_running(nn->netdev))
                 goto out;
 
@@ -207,13 +211,13 @@ void nfp_net_debugfs_adapter_add(struct nfp_net *nn)
         for (i = 0; i < nn->num_rx_rings; i++) {
                 sprintf(int_name, "%d", i);
                 debugfs_create_file(int_name, S_IRUSR, rx,
-                                    &nn->rx_rings[i], &nfp_rx_q_fops);
+                                    &nn->r_vecs[i], &nfp_rx_q_fops);
         }
 
         for (i = 0; i < nn->num_tx_rings; i++) {
                 sprintf(int_name, "%d", i);
                 debugfs_create_file(int_name, S_IRUSR, tx,
-                                    &nn->tx_rings[i], &nfp_tx_q_fops);
+                                    &nn->r_vecs[i], &nfp_tx_q_fops);
         }
 }
 
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c b/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c
index 9a4084a68db5..ccfef1f17627 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.c
@@ -153,37 +153,25 @@ static int nfp_net_set_ringparam(struct net_device *netdev,
         struct nfp_net *nn = netdev_priv(netdev);
         u32 rxd_cnt, txd_cnt;
 
-        if (netif_running(netdev)) {
-                /* Some NIC drivers allow reconfiguration on the fly,
-                 * some down the interface, change and then up it
-                 * again.  For now we don't allow changes when the
-                 * device is up.
-                 */
-                nn_warn(nn, "Can't change rings while device is up\n");
-                return -EBUSY;
-        }
-
         /* We don't have separate queues/rings for small/large frames. */
         if (ring->rx_mini_pending || ring->rx_jumbo_pending)
                 return -EINVAL;
 
         /* Round up to supported values */
         rxd_cnt = roundup_pow_of_two(ring->rx_pending);
-        rxd_cnt = max_t(u32, rxd_cnt, NFP_NET_MIN_RX_DESCS);
-        rxd_cnt = min_t(u32, rxd_cnt, NFP_NET_MAX_RX_DESCS);
-
         txd_cnt = roundup_pow_of_two(ring->tx_pending);
-        txd_cnt = max_t(u32, txd_cnt, NFP_NET_MIN_TX_DESCS);
-        txd_cnt = min_t(u32, txd_cnt, NFP_NET_MAX_TX_DESCS);
 
-        if (nn->rxd_cnt != rxd_cnt || nn->txd_cnt != txd_cnt)
-                nn_dbg(nn, "Change ring size: RxQ %u->%u, TxQ %u->%u\n",
-                       nn->rxd_cnt, rxd_cnt, nn->txd_cnt, txd_cnt);
+        if (rxd_cnt < NFP_NET_MIN_RX_DESCS || rxd_cnt > NFP_NET_MAX_RX_DESCS ||
+            txd_cnt < NFP_NET_MIN_TX_DESCS || txd_cnt > NFP_NET_MAX_TX_DESCS)
+                return -EINVAL;
 
-        nn->rxd_cnt = rxd_cnt;
-        nn->txd_cnt = txd_cnt;
+        if (nn->rxd_cnt == rxd_cnt && nn->txd_cnt == txd_cnt)
+                return 0;
 
-        return 0;
+        nn_dbg(nn, "Change ring size: RxQ %u->%u, TxQ %u->%u\n",
+               nn->rxd_cnt, rxd_cnt, nn->txd_cnt, txd_cnt);
+
+        return nfp_net_set_ring_size(nn, rxd_cnt, txd_cnt);
 }
 
 static void nfp_net_get_strings(struct net_device *netdev,
diff --git a/drivers/net/ethernet/qlogic/qed/qed_int.c b/drivers/net/ethernet/qlogic/qed/qed_int.c
index ffd0accc2ec9..2017b0121f5f 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_int.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_int.c
@@ -2750,7 +2750,7 @@ void qed_int_igu_enable_int(struct qed_hwfn *p_hwfn,
 int qed_int_igu_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                        enum qed_int_mode int_mode)
 {
-        int rc;
+        int rc = 0;
 
         /* Configure AEU signal change to produce attentions */
         qed_wr(p_hwfn, p_ptt, IGU_REG_ATTENTION_ENABLE, 0);
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge.h b/drivers/net/ethernet/qlogic/qlge/qlge.h
index ef332708e5f2..6d31f92ef2b6 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge.h
+++ b/drivers/net/ethernet/qlogic/qlge/qlge.h
@@ -18,7 +18,7 @@
  */
 #define DRV_NAME        "qlge"
 #define DRV_STRING      "QLogic 10 Gigabit PCI-E Ethernet Driver "
-#define DRV_VERSION     "1.00.00.34"
+#define DRV_VERSION     "1.00.00.35"
 
 #define WQ_ADDR_ALIGN   0x3     /* 4 byte alignment */
 
diff --git a/drivers/net/ethernet/renesas/ravb.h b/drivers/net/ethernet/renesas/ravb.h
index b2160d1b9c71..5c1624147778 100644
--- a/drivers/net/ethernet/renesas/ravb.h
+++ b/drivers/net/ethernet/renesas/ravb.h
@@ -157,6 +157,7 @@ enum ravb_reg {
         TIC     = 0x0378,
         TIS     = 0x037C,
         ISS     = 0x0380,
+        CIE     = 0x0384,       /* R-Car Gen3 only */
         GCCR    = 0x0390,
         GMTT    = 0x0394,
         GPTC    = 0x0398,
@@ -170,6 +171,15 @@ enum ravb_reg {
         GCT0    = 0x03B8,
         GCT1    = 0x03BC,
         GCT2    = 0x03C0,
+        GIE     = 0x03CC,       /* R-Car Gen3 only */
+        GID     = 0x03D0,       /* R-Car Gen3 only */
+        DIL     = 0x0440,       /* R-Car Gen3 only */
+        RIE0    = 0x0460,       /* R-Car Gen3 only */
+        RID0    = 0x0464,       /* R-Car Gen3 only */
+        RIE2    = 0x0470,       /* R-Car Gen3 only */
+        RID2    = 0x0474,       /* R-Car Gen3 only */
+        TIE     = 0x0478,       /* R-Car Gen3 only */
+        TID     = 0x047c,       /* R-Car Gen3 only */
 
         /* E-MAC registers */
         ECMR    = 0x0500,
@@ -556,6 +566,16 @@ enum ISS_BIT {
         ISS_DPS15       = 0x80000000,
 };
 
+/* CIE (R-Car Gen3 only) */
+enum CIE_BIT {
+        CIE_CRIE        = 0x00000001,
+        CIE_CTIE        = 0x00000100,
+        CIE_RQFM        = 0x00010000,
+        CIE_CL0M        = 0x00020000,
+        CIE_RFWL        = 0x00040000,
+        CIE_RFFL        = 0x00080000,
+};
+
 /* GCCR */
 enum GCCR_BIT {
         GCCR_TCR        = 0x00000003,
@@ -592,6 +612,188 @@ enum GIS_BIT {
         GIS_PTMF        = 0x00000004,
 };
 
+/* GIE (R-Car Gen3 only) */
+enum GIE_BIT {
+        GIE_PTCS        = 0x00000001,
+        GIE_PTOS        = 0x00000002,
+        GIE_PTMS0       = 0x00000004,
+        GIE_PTMS1       = 0x00000008,
+        GIE_PTMS2       = 0x00000010,
+        GIE_PTMS3       = 0x00000020,
+        GIE_PTMS4       = 0x00000040,
+        GIE_PTMS5       = 0x00000080,
+        GIE_PTMS6       = 0x00000100,
+        GIE_PTMS7       = 0x00000200,
+        GIE_ATCS0       = 0x00010000,
+        GIE_ATCS1       = 0x00020000,
+        GIE_ATCS2       = 0x00040000,
+        GIE_ATCS3       = 0x00080000,
+        GIE_ATCS4       = 0x00100000,
+        GIE_ATCS5       = 0x00200000,
+        GIE_ATCS6       = 0x00400000,
+        GIE_ATCS7       = 0x00800000,
+        GIE_ATCS8       = 0x01000000,
+        GIE_ATCS9       = 0x02000000,
+        GIE_ATCS10      = 0x04000000,
+        GIE_ATCS11      = 0x08000000,
+        GIE_ATCS12      = 0x10000000,
+        GIE_ATCS13      = 0x20000000,
+        GIE_ATCS14      = 0x40000000,
+        GIE_ATCS15      = 0x80000000,
+};
+
+/* GID (R-Car Gen3 only) */
+enum GID_BIT {
+        GID_PTCD        = 0x00000001,
+        GID_PTOD        = 0x00000002,
+        GID_PTMD0       = 0x00000004,
+        GID_PTMD1       = 0x00000008,
+        GID_PTMD2       = 0x00000010,
+        GID_PTMD3       = 0x00000020,
+        GID_PTMD4       = 0x00000040,
+        GID_PTMD5       = 0x00000080,
+        GID_PTMD6       = 0x00000100,
+        GID_PTMD7       = 0x00000200,
+        GID_ATCD0       = 0x00010000,
+        GID_ATCD1       = 0x00020000,
+        GID_ATCD2       = 0x00040000,
+        GID_ATCD3       = 0x00080000,
+        GID_ATCD4       = 0x00100000,
+        GID_ATCD5       = 0x00200000,
+        GID_ATCD6       = 0x00400000,
+        GID_ATCD7       = 0x00800000,
+        GID_ATCD8       = 0x01000000,
+        GID_ATCD9       = 0x02000000,
+        GID_ATCD10      = 0x04000000,
+        GID_ATCD11      = 0x08000000,
+        GID_ATCD12      = 0x10000000,
+        GID_ATCD13      = 0x20000000,
+        GID_ATCD14      = 0x40000000,
+        GID_ATCD15      = 0x80000000,
+};
+
+/* RIE0 (R-Car Gen3 only) */
+enum RIE0_BIT {
+        RIE0_FRS0       = 0x00000001,
+        RIE0_FRS1       = 0x00000002,
+        RIE0_FRS2       = 0x00000004,
+        RIE0_FRS3       = 0x00000008,
+        RIE0_FRS4       = 0x00000010,
+        RIE0_FRS5       = 0x00000020,
+        RIE0_FRS6       = 0x00000040,
+        RIE0_FRS7       = 0x00000080,
+        RIE0_FRS8       = 0x00000100,
+        RIE0_FRS9       = 0x00000200,
+        RIE0_FRS10      = 0x00000400,
+        RIE0_FRS11      = 0x00000800,
+        RIE0_FRS12      = 0x00001000,
+        RIE0_FRS13      = 0x00002000,
+        RIE0_FRS14      = 0x00004000,
+        RIE0_FRS15      = 0x00008000,
+        RIE0_FRS16      = 0x00010000,
+        RIE0_FRS17      = 0x00020000,
+};
+
+/* RID0 (R-Car Gen3 only) */
+enum RID0_BIT {
+        RID0_FRD0       = 0x00000001,
+        RID0_FRD1       = 0x00000002,
+        RID0_FRD2       = 0x00000004,
+        RID0_FRD3       = 0x00000008,
+        RID0_FRD4       = 0x00000010,
+        RID0_FRD5       = 0x00000020,
+        RID0_FRD6       = 0x00000040,
+        RID0_FRD7       = 0x00000080,
+        RID0_FRD8       = 0x00000100,
+        RID0_FRD9       = 0x00000200,
+        RID0_FRD10      = 0x00000400,
+        RID0_FRD11      = 0x00000800,
+        RID0_FRD12      = 0x00001000,
+        RID0_FRD13      = 0x00002000,
+        RID0_FRD14      = 0x00004000,
+        RID0_FRD15      = 0x00008000,
+        RID0_FRD16      = 0x00010000,
+        RID0_FRD17      = 0x00020000,
+};
+
+/* RIE2 (R-Car Gen3 only) */
+enum RIE2_BIT {
+        RIE2_QFS0       = 0x00000001,
+        RIE2_QFS1       = 0x00000002,
+        RIE2_QFS2       = 0x00000004,
+        RIE2_QFS3       = 0x00000008,
+        RIE2_QFS4       = 0x00000010,
+        RIE2_QFS5       = 0x00000020,
+        RIE2_QFS6       = 0x00000040,
+        RIE2_QFS7       = 0x00000080,
+        RIE2_QFS8       = 0x00000100,
+        RIE2_QFS9       = 0x00000200,
+        RIE2_QFS10      = 0x00000400,
+        RIE2_QFS11      = 0x00000800,
+        RIE2_QFS12      = 0x00001000,
+        RIE2_QFS13      = 0x00002000,
+        RIE2_QFS14      = 0x00004000,
+        RIE2_QFS15      = 0x00008000,
+        RIE2_QFS16      = 0x00010000,
+        RIE2_QFS17      = 0x00020000,
+        RIE2_RFFS       = 0x80000000,
+};
+
+/* RID2 (R-Car Gen3 only) */
+enum RID2_BIT {
+        RID2_QFD0       = 0x00000001,
+        RID2_QFD1       = 0x00000002,
+        RID2_QFD2       = 0x00000004,
+        RID2_QFD3       = 0x00000008,
+        RID2_QFD4       = 0x00000010,
+        RID2_QFD5       = 0x00000020,
+        RID2_QFD6       = 0x00000040,
+        RID2_QFD7       = 0x00000080,
+        RID2_QFD8       = 0x00000100,
+        RID2_QFD9       = 0x00000200,
+        RID2_QFD10      = 0x00000400,
+        RID2_QFD11      = 0x00000800,
+        RID2_QFD12      = 0x00001000,
+        RID2_QFD13      = 0x00002000,
+        RID2_QFD14      = 0x00004000,
+        RID2_QFD15      = 0x00008000,
+        RID2_QFD16      = 0x00010000,
+        RID2_QFD17      = 0x00020000,
+        RID2_RFFD       = 0x80000000,
+};
+
+/* TIE (R-Car Gen3 only) */
+enum TIE_BIT {
+        TIE_FTS0        = 0x00000001,
+        TIE_FTS1        = 0x00000002,
+        TIE_FTS2        = 0x00000004,
+        TIE_FTS3        = 0x00000008,
+        TIE_TFUS        = 0x00000100,
+        TIE_TFWS        = 0x00000200,
+        TIE_MFUS        = 0x00000400,
+        TIE_MFWS        = 0x00000800,
+        TIE_TDPS0       = 0x00010000,
+        TIE_TDPS1       = 0x00020000,
+        TIE_TDPS2       = 0x00040000,
+        TIE_TDPS3       = 0x00080000,
+};
+
+/* TID (R-Car Gen3 only) */
+enum TID_BIT {
+        TID_FTD0        = 0x00000001,
+        TID_FTD1        = 0x00000002,
+        TID_FTD2        = 0x00000004,
+        TID_FTD3        = 0x00000008,
+        TID_TFUD        = 0x00000100,
+        TID_TFWD        = 0x00000200,
+        TID_MFUD        = 0x00000400,
+        TID_MFWD        = 0x00000800,
+        TID_TDPD0       = 0x00010000,
+        TID_TDPD1       = 0x00020000,
+        TID_TDPD2       = 0x00040000,
+        TID_TDPD3       = 0x00080000,
+};
+
 /* ECMR */
 enum ECMR_BIT {
         ECMR_PRM        = 0x00000001,
@@ -817,6 +1019,8 @@ struct ravb_private {
         int duplex;
         int emac_irq;
         enum ravb_chip_id chip_id;
+        int rx_irqs[NUM_RX_QUEUE];
+        int tx_irqs[NUM_TX_QUEUE];
 
         unsigned no_avb_link:1;
         unsigned avb_link_active_low:1;
diff --git a/drivers/net/ethernet/renesas/ravb_main.c b/drivers/net/ethernet/renesas/ravb_main.c
index 4e1a7dba7c4a..4b71951e185d 100644
--- a/drivers/net/ethernet/renesas/ravb_main.c
+++ b/drivers/net/ethernet/renesas/ravb_main.c
@@ -42,6 +42,16 @@
                  NETIF_MSG_RX_ERR | \
                  NETIF_MSG_TX_ERR)
 
+static const char *ravb_rx_irqs[NUM_RX_QUEUE] = {
+        "ch0", /* RAVB_BE */
+        "ch1", /* RAVB_NC */
+};
+
+static const char *ravb_tx_irqs[NUM_TX_QUEUE] = {
+        "ch18", /* RAVB_BE */
+        "ch19", /* RAVB_NC */
+};
+
 void ravb_modify(struct net_device *ndev, enum ravb_reg reg, u32 clear,
                  u32 set)
 {
@@ -365,6 +375,7 @@ static void ravb_emac_init(struct net_device *ndev)
 /* Device init function for Ethernet AVB */
 static int ravb_dmac_init(struct net_device *ndev)
 {
+        struct ravb_private *priv = netdev_priv(ndev);
         int error;
 
         /* Set CONFIG mode */
@@ -401,6 +412,12 @@ static int ravb_dmac_init(struct net_device *ndev)
         ravb_write(ndev, TCCR_TFEN, TCCR);
 
         /* Interrupt init: */
+        if (priv->chip_id == RCAR_GEN3) {
+                /* Clear DIL.DPLx */
+                ravb_write(ndev, 0, DIL);
+                /* Set queue specific interrupt */
+                ravb_write(ndev, CIE_CRIE | CIE_CTIE | CIE_CL0M, CIE);
+        }
         /* Frame receive */
         ravb_write(ndev, RIC0_FRE0 | RIC0_FRE1, RIC0);
         /* Disable FIFO full warning */
@@ -643,7 +660,7 @@ static int ravb_stop_dma(struct net_device *ndev)
 }
 
 /* E-MAC interrupt handler */
-static void ravb_emac_interrupt(struct net_device *ndev)
+static void ravb_emac_interrupt_unlocked(struct net_device *ndev)
 {
         struct ravb_private *priv = netdev_priv(ndev);
         u32 ecsr, psr;
@@ -669,6 +686,18 @@ static void ravb_emac_interrupt(struct net_device *ndev)
         }
 }
 
+static irqreturn_t ravb_emac_interrupt(int irq, void *dev_id)
+{
+        struct net_device *ndev = dev_id;
+        struct ravb_private *priv = netdev_priv(ndev);
+
+        spin_lock(&priv->lock);
+        ravb_emac_interrupt_unlocked(ndev);
+        mmiowb();
+        spin_unlock(&priv->lock);
+        return IRQ_HANDLED;
+}
+
 /* Error interrupt handler */
 static void ravb_error_interrupt(struct net_device *ndev)
 {
@@ -695,6 +724,50 @@ static void ravb_error_interrupt(struct net_device *ndev)
         }
 }
 
+static bool ravb_queue_interrupt(struct net_device *ndev, int q)
+{
+        struct ravb_private *priv = netdev_priv(ndev);
+        u32 ris0 = ravb_read(ndev, RIS0);
+        u32 ric0 = ravb_read(ndev, RIC0);
+        u32 tis  = ravb_read(ndev, TIS);
+        u32 tic  = ravb_read(ndev, TIC);
+
+        if (((ris0 & ric0) & BIT(q)) || ((tis  & tic)  & BIT(q))) {
+                if (napi_schedule_prep(&priv->napi[q])) {
+                        /* Mask RX and TX interrupts */
+                        if (priv->chip_id == RCAR_GEN2) {
+                                ravb_write(ndev, ric0 & ~BIT(q), RIC0);
+                                ravb_write(ndev, tic & ~BIT(q), TIC);
+                        } else {
+                                ravb_write(ndev, BIT(q), RID0);
+                                ravb_write(ndev, BIT(q), TID);
+                        }
+                        __napi_schedule(&priv->napi[q]);
+                } else {
+                        netdev_warn(ndev,
+                                    "ignoring interrupt, rx status 0x%08x, rx mask 0x%08x,\n",
+                                    ris0, ric0);
+                        netdev_warn(ndev,
+                                    "                    tx status 0x%08x, tx mask 0x%08x.\n",
+                                    tis, tic);
+                }
+                return true;
+        }
+        return false;
+}
+
+static bool ravb_timestamp_interrupt(struct net_device *ndev)
+{
+        u32 tis = ravb_read(ndev, TIS);
+
+        if (tis & TIS_TFUF) {
+                ravb_write(ndev, ~TIS_TFUF, TIS);
+                ravb_get_tx_tstamp(ndev);
+                return true;
+        }
+        return false;
+}
+
 static irqreturn_t ravb_interrupt(int irq, void *dev_id)
 {
         struct net_device *ndev = dev_id;
@@ -708,46 +781,22 @@ static irqreturn_t ravb_interrupt(int irq, void *dev_id)
 
         /* Received and transmitted interrupts */
         if (iss & (ISS_FRS | ISS_FTS | ISS_TFUS)) {
-                u32 ris0 = ravb_read(ndev, RIS0);
-                u32 ric0 = ravb_read(ndev, RIC0);
-                u32 tis  = ravb_read(ndev, TIS);
-                u32 tic  = ravb_read(ndev, TIC);
                 int q;
 
                 /* Timestamp updated */
-                if (tis & TIS_TFUF) {
-                        ravb_write(ndev, ~TIS_TFUF, TIS);
-                        ravb_get_tx_tstamp(ndev);
+                if (ravb_timestamp_interrupt(ndev))
                         result = IRQ_HANDLED;
-                }
 
                 /* Network control and best effort queue RX/TX */
                 for (q = RAVB_NC; q >= RAVB_BE; q--) {
-                        if (((ris0 & ric0) & BIT(q)) ||
-                            ((tis  & tic)  & BIT(q))) {
-                                if (napi_schedule_prep(&priv->napi[q])) {
-                                        /* Mask RX and TX interrupts */
-                                        ric0 &= ~BIT(q);
-                                        tic &= ~BIT(q);
-                                        ravb_write(ndev, ric0, RIC0);
-                                        ravb_write(ndev, tic, TIC);
-                                        __napi_schedule(&priv->napi[q]);
-                                } else {
-                                        netdev_warn(ndev,
-                                                    "ignoring interrupt, rx status 0x%08x, rx mask 0x%08x,\n",
-                                                    ris0, ric0);
-                                        netdev_warn(ndev,
-                                                    "                    tx status 0x%08x, tx mask 0x%08x.\n",
-                                                    tis, tic);
-                                }
+                        if (ravb_queue_interrupt(ndev, q))
                                 result = IRQ_HANDLED;
-                        }
                 }
         }
 
         /* E-MAC status summary */
         if (iss & ISS_MS) {
-                ravb_emac_interrupt(ndev);
+                ravb_emac_interrupt_unlocked(ndev);
                 result = IRQ_HANDLED;
         }
 
@@ -757,6 +806,7 @@ static irqreturn_t ravb_interrupt(int irq, void *dev_id)
                 result = IRQ_HANDLED;
         }
 
+        /* gPTP interrupt status summary */
         if ((iss & ISS_CGIS) && ravb_ptp_interrupt(ndev) == IRQ_HANDLED)
                 result = IRQ_HANDLED;
 
@@ -765,6 +815,64 @@ static irqreturn_t ravb_interrupt(int irq, void *dev_id)
         return result;
 }
 
+/* Timestamp/Error/gPTP interrupt handler */
+static irqreturn_t ravb_multi_interrupt(int irq, void *dev_id)
+{
+        struct net_device *ndev = dev_id;
+        struct ravb_private *priv = netdev_priv(ndev);
+        irqreturn_t result = IRQ_NONE;
+        u32 iss;
+
+        spin_lock(&priv->lock);
+        /* Get interrupt status */
+        iss = ravb_read(ndev, ISS);
+
+        /* Timestamp updated */
+        if ((iss & ISS_TFUS) && ravb_timestamp_interrupt(ndev))
+                result = IRQ_HANDLED;
+
+        /* Error status summary */
+        if (iss & ISS_ES) {
+                ravb_error_interrupt(ndev);
+                result = IRQ_HANDLED;
+        }
+
+        /* gPTP interrupt status summary */
+        if ((iss & ISS_CGIS) && ravb_ptp_interrupt(ndev) == IRQ_HANDLED)
+                result = IRQ_HANDLED;
+
+        mmiowb();
+        spin_unlock(&priv->lock);
+        return result;
+}
+
+static irqreturn_t ravb_dma_interrupt(int irq, void *dev_id, int q)
+{
+        struct net_device *ndev = dev_id;
+        struct ravb_private *priv = netdev_priv(ndev);
+        irqreturn_t result = IRQ_NONE;
+
+        spin_lock(&priv->lock);
+
+        /* Network control/Best effort queue RX/TX */
+        if (ravb_queue_interrupt(ndev, q))
+                result = IRQ_HANDLED;
+
+        mmiowb();
+        spin_unlock(&priv->lock);
+        return result;
+}
+
+static irqreturn_t ravb_be_interrupt(int irq, void *dev_id)
+{
+        return ravb_dma_interrupt(irq, dev_id, RAVB_BE);
+}
+
+static irqreturn_t ravb_nc_interrupt(int irq, void *dev_id)
+{
+        return ravb_dma_interrupt(irq, dev_id, RAVB_NC);
+}
+
 static int ravb_poll(struct napi_struct *napi, int budget)
 {
         struct net_device *ndev = napi->dev;
@@ -804,8 +912,13 @@ static int ravb_poll(struct napi_struct *napi, int budget)
 
         /* Re-enable RX/TX interrupts */
         spin_lock_irqsave(&priv->lock, flags);
-        ravb_modify(ndev, RIC0, mask, mask);
-        ravb_modify(ndev, TIC,  mask, mask);
+        if (priv->chip_id == RCAR_GEN2) {
+                ravb_modify(ndev, RIC0, mask, mask);
+                ravb_modify(ndev, TIC,  mask, mask);
+        } else {
+                ravb_write(ndev, mask, RIE0);
+                ravb_write(ndev, mask, TIE);
+        }
         mmiowb();
         spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -1208,35 +1321,72 @@ static const struct ethtool_ops ravb_ethtool_ops = {
         .get_ts_info            = ravb_get_ts_info,
 };
 
+static inline int ravb_hook_irq(unsigned int irq, irq_handler_t handler,
+                                struct net_device *ndev, struct device *dev,
+                                const char *ch)
+{
+        char *name;
+        int error;
+
+        name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s", ndev->name, ch);
+        if (!name)
+                return -ENOMEM;
+        error = request_irq(irq, handler, 0, name, ndev);
+        if (error)
+                netdev_err(ndev, "cannot request IRQ %s\n", name);
+
+        return error;
+}
+
 /* Network device open function for Ethernet AVB */
 static int ravb_open(struct net_device *ndev)
 {
         struct ravb_private *priv = netdev_priv(ndev);
+        struct platform_device *pdev = priv->pdev;
+        struct device *dev = &pdev->dev;
         int error;
 
         napi_enable(&priv->napi[RAVB_BE]);
         napi_enable(&priv->napi[RAVB_NC]);
 
-        error = request_irq(ndev->irq, ravb_interrupt, IRQF_SHARED, ndev->name,
-                            ndev);
-        if (error) {
-                netdev_err(ndev, "cannot request IRQ\n");
-                goto out_napi_off;
-        }
-
-        if (priv->chip_id == RCAR_GEN3) {
-                error = request_irq(priv->emac_irq, ravb_interrupt,
-                                    IRQF_SHARED, ndev->name, ndev);
+        if (priv->chip_id == RCAR_GEN2) {
+                error = request_irq(ndev->irq, ravb_interrupt, IRQF_SHARED,
+                                    ndev->name, ndev);
                 if (error) {
                         netdev_err(ndev, "cannot request IRQ\n");
-                        goto out_free_irq;
+                        goto out_napi_off;
                 }
+        } else {
+                error = ravb_hook_irq(ndev->irq, ravb_multi_interrupt, ndev,
+                                      dev, "ch22:multi");
+                if (error)
+                        goto out_napi_off;
+                error = ravb_hook_irq(priv->emac_irq, ravb_emac_interrupt, ndev,
+                                      dev, "ch24:emac");
+                if (error)
+                        goto out_free_irq;
+                error = ravb_hook_irq(priv->rx_irqs[RAVB_BE], ravb_be_interrupt,
+                                      ndev, dev, "ch0:rx_be");
+                if (error)
+                        goto out_free_irq_emac;
+                error = ravb_hook_irq(priv->tx_irqs[RAVB_BE], ravb_be_interrupt,
+                                      ndev, dev, "ch18:tx_be");
+                if (error)
+                        goto out_free_irq_be_rx;
+                error = ravb_hook_irq(priv->rx_irqs[RAVB_NC], ravb_nc_interrupt,
+                                      ndev, dev, "ch1:rx_nc");
+                if (error)
+                        goto out_free_irq_be_tx;
+                error = ravb_hook_irq(priv->tx_irqs[RAVB_NC], ravb_nc_interrupt,
+                                      ndev, dev, "ch19:tx_nc");
+                if (error)
+                        goto out_free_irq_nc_rx;
         }
 
         /* Device init */
         error = ravb_dmac_init(ndev);
         if (error)
-                goto out_free_irq2;
+                goto out_free_irq_nc_tx;
         ravb_emac_init(ndev);
 
         /* Initialise PTP Clock driver */
@@ -1256,9 +1406,18 @@ out_ptp_stop:
         /* Stop PTP Clock driver */
         if (priv->chip_id == RCAR_GEN2)
                 ravb_ptp_stop(ndev);
-out_free_irq2:
-        if (priv->chip_id == RCAR_GEN3)
-                free_irq(priv->emac_irq, ndev);
+out_free_irq_nc_tx:
+        if (priv->chip_id == RCAR_GEN2)
+                goto out_free_irq;
+        free_irq(priv->tx_irqs[RAVB_NC], ndev);
+out_free_irq_nc_rx:
+        free_irq(priv->rx_irqs[RAVB_NC], ndev);
+out_free_irq_be_tx:
+        free_irq(priv->tx_irqs[RAVB_BE], ndev);
+out_free_irq_be_rx:
+        free_irq(priv->rx_irqs[RAVB_BE], ndev);
+out_free_irq_emac:
+        free_irq(priv->emac_irq, ndev);
 out_free_irq:
         free_irq(ndev->irq, ndev);
 out_napi_off:
@@ -1377,11 +1536,11 @@ static netdev_tx_t ravb_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 
                 /* TAG and timestamp required flag */
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
-                skb_tx_timestamp(skb);
                 desc->tagh_tsr = (ts_skb->tag >> 4) | TX_TSR;
                 desc->ds_tagl |= le16_to_cpu(ts_skb->tag << 12);
         }
 
+        skb_tx_timestamp(skb);
         /* Descriptor type must be set after all the above writes */
         dma_wmb();
         desc->die_dt = DT_FEND;
@@ -1713,6 +1872,7 @@ static int ravb_probe(struct platform_device *pdev)
         struct net_device *ndev;
         int error, irq, q;
         struct resource *res;
+        int i;
 
         if (!np) {
                 dev_err(&pdev->dev,
@@ -1782,6 +1942,22 @@ static int ravb_probe(struct platform_device *pdev)
                         goto out_release;
                 }
                 priv->emac_irq = irq;
+                for (i = 0; i < NUM_RX_QUEUE; i++) {
+                        irq = platform_get_irq_byname(pdev, ravb_rx_irqs[i]);
+                        if (irq < 0) {
+                                error = irq;
+                                goto out_release;
+                        }
+                        priv->rx_irqs[i] = irq;
+                }
+                for (i = 0; i < NUM_TX_QUEUE; i++) {
+                        irq = platform_get_irq_byname(pdev, ravb_tx_irqs[i]);
+                        if (irq < 0) {
+                                error = irq;
+                                goto out_release;
+                        }
+                        priv->tx_irqs[i] = irq;
+                }
         }
 
         priv->chip_id = chip_id;
diff --git a/drivers/net/ethernet/renesas/ravb_ptp.c b/drivers/net/ethernet/renesas/ravb_ptp.c
index 57992ccc4657..f1b2cbb336e8 100644
--- a/drivers/net/ethernet/renesas/ravb_ptp.c
+++ b/drivers/net/ethernet/renesas/ravb_ptp.c
@@ -194,7 +194,12 @@ static int ravb_ptp_extts(struct ptp_clock_info *ptp,
         priv->ptp.extts[req->index] = on;
 
         spin_lock_irqsave(&priv->lock, flags);
-        ravb_modify(ndev, GIC, GIC_PTCE, on ? GIC_PTCE : 0);
+        if (priv->chip_id == RCAR_GEN2)
+                ravb_modify(ndev, GIC, GIC_PTCE, on ? GIC_PTCE : 0);
+        else if (on)
+                ravb_write(ndev, GIE_PTCS, GIE);
+        else
+                ravb_write(ndev, GID_PTCD, GID);
         mmiowb();
         spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -241,7 +246,10 @@ static int ravb_ptp_perout(struct ptp_clock_info *ptp,
                 error = ravb_ptp_update_compare(priv, (u32)start_ns);
                 if (!error) {
                         /* Unmask interrupt */
-                        ravb_modify(ndev, GIC, GIC_PTME, GIC_PTME);
+                        if (priv->chip_id == RCAR_GEN2)
+                                ravb_modify(ndev, GIC, GIC_PTME, GIC_PTME);
+                        else
+                                ravb_write(ndev, GIE_PTMS0, GIE);
                 }
         } else  {
                 spin_lock_irqsave(&priv->lock, flags);
@@ -250,7 +258,10 @@ static int ravb_ptp_perout(struct ptp_clock_info *ptp,
                 perout->period = 0;
 
                 /* Mask interrupt */
-                ravb_modify(ndev, GIC, GIC_PTME, 0);
+                if (priv->chip_id == RCAR_GEN2)
+                        ravb_modify(ndev, GIC, GIC_PTME, 0);
+                else
+                        ravb_write(ndev, GID_PTMD0, GID);
         }
         mmiowb();
         spin_unlock_irqrestore(&priv->lock, flags);
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
index b02eed12bfc5..73427e29df2a 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
@@ -155,11 +155,11 @@ static int sxgbe_platform_probe(struct platform_device *pdev)
         return 0;
 
 err_rx_irq_unmap:
-        while (--i)
+        while (i--)
                 irq_dispose_mapping(priv->rxq[i]->irq_no);
         i = SXGBE_TX_QUEUES;
 err_tx_irq_unmap:
-        while (--i)
+        while (i--)
                 irq_dispose_mapping(priv->txq[i]->irq_no);
         irq_dispose_mapping(priv->irq);
 err_drv_remove:
diff --git a/drivers/net/ethernet/smsc/smc911x.c b/drivers/net/ethernet/smsc/smc911x.c
index 3f5711061432..a733868a43aa 100644
--- a/drivers/net/ethernet/smsc/smc911x.c
+++ b/drivers/net/ethernet/smsc/smc911x.c
@@ -1791,9 +1791,11 @@ static int smc911x_probe(struct net_device *dev)
         unsigned int val, chip_id, revision;
         const char *version_string;
         unsigned long irq_flags;
+#ifdef SMC_USE_DMA
         struct dma_slave_config config;
         dma_cap_mask_t mask;
         struct pxad_param param;
+#endif
 
         DBG(SMC_DEBUG_FUNC, dev, "--> %s\n", __func__);
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/Makefile b/drivers/net/ethernet/stmicro/stmmac/Makefile
index b3901616f4f6..0fb362d5a722 100644
--- a/drivers/net/ethernet/stmicro/stmmac/Makefile
+++ b/drivers/net/ethernet/stmicro/stmmac/Makefile
@@ -2,7 +2,8 @@ obj-$(CONFIG_STMMAC_ETH) += stmmac.o
 stmmac-objs:= stmmac_main.o stmmac_ethtool.o stmmac_mdio.o ring_mode.o  \
               chain_mode.o dwmac_lib.o dwmac1000_core.o dwmac1000_dma.o \
               dwmac100_core.o dwmac100_dma.o enh_desc.o norm_desc.o     \
-              mmc_core.o stmmac_hwtstamp.o stmmac_ptp.o $(stmmac-y)
+              mmc_core.o stmmac_hwtstamp.o stmmac_ptp.o dwmac4_descs.o  \
+              dwmac4_dma.o dwmac4_lib.o dwmac4_core.o $(stmmac-y)
 
 # Ordering matters. Generic driver must be last.
 obj-$(CONFIG_STMMAC_PLATFORM)   += stmmac-platform.o
diff --git a/drivers/net/ethernet/stmicro/stmmac/common.h b/drivers/net/ethernet/stmicro/stmmac/common.h
index f96d257308b0..fc60368df2e7 100644
--- a/drivers/net/ethernet/stmicro/stmmac/common.h
+++ b/drivers/net/ethernet/stmicro/stmmac/common.h
@@ -41,6 +41,8 @@
 /* Synopsys Core versions */
 #define DWMAC_CORE_3_40 0x34
 #define DWMAC_CORE_3_50 0x35
+#define DWMAC_CORE_4_00 0x40
+#define STMMAC_CHAN0    0       /* Always supported and default for all chips */
 
 #define DMA_TX_SIZE 512
 #define DMA_RX_SIZE 512
@@ -167,6 +169,9 @@ struct stmmac_extra_stats {
         unsigned long mtl_rx_fifo_ctrl_active;
         unsigned long mac_rx_frame_ctrl_fifo;
         unsigned long mac_gmii_rx_proto_engine;
+        /* TSO */
+        unsigned long tx_tso_frames;
+        unsigned long tx_tso_nfrags;
 };
 
 /* CSR Frequency Access Defines*/
@@ -243,6 +248,7 @@ enum rx_frame_status {
         csum_none = 0x2,
         llc_snap = 0x4,
         dma_own = 0x8,
+        rx_not_ls = 0x10,
 };
 
 /* Tx status */
@@ -269,6 +275,7 @@ enum dma_irq_status {
 #define CORE_PCS_ANE_COMPLETE           (1 << 5)
 #define CORE_PCS_LINK_STATUS            (1 << 6)
 #define CORE_RGMII_IRQ                  (1 << 7)
+#define CORE_IRQ_MTL_RX_OVERFLOW        BIT(8)
 
 /* Physical Coding Sublayer */
 struct rgmii_adv {
@@ -300,8 +307,10 @@ struct dma_features {
         /* 802.3az - Energy-Efficient Ethernet (EEE) */
         unsigned int eee;
         unsigned int av;
+        unsigned int tsoen;
         /* TX and RX csum */
         unsigned int tx_coe;
+        unsigned int rx_coe;
         unsigned int rx_coe_type1;
         unsigned int rx_coe_type2;
         unsigned int rxfifo_over_2048;
@@ -348,6 +357,10 @@ struct stmmac_desc_ops {
         void (*prepare_tx_desc) (struct dma_desc *p, int is_fs, int len,
                                  bool csum_flag, int mode, bool tx_own,
                                  bool ls);
+        void (*prepare_tso_tx_desc)(struct dma_desc *p, int is_fs, int len1,
+                                    int len2, bool tx_own, bool ls,
+                                    unsigned int tcphdrlen,
+                                    unsigned int tcppayloadlen);
         /* Set/get the owner of the descriptor */
         void (*set_tx_owner) (struct dma_desc *p);
         int (*get_tx_owner) (struct dma_desc *p);
@@ -380,6 +393,10 @@ struct stmmac_desc_ops {
          u64(*get_timestamp) (void *desc, u32 ats);
         /* get rx timestamp status */
         int (*get_rx_timestamp_status) (void *desc, u32 ats);
+        /* Display ring */
+        void (*display_ring)(void *head, unsigned int size, bool rx);
+        /* set MSS via context descriptor */
+        void (*set_mss)(struct dma_desc *p, unsigned int mss);
 };
 
 extern const struct stmmac_desc_ops enh_desc_ops;
@@ -412,9 +429,15 @@ struct stmmac_dma_ops {
         int (*dma_interrupt) (void __iomem *ioaddr,
                               struct stmmac_extra_stats *x);
         /* If supported then get the optional core features */
-        unsigned int (*get_hw_feature) (void __iomem *ioaddr);
+        void (*get_hw_feature)(void __iomem *ioaddr,
+                               struct dma_features *dma_cap);
         /* Program the HW RX Watchdog */
         void (*rx_watchdog) (void __iomem *ioaddr, u32 riwt);
+        void (*set_tx_ring_len)(void __iomem *ioaddr, u32 len);
+        void (*set_rx_ring_len)(void __iomem *ioaddr, u32 len);
+        void (*set_rx_tail_ptr)(void __iomem *ioaddr, u32 tail_ptr, u32 chan);
+        void (*set_tx_tail_ptr)(void __iomem *ioaddr, u32 tail_ptr, u32 chan);
+        void (*enable_tso)(void __iomem *ioaddr, bool en, u32 chan);
 };
 
 struct mac_device_info;
@@ -463,6 +486,7 @@ struct stmmac_hwtimestamp {
 };
 
 extern const struct stmmac_hwtimestamp stmmac_ptp;
+extern const struct stmmac_mode_ops dwmac4_ring_mode_ops;
 
 struct mac_link {
         int port;
@@ -495,7 +519,6 @@ struct mac_device_info {
         const struct stmmac_hwtimestamp *ptp;
         struct mii_regs mii;    /* MII register Addresses */
         struct mac_link link;
-        unsigned int synopsys_uid;
         void __iomem *pcsr;     /* vpointer to device CSRs */
         int multicast_filter_bins;
         int unicast_filter_entries;
@@ -504,18 +527,47 @@ struct mac_device_info {
 };
 
 struct mac_device_info *dwmac1000_setup(void __iomem *ioaddr, int mcbins,
-                                        int perfect_uc_entries);
-struct mac_device_info *dwmac100_setup(void __iomem *ioaddr);
+                                        int perfect_uc_entries,
+                                        int *synopsys_id);
+struct mac_device_info *dwmac100_setup(void __iomem *ioaddr, int *synopsys_id);
+struct mac_device_info *dwmac4_setup(void __iomem *ioaddr, int mcbins,
+                                     int perfect_uc_entries, int *synopsys_id);
 
 void stmmac_set_mac_addr(void __iomem *ioaddr, u8 addr[6],
                          unsigned int high, unsigned int low);
 void stmmac_get_mac_addr(void __iomem *ioaddr, unsigned char *addr,
                          unsigned int high, unsigned int low);
-
 void stmmac_set_mac(void __iomem *ioaddr, bool enable);
 
+void stmmac_dwmac4_set_mac_addr(void __iomem *ioaddr, u8 addr[6],
+                                unsigned int high, unsigned int low);
+void stmmac_dwmac4_get_mac_addr(void __iomem *ioaddr, unsigned char *addr,
+                                unsigned int high, unsigned int low);
+void stmmac_dwmac4_set_mac(void __iomem *ioaddr, bool enable);
+
 void dwmac_dma_flush_tx_fifo(void __iomem *ioaddr);
 extern const struct stmmac_mode_ops ring_mode_ops;
 extern const struct stmmac_mode_ops chain_mode_ops;
-
+extern const struct stmmac_desc_ops dwmac4_desc_ops;
+
+/**
+ * stmmac_get_synopsys_id - return the SYINID.
+ * @priv: driver private structure
+ * Description: this simple function is to decode and return the SYINID
+ * starting from the HW core register.
+ */
+static inline u32 stmmac_get_synopsys_id(u32 hwid)
+{
+        /* Check Synopsys Id (not available on old chips) */
+        if (likely(hwid)) {
+                u32 uid = ((hwid & 0x0000ff00) >> 8);
+                u32 synid = (hwid & 0x000000ff);
+
+                pr_info("stmmac - user ID: 0x%x, Synopsys ID: 0x%x\n",
+                        uid, synid);
+
+                return synid;
+        }
+        return 0;
+}
 #endif /* __COMMON_H__ */
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_core.c b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_core.c
index c2941172f6d1..fb1eb578e34e 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_core.c
@@ -491,7 +491,8 @@ static const struct stmmac_ops dwmac1000_ops = {
 };
 
 struct mac_device_info *dwmac1000_setup(void __iomem *ioaddr, int mcbins,
-                                        int perfect_uc_entries)
+                                        int perfect_uc_entries,
+                                        int *synopsys_id)
 {
         struct mac_device_info *mac;
         u32 hwid = readl(ioaddr + GMAC_VERSION);
@@ -516,7 +517,9 @@ struct mac_device_info *dwmac1000_setup(void __iomem *ioaddr, int mcbins,
         mac->link.speed = GMAC_CONTROL_FES;
         mac->mii.addr = GMAC_MII_ADDR;
         mac->mii.data = GMAC_MII_DATA;
-        mac->synopsys_uid = hwid;
+
+        /* Get and dump the chip ID */
+        *synopsys_id = stmmac_get_synopsys_id(hwid);
 
         return mac;
 }
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c
index da32d6037e3e..990746955216 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c
@@ -215,9 +215,40 @@ static void dwmac1000_dump_dma_regs(void __iomem *ioaddr)
         }
 }
 
-static unsigned int dwmac1000_get_hw_feature(void __iomem *ioaddr)
+static void dwmac1000_get_hw_feature(void __iomem *ioaddr,
+                                     struct dma_features *dma_cap)
 {
-        return readl(ioaddr + DMA_HW_FEATURE);
+        u32 hw_cap = readl(ioaddr + DMA_HW_FEATURE);
+
+        dma_cap->mbps_10_100 = (hw_cap & DMA_HW_FEAT_MIISEL);
+        dma_cap->mbps_1000 = (hw_cap & DMA_HW_FEAT_GMIISEL) >> 1;
+        dma_cap->half_duplex = (hw_cap & DMA_HW_FEAT_HDSEL) >> 2;
+        dma_cap->hash_filter = (hw_cap & DMA_HW_FEAT_HASHSEL) >> 4;
+        dma_cap->multi_addr = (hw_cap & DMA_HW_FEAT_ADDMAC) >> 5;
+        dma_cap->pcs = (hw_cap & DMA_HW_FEAT_PCSSEL) >> 6;
+        dma_cap->sma_mdio = (hw_cap & DMA_HW_FEAT_SMASEL) >> 8;
+        dma_cap->pmt_remote_wake_up = (hw_cap & DMA_HW_FEAT_RWKSEL) >> 9;
+        dma_cap->pmt_magic_frame = (hw_cap & DMA_HW_FEAT_MGKSEL) >> 10;
+        /* MMC */
+        dma_cap->rmon = (hw_cap & DMA_HW_FEAT_MMCSEL) >> 11;
+        /* IEEE 1588-2002 */
+        dma_cap->time_stamp =
+            (hw_cap & DMA_HW_FEAT_TSVER1SEL) >> 12;
+        /* IEEE 1588-2008 */
+        dma_cap->atime_stamp = (hw_cap & DMA_HW_FEAT_TSVER2SEL) >> 13;
+        /* 802.3az - Energy-Efficient Ethernet (EEE) */
+        dma_cap->eee = (hw_cap & DMA_HW_FEAT_EEESEL) >> 14;
+        dma_cap->av = (hw_cap & DMA_HW_FEAT_AVSEL) >> 15;
+        /* TX and RX csum */
+        dma_cap->tx_coe = (hw_cap & DMA_HW_FEAT_TXCOESEL) >> 16;
+        dma_cap->rx_coe_type1 = (hw_cap & DMA_HW_FEAT_RXTYP1COE) >> 17;
+        dma_cap->rx_coe_type2 = (hw_cap & DMA_HW_FEAT_RXTYP2COE) >> 18;
+        dma_cap->rxfifo_over_2048 = (hw_cap & DMA_HW_FEAT_RXFIFOSIZE) >> 19;
+        /* TX and RX number of channels */
+        dma_cap->number_rx_channel = (hw_cap & DMA_HW_FEAT_RXCHCNT) >> 20;
+        dma_cap->number_tx_channel = (hw_cap & DMA_HW_FEAT_TXCHCNT) >> 22;
+        /* Alternate (enhanced) DESC mode */
+        dma_cap->enh_desc = (hw_cap & DMA_HW_FEAT_ENHDESSEL) >> 24;
 }
 
 static void dwmac1000_rx_watchdog(void __iomem *ioaddr, u32 riwt)
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac100_core.c b/drivers/net/ethernet/stmicro/stmmac/dwmac100_core.c
index f8dd773f246c..6418b2e07619 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac100_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac100_core.c
@@ -173,7 +173,7 @@ static const struct stmmac_ops dwmac100_ops = {
         .get_umac_addr = dwmac100_get_umac_addr,
 };
 
-struct mac_device_info *dwmac100_setup(void __iomem *ioaddr)
+struct mac_device_info *dwmac100_setup(void __iomem *ioaddr, int *synopsys_id)
 {
         struct mac_device_info *mac;
 
@@ -192,7 +192,8 @@ struct mac_device_info *dwmac100_setup(void __iomem *ioaddr)
         mac->link.speed = 0;
         mac->mii.addr = MAC_MII_ADDR;
         mac->mii.data = MAC_MII_DATA;
-        mac->synopsys_uid = 0;
+        /* Synopsys Id is not available on old chips */
+        *synopsys_id = 0;
 
         return mac;
 }
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4.h b/drivers/net/ethernet/stmicro/stmmac/dwmac4.h
new file mode 100644
index 000000000000..bc50952a18e7
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4.h
@@ -0,0 +1,255 @@
+/*
+ * DWMAC4 Header file.
+ *
+ * Copyright (C) 2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#ifndef __DWMAC4_H__
+#define __DWMAC4_H__
+
+#include "common.h"
+
+/*  MAC registers */
+#define GMAC_CONFIG                     0x00000000
+#define GMAC_PACKET_FILTER              0x00000008
+#define GMAC_HASH_TAB_0_31              0x00000010
+#define GMAC_HASH_TAB_32_63             0x00000014
+#define GMAC_RX_FLOW_CTRL               0x00000090
+#define GMAC_QX_TX_FLOW_CTRL(x)         (0x70 + x * 4)
+#define GMAC_INT_STATUS                 0x000000b0
+#define GMAC_INT_EN                     0x000000b4
+#define GMAC_AN_CTRL                    0x000000e0
+#define GMAC_AN_STATUS                  0x000000e4
+#define GMAC_AN_ADV                     0x000000e8
+#define GMAC_AN_LPA                     0x000000ec
+#define GMAC_PMT                        0x000000c0
+#define GMAC_VERSION                    0x00000110
+#define GMAC_DEBUG                      0x00000114
+#define GMAC_HW_FEATURE0                0x0000011c
+#define GMAC_HW_FEATURE1                0x00000120
+#define GMAC_HW_FEATURE2                0x00000124
+#define GMAC_MDIO_ADDR                  0x00000200
+#define GMAC_MDIO_DATA                  0x00000204
+#define GMAC_ADDR_HIGH(reg)             (0x300 + reg * 8)
+#define GMAC_ADDR_LOW(reg)              (0x304 + reg * 8)
+
+/* MAC Packet Filtering */
+#define GMAC_PACKET_FILTER_PR           BIT(0)
+#define GMAC_PACKET_FILTER_HMC          BIT(2)
+#define GMAC_PACKET_FILTER_PM           BIT(4)
+
+#define GMAC_MAX_PERFECT_ADDRESSES      128
+
+/* MAC Flow Control RX */
+#define GMAC_RX_FLOW_CTRL_RFE           BIT(0)
+
+/* MAC Flow Control TX */
+#define GMAC_TX_FLOW_CTRL_TFE           BIT(1)
+#define GMAC_TX_FLOW_CTRL_PT_SHIFT      16
+
+/*  MAC Interrupt bitmap*/
+#define GMAC_INT_PMT_EN                 BIT(4)
+#define GMAC_INT_LPI_EN                 BIT(5)
+
+enum dwmac4_irq_status {
+        time_stamp_irq = 0x00001000,
+        mmc_rx_csum_offload_irq = 0x00000800,
+        mmc_tx_irq = 0x00000400,
+        mmc_rx_irq = 0x00000200,
+        mmc_irq = 0x00000100,
+        pmt_irq = 0x00000010,
+        pcs_ane_irq = 0x00000004,
+        pcs_link_irq = 0x00000002,
+};
+
+/* MAC Auto-Neg bitmap*/
+#define GMAC_AN_CTRL_RAN                BIT(9)
+#define GMAC_AN_CTRL_ANE                BIT(12)
+#define GMAC_AN_CTRL_ELE                BIT(14)
+#define GMAC_AN_FD                      BIT(5)
+#define GMAC_AN_HD                      BIT(6)
+#define GMAC_AN_PSE_MASK                GENMASK(8, 7)
+#define GMAC_AN_PSE_SHIFT               7
+
+/* MAC PMT bitmap */
+enum power_event {
+        pointer_reset = 0x80000000,
+        global_unicast = 0x00000200,
+        wake_up_rx_frame = 0x00000040,
+        magic_frame = 0x00000020,
+        wake_up_frame_en = 0x00000004,
+        magic_pkt_en = 0x00000002,
+        power_down = 0x00000001,
+};
+
+/* MAC Debug bitmap */
+#define GMAC_DEBUG_TFCSTS_MASK          GENMASK(18, 17)
+#define GMAC_DEBUG_TFCSTS_SHIFT         17
+#define GMAC_DEBUG_TFCSTS_IDLE          0
+#define GMAC_DEBUG_TFCSTS_WAIT          1
+#define GMAC_DEBUG_TFCSTS_GEN_PAUSE     2
+#define GMAC_DEBUG_TFCSTS_XFER          3
+#define GMAC_DEBUG_TPESTS               BIT(16)
+#define GMAC_DEBUG_RFCFCSTS_MASK        GENMASK(2, 1)
+#define GMAC_DEBUG_RFCFCSTS_SHIFT       1
+#define GMAC_DEBUG_RPESTS               BIT(0)
+
+/* MAC config */
+#define GMAC_CONFIG_IPC                 BIT(27)
+#define GMAC_CONFIG_2K                  BIT(22)
+#define GMAC_CONFIG_ACS                 BIT(20)
+#define GMAC_CONFIG_BE                  BIT(18)
+#define GMAC_CONFIG_JD                  BIT(17)
+#define GMAC_CONFIG_JE                  BIT(16)
+#define GMAC_CONFIG_PS                  BIT(15)
+#define GMAC_CONFIG_FES                 BIT(14)
+#define GMAC_CONFIG_DM                  BIT(13)
+#define GMAC_CONFIG_DCRS                BIT(9)
+#define GMAC_CONFIG_TE                  BIT(1)
+#define GMAC_CONFIG_RE                  BIT(0)
+
+/* MAC HW features0 bitmap */
+#define GMAC_HW_FEAT_ADDMAC             BIT(18)
+#define GMAC_HW_FEAT_RXCOESEL           BIT(16)
+#define GMAC_HW_FEAT_TXCOSEL            BIT(14)
+#define GMAC_HW_FEAT_EEESEL             BIT(13)
+#define GMAC_HW_FEAT_TSSEL              BIT(12)
+#define GMAC_HW_FEAT_MMCSEL             BIT(8)
+#define GMAC_HW_FEAT_MGKSEL             BIT(7)
+#define GMAC_HW_FEAT_RWKSEL             BIT(6)
+#define GMAC_HW_FEAT_SMASEL             BIT(5)
+#define GMAC_HW_FEAT_VLHASH             BIT(4)
+#define GMAC_HW_FEAT_PCSSEL             BIT(3)
+#define GMAC_HW_FEAT_HDSEL              BIT(2)
+#define GMAC_HW_FEAT_GMIISEL            BIT(1)
+#define GMAC_HW_FEAT_MIISEL             BIT(0)
+
+/* MAC HW features1 bitmap */
+#define GMAC_HW_FEAT_AVSEL              BIT(20)
+#define GMAC_HW_TSOEN                   BIT(18)
+
+/* MAC HW features2 bitmap */
+#define GMAC_HW_FEAT_TXCHCNT            GENMASK(21, 18)
+#define GMAC_HW_FEAT_RXCHCNT            GENMASK(15, 12)
+
+/* MAC HW ADDR regs */
+#define GMAC_HI_DCS                     GENMASK(18, 16)
+#define GMAC_HI_DCS_SHIFT               16
+#define GMAC_HI_REG_AE                  BIT(31)
+
+/*  MTL registers */
+#define MTL_INT_STATUS                  0x00000c20
+#define MTL_INT_Q0                      BIT(0)
+
+#define MTL_CHAN_BASE_ADDR              0x00000d00
+#define MTL_CHAN_BASE_OFFSET            0x40
+#define MTL_CHANX_BASE_ADDR(x)          (MTL_CHAN_BASE_ADDR + \
+                                        (x * MTL_CHAN_BASE_OFFSET))
+
+#define MTL_CHAN_TX_OP_MODE(x)          MTL_CHANX_BASE_ADDR(x)
+#define MTL_CHAN_TX_DEBUG(x)            (MTL_CHANX_BASE_ADDR(x) + 0x8)
+#define MTL_CHAN_INT_CTRL(x)            (MTL_CHANX_BASE_ADDR(x) + 0x2c)
+#define MTL_CHAN_RX_OP_MODE(x)          (MTL_CHANX_BASE_ADDR(x) + 0x30)
+#define MTL_CHAN_RX_DEBUG(x)            (MTL_CHANX_BASE_ADDR(x) + 0x38)
+
+#define MTL_OP_MODE_RSF                 BIT(5)
+#define MTL_OP_MODE_TSF                 BIT(1)
+
+#define MTL_OP_MODE_TTC_MASK            0x70
+#define MTL_OP_MODE_TTC_SHIFT           4
+
+#define MTL_OP_MODE_TTC_32              0
+#define MTL_OP_MODE_TTC_64              (1 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_96              (2 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_128             (3 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_192             (4 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_256             (5 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_384             (6 << MTL_OP_MODE_TTC_SHIFT)
+#define MTL_OP_MODE_TTC_512             (7 << MTL_OP_MODE_TTC_SHIFT)
+
+#define MTL_OP_MODE_RTC_MASK            0x18
+#define MTL_OP_MODE_RTC_SHIFT           3
+
+#define MTL_OP_MODE_RTC_32              (1 << MTL_OP_MODE_RTC_SHIFT)
+#define MTL_OP_MODE_RTC_64              0
+#define MTL_OP_MODE_RTC_96              (2 << MTL_OP_MODE_RTC_SHIFT)
+#define MTL_OP_MODE_RTC_128             (3 << MTL_OP_MODE_RTC_SHIFT)
+
+/*  MTL debug */
+#define MTL_DEBUG_TXSTSFSTS             BIT(5)
+#define MTL_DEBUG_TXFSTS                BIT(4)
+#define MTL_DEBUG_TWCSTS                BIT(3)
+
+/* MTL debug: Tx FIFO Read Controller Status */
+#define MTL_DEBUG_TRCSTS_MASK           GENMASK(2, 1)
+#define MTL_DEBUG_TRCSTS_SHIFT          1
+#define MTL_DEBUG_TRCSTS_IDLE           0
+#define MTL_DEBUG_TRCSTS_READ           1
+#define MTL_DEBUG_TRCSTS_TXW            2
+#define MTL_DEBUG_TRCSTS_WRITE          3
+#define MTL_DEBUG_TXPAUSED              BIT(0)
+
+/* MAC debug: GMII or MII Transmit Protocol Engine Status */
+#define MTL_DEBUG_RXFSTS_MASK           GENMASK(5, 4)
+#define MTL_DEBUG_RXFSTS_SHIFT          4
+#define MTL_DEBUG_RXFSTS_EMPTY          0
+#define MTL_DEBUG_RXFSTS_BT             1
+#define MTL_DEBUG_RXFSTS_AT             2
+#define MTL_DEBUG_RXFSTS_FULL           3
+#define MTL_DEBUG_RRCSTS_MASK           GENMASK(2, 1)
+#define MTL_DEBUG_RRCSTS_SHIFT          1
+#define MTL_DEBUG_RRCSTS_IDLE           0
+#define MTL_DEBUG_RRCSTS_RDATA          1
+#define MTL_DEBUG_RRCSTS_RSTAT          2
+#define MTL_DEBUG_RRCSTS_FLUSH          3
+#define MTL_DEBUG_RWCSTS                BIT(0)
+
+/*  MTL interrupt */
+#define MTL_RX_OVERFLOW_INT_EN          BIT(24)
+#define MTL_RX_OVERFLOW_INT             BIT(16)
+
+/* Default operating mode of the MAC */
+#define GMAC_CORE_INIT (GMAC_CONFIG_JD | GMAC_CONFIG_PS | GMAC_CONFIG_ACS | \
+                        GMAC_CONFIG_BE | GMAC_CONFIG_DCRS)
+
+/* To dump the core regs excluding  the Address Registers */
+#define GMAC_REG_NUM    132
+
+/*  MTL debug */
+#define MTL_DEBUG_TXSTSFSTS             BIT(5)
+#define MTL_DEBUG_TXFSTS                BIT(4)
+#define MTL_DEBUG_TWCSTS                BIT(3)
+
+/* MTL debug: Tx FIFO Read Controller Status */
+#define MTL_DEBUG_TRCSTS_MASK           GENMASK(2, 1)
+#define MTL_DEBUG_TRCSTS_SHIFT          1
+#define MTL_DEBUG_TRCSTS_IDLE           0
+#define MTL_DEBUG_TRCSTS_READ           1
+#define MTL_DEBUG_TRCSTS_TXW            2
+#define MTL_DEBUG_TRCSTS_WRITE          3
+#define MTL_DEBUG_TXPAUSED              BIT(0)
+
+/* MAC debug: GMII or MII Transmit Protocol Engine Status */
+#define MTL_DEBUG_RXFSTS_MASK           GENMASK(5, 4)
+#define MTL_DEBUG_RXFSTS_SHIFT          4
+#define MTL_DEBUG_RXFSTS_EMPTY          0
+#define MTL_DEBUG_RXFSTS_BT             1
+#define MTL_DEBUG_RXFSTS_AT             2
+#define MTL_DEBUG_RXFSTS_FULL           3
+#define MTL_DEBUG_RRCSTS_MASK           GENMASK(2, 1)
+#define MTL_DEBUG_RRCSTS_SHIFT          1
+#define MTL_DEBUG_RRCSTS_IDLE           0
+#define MTL_DEBUG_RRCSTS_RDATA          1
+#define MTL_DEBUG_RRCSTS_RSTAT          2
+#define MTL_DEBUG_RRCSTS_FLUSH          3
+#define MTL_DEBUG_RWCSTS                BIT(0)
+
+extern const struct stmmac_dma_ops dwmac4_dma_ops;
+extern const struct stmmac_dma_ops dwmac410_dma_ops;
+#endif /* __DWMAC4_H__ */
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
new file mode 100644
index 000000000000..4f7283d05588
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
@@ -0,0 +1,407 @@
+/*
+ * This is the driver for the GMAC on-chip Ethernet controller for ST SoCs.
+ * DWC Ether MAC version 4.00  has been used for developing this code.
+ *
+ * This only implements the mac core functions for this chip.
+ *
+ * Copyright (C) 2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#include <linux/crc32.h>
+#include <linux/slab.h>
+#include <linux/ethtool.h>
+#include <linux/io.h>
+#include "dwmac4.h"
+
+static void dwmac4_core_init(struct mac_device_info *hw, int mtu)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        u32 value = readl(ioaddr + GMAC_CONFIG);
+
+        value |= GMAC_CORE_INIT;
+
+        if (mtu > 1500)
+                value |= GMAC_CONFIG_2K;
+        if (mtu > 2000)
+                value |= GMAC_CONFIG_JE;
+
+        writel(value, ioaddr + GMAC_CONFIG);
+
+        /* Mask GMAC interrupts */
+        writel(GMAC_INT_PMT_EN, ioaddr + GMAC_INT_EN);
+}
+
+static void dwmac4_dump_regs(struct mac_device_info *hw)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        int i;
+
+        pr_debug("\tDWMAC4 regs (base addr = 0x%p)\n", ioaddr);
+
+        for (i = 0; i < GMAC_REG_NUM; i++) {
+                int offset = i * 4;
+
+                pr_debug("\tReg No. %d (offset 0x%x): 0x%08x\n", i,
+                         offset, readl(ioaddr + offset));
+        }
+}
+
+static int dwmac4_rx_ipc_enable(struct mac_device_info *hw)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        u32 value = readl(ioaddr + GMAC_CONFIG);
+
+        if (hw->rx_csum)
+                value |= GMAC_CONFIG_IPC;
+        else
+                value &= ~GMAC_CONFIG_IPC;
+
+        writel(value, ioaddr + GMAC_CONFIG);
+
+        value = readl(ioaddr + GMAC_CONFIG);
+
+        return !!(value & GMAC_CONFIG_IPC);
+}
+
+static void dwmac4_pmt(struct mac_device_info *hw, unsigned long mode)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        unsigned int pmt = 0;
+
+        if (mode & WAKE_MAGIC) {
+                pr_debug("GMAC: WOL Magic frame\n");
+                pmt |= power_down | magic_pkt_en;
+        }
+        if (mode & WAKE_UCAST) {
+                pr_debug("GMAC: WOL on global unicast\n");
+                pmt |= global_unicast;
+        }
+
+        writel(pmt, ioaddr + GMAC_PMT);
+}
+
+static void dwmac4_set_umac_addr(struct mac_device_info *hw,
+                                 unsigned char *addr, unsigned int reg_n)
+{
+        void __iomem *ioaddr = hw->pcsr;
+
+        stmmac_dwmac4_set_mac_addr(ioaddr, addr, GMAC_ADDR_HIGH(reg_n),
+                                   GMAC_ADDR_LOW(reg_n));
+}
+
+static void dwmac4_get_umac_addr(struct mac_device_info *hw,
+                                 unsigned char *addr, unsigned int reg_n)
+{
+        void __iomem *ioaddr = hw->pcsr;
+
+        stmmac_dwmac4_get_mac_addr(ioaddr, addr, GMAC_ADDR_HIGH(reg_n),
+                                   GMAC_ADDR_LOW(reg_n));
+}
+
+static void dwmac4_set_filter(struct mac_device_info *hw,
+                              struct net_device *dev)
+{
+        void __iomem *ioaddr = (void __iomem *)dev->base_addr;
+        unsigned int value = 0;
+
+        if (dev->flags & IFF_PROMISC) {
+                value = GMAC_PACKET_FILTER_PR;
+        } else if ((dev->flags & IFF_ALLMULTI) ||
+                        (netdev_mc_count(dev) > HASH_TABLE_SIZE)) {
+                /* Pass all multi */
+                value = GMAC_PACKET_FILTER_PM;
+                /* Set the 64 bits of the HASH tab. To be updated if taller
+                 * hash table is used
+                 */
+                writel(0xffffffff, ioaddr + GMAC_HASH_TAB_0_31);
+                writel(0xffffffff, ioaddr + GMAC_HASH_TAB_32_63);
+        } else if (!netdev_mc_empty(dev)) {
+                u32 mc_filter[2];
+                struct netdev_hw_addr *ha;
+
+                /* Hash filter for multicast */
+                value = GMAC_PACKET_FILTER_HMC;
+
+                memset(mc_filter, 0, sizeof(mc_filter));
+                netdev_for_each_mc_addr(ha, dev) {
+                        /* The upper 6 bits of the calculated CRC are used to
+                         * index the content of the Hash Table Reg 0 and 1.
+                         */
+                        int bit_nr =
+                                (bitrev32(~crc32_le(~0, ha->addr, 6)) >> 26);
+                        /* The most significant bit determines the register
+                         * to use while the other 5 bits determines the bit
+                         * within the selected register
+                         */
+                        mc_filter[bit_nr >> 5] |= (1 << (bit_nr & 0x1F));
+                }
+                writel(mc_filter[0], ioaddr + GMAC_HASH_TAB_0_31);
+                writel(mc_filter[1], ioaddr + GMAC_HASH_TAB_32_63);
+        }
+
+        /* Handle multiple unicast addresses */
+        if (netdev_uc_count(dev) > GMAC_MAX_PERFECT_ADDRESSES) {
+                /* Switch to promiscuous mode if more than 128 addrs
+                 * are required
+                 */
+                value |= GMAC_PACKET_FILTER_PR;
+        } else if (!netdev_uc_empty(dev)) {
+                int reg = 1;
+                struct netdev_hw_addr *ha;
+
+                netdev_for_each_uc_addr(ha, dev) {
+                        dwmac4_set_umac_addr(ioaddr, ha->addr, reg);
+                        reg++;
+                }
+        }
+
+        writel(value, ioaddr + GMAC_PACKET_FILTER);
+}
+
+static void dwmac4_flow_ctrl(struct mac_device_info *hw, unsigned int duplex,
+                             unsigned int fc, unsigned int pause_time)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        u32 channel = STMMAC_CHAN0;     /* FIXME */
+        unsigned int flow = 0;
+
+        pr_debug("GMAC Flow-Control:\n");
+        if (fc & FLOW_RX) {
+                pr_debug("\tReceive Flow-Control ON\n");
+                flow |= GMAC_RX_FLOW_CTRL_RFE;
+                writel(flow, ioaddr + GMAC_RX_FLOW_CTRL);
+        }
+        if (fc & FLOW_TX) {
+                pr_debug("\tTransmit Flow-Control ON\n");
+                flow |= GMAC_TX_FLOW_CTRL_TFE;
+                writel(flow, ioaddr + GMAC_QX_TX_FLOW_CTRL(channel));
+
+                if (duplex) {
+                        pr_debug("\tduplex mode: PAUSE %d\n", pause_time);
+                        flow |= (pause_time << GMAC_TX_FLOW_CTRL_PT_SHIFT);
+                        writel(flow, ioaddr + GMAC_QX_TX_FLOW_CTRL(channel));
+                }
+        }
+}
+
+static void dwmac4_ctrl_ane(struct mac_device_info *hw, bool restart)
+{
+        void __iomem *ioaddr = hw->pcsr;
+
+        /* auto negotiation enable and External Loopback enable */
+        u32 value = GMAC_AN_CTRL_ANE | GMAC_AN_CTRL_ELE;
+
+        if (restart)
+                value |= GMAC_AN_CTRL_RAN;
+
+        writel(value, ioaddr + GMAC_AN_CTRL);
+}
+
+static void dwmac4_get_adv(struct mac_device_info *hw, struct rgmii_adv *adv)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        u32 value = readl(ioaddr + GMAC_AN_ADV);
+
+        if (value & GMAC_AN_FD)
+                adv->duplex = DUPLEX_FULL;
+        if (value & GMAC_AN_HD)
+                adv->duplex |= DUPLEX_HALF;
+
+        adv->pause = (value & GMAC_AN_PSE_MASK) >> GMAC_AN_PSE_SHIFT;
+
+        value = readl(ioaddr + GMAC_AN_LPA);
+
+        if (value & GMAC_AN_FD)
+                adv->lp_duplex = DUPLEX_FULL;
+        if (value & GMAC_AN_HD)
+                adv->lp_duplex = DUPLEX_HALF;
+
+        adv->lp_pause = (value & GMAC_AN_PSE_MASK) >> GMAC_AN_PSE_SHIFT;
+}
+
+static int dwmac4_irq_status(struct mac_device_info *hw,
+                             struct stmmac_extra_stats *x)
+{
+        void __iomem *ioaddr = hw->pcsr;
+        u32 mtl_int_qx_status;
+        u32 intr_status;
+        int ret = 0;
+
+        intr_status = readl(ioaddr + GMAC_INT_STATUS);
+
+        /* Not used events (e.g. MMC interrupts) are not handled. */
+        if ((intr_status & mmc_tx_irq))
+                x->mmc_tx_irq_n++;
+        if (unlikely(intr_status & mmc_rx_irq))
+                x->mmc_rx_irq_n++;
+        if (unlikely(intr_status & mmc_rx_csum_offload_irq))
+                x->mmc_rx_csum_offload_irq_n++;
+        /* Clear the PMT bits 5 and 6 by reading the PMT status reg */
+        if (unlikely(intr_status & pmt_irq)) {
+                readl(ioaddr + GMAC_PMT);
+                x->irq_receive_pmt_irq_n++;
+        }
+
+        if ((intr_status & pcs_ane_irq) || (intr_status & pcs_link_irq)) {
+                readl(ioaddr + GMAC_AN_STATUS);
+                x->irq_pcs_ane_n++;
+        }
+
+        mtl_int_qx_status = readl(ioaddr + MTL_INT_STATUS);
+        /* Check MTL Interrupt: Currently only one queue is used: Q0. */
+        if (mtl_int_qx_status & MTL_INT_Q0) {
+                /* read Queue 0 Interrupt status */
+                u32 status = readl(ioaddr + MTL_CHAN_INT_CTRL(STMMAC_CHAN0));
+
+                if (status & MTL_RX_OVERFLOW_INT) {
+                        /*  clear Interrupt */
+                        writel(status | MTL_RX_OVERFLOW_INT,
+                               ioaddr + MTL_CHAN_INT_CTRL(STMMAC_CHAN0));
+                        ret = CORE_IRQ_MTL_RX_OVERFLOW;
+                }
+        }
+
+        return ret;
+}
+
+static void dwmac4_debug(void __iomem *ioaddr, struct stmmac_extra_stats *x)
+{
+        u32 value;
+
+        /*  Currently only channel 0 is supported */
+        value = readl(ioaddr + MTL_CHAN_TX_DEBUG(STMMAC_CHAN0));
+
+        if (value & MTL_DEBUG_TXSTSFSTS)
+                x->mtl_tx_status_fifo_full++;
+        if (value & MTL_DEBUG_TXFSTS)
+                x->mtl_tx_fifo_not_empty++;
+        if (value & MTL_DEBUG_TWCSTS)
+                x->mmtl_fifo_ctrl++;
+        if (value & MTL_DEBUG_TRCSTS_MASK) {
+                u32 trcsts = (value & MTL_DEBUG_TRCSTS_MASK)
+                             >> MTL_DEBUG_TRCSTS_SHIFT;
+                if (trcsts == MTL_DEBUG_TRCSTS_WRITE)
+                        x->mtl_tx_fifo_read_ctrl_write++;
+                else if (trcsts == MTL_DEBUG_TRCSTS_TXW)
+                        x->mtl_tx_fifo_read_ctrl_wait++;
+                else if (trcsts == MTL_DEBUG_TRCSTS_READ)
+                        x->mtl_tx_fifo_read_ctrl_read++;
+                else
+                        x->mtl_tx_fifo_read_ctrl_idle++;
+        }
+        if (value & MTL_DEBUG_TXPAUSED)
+                x->mac_tx_in_pause++;
+
+        value = readl(ioaddr + MTL_CHAN_RX_DEBUG(STMMAC_CHAN0));
+
+        if (value & MTL_DEBUG_RXFSTS_MASK) {
+                u32 rxfsts = (value & MTL_DEBUG_RXFSTS_MASK)
+                             >> MTL_DEBUG_RRCSTS_SHIFT;
+
+                if (rxfsts == MTL_DEBUG_RXFSTS_FULL)
+                        x->mtl_rx_fifo_fill_level_full++;
+                else if (rxfsts == MTL_DEBUG_RXFSTS_AT)
+                        x->mtl_rx_fifo_fill_above_thresh++;
+                else if (rxfsts == MTL_DEBUG_RXFSTS_BT)
+                        x->mtl_rx_fifo_fill_below_thresh++;
+                else
+                        x->mtl_rx_fifo_fill_level_empty++;
+        }
+        if (value & MTL_DEBUG_RRCSTS_MASK) {
+                u32 rrcsts = (value & MTL_DEBUG_RRCSTS_MASK) >>
+                             MTL_DEBUG_RRCSTS_SHIFT;
+
+                if (rrcsts == MTL_DEBUG_RRCSTS_FLUSH)
+                        x->mtl_rx_fifo_read_ctrl_flush++;
+                else if (rrcsts == MTL_DEBUG_RRCSTS_RSTAT)
+                        x->mtl_rx_fifo_read_ctrl_read_data++;
+                else if (rrcsts == MTL_DEBUG_RRCSTS_RDATA)
+                        x->mtl_rx_fifo_read_ctrl_status++;
+                else
+                        x->mtl_rx_fifo_read_ctrl_idle++;
+        }
+        if (value & MTL_DEBUG_RWCSTS)
+                x->mtl_rx_fifo_ctrl_active++;
+
+        /* GMAC debug */
+        value = readl(ioaddr + GMAC_DEBUG);
+
+        if (value & GMAC_DEBUG_TFCSTS_MASK) {
+                u32 tfcsts = (value & GMAC_DEBUG_TFCSTS_MASK)
+                              >> GMAC_DEBUG_TFCSTS_SHIFT;
+
+                if (tfcsts == GMAC_DEBUG_TFCSTS_XFER)
+                        x->mac_tx_frame_ctrl_xfer++;
+                else if (tfcsts == GMAC_DEBUG_TFCSTS_GEN_PAUSE)
+                        x->mac_tx_frame_ctrl_pause++;
+                else if (tfcsts == GMAC_DEBUG_TFCSTS_WAIT)
+                        x->mac_tx_frame_ctrl_wait++;
+                else
+                        x->mac_tx_frame_ctrl_idle++;
+        }
+        if (value & GMAC_DEBUG_TPESTS)
+                x->mac_gmii_tx_proto_engine++;
+        if (value & GMAC_DEBUG_RFCFCSTS_MASK)
+                x->mac_rx_frame_ctrl_fifo = (value & GMAC_DEBUG_RFCFCSTS_MASK)
+                                            >> GMAC_DEBUG_RFCFCSTS_SHIFT;
+        if (value & GMAC_DEBUG_RPESTS)
+                x->mac_gmii_rx_proto_engine++;
+}
+
+static const struct stmmac_ops dwmac4_ops = {
+        .core_init = dwmac4_core_init,
+        .rx_ipc = dwmac4_rx_ipc_enable,
+        .dump_regs = dwmac4_dump_regs,
+        .host_irq_status = dwmac4_irq_status,
+        .flow_ctrl = dwmac4_flow_ctrl,
+        .pmt = dwmac4_pmt,
+        .set_umac_addr = dwmac4_set_umac_addr,
+        .get_umac_addr = dwmac4_get_umac_addr,
+        .ctrl_ane = dwmac4_ctrl_ane,
+        .get_adv = dwmac4_get_adv,
+        .debug = dwmac4_debug,
+        .set_filter = dwmac4_set_filter,
+};
+
+struct mac_device_info *dwmac4_setup(void __iomem *ioaddr, int mcbins,
+                                     int perfect_uc_entries, int *synopsys_id)
+{
+        struct mac_device_info *mac;
+        u32 hwid = readl(ioaddr + GMAC_VERSION);
+
+        mac = kzalloc(sizeof(const struct mac_device_info), GFP_KERNEL);
+        if (!mac)
+                return NULL;
+
+        mac->pcsr = ioaddr;
+        mac->multicast_filter_bins = mcbins;
+        mac->unicast_filter_entries = perfect_uc_entries;
+        mac->mcast_bits_log2 = 0;
+
+        if (mac->multicast_filter_bins)
+                mac->mcast_bits_log2 = ilog2(mac->multicast_filter_bins);
+
+        mac->mac = &dwmac4_ops;
+
+        mac->link.port = GMAC_CONFIG_PS;
+        mac->link.duplex = GMAC_CONFIG_DM;
+        mac->link.speed = GMAC_CONFIG_FES;
+        mac->mii.addr = GMAC_MDIO_ADDR;
+        mac->mii.data = GMAC_MDIO_DATA;
+
+        /* Get and dump the chip ID */
+        *synopsys_id = stmmac_get_synopsys_id(hwid);
+
+        if (*synopsys_id > DWMAC_CORE_4_00)
+                mac->dma = &dwmac410_dma_ops;
+        else
+                mac->dma = &dwmac4_dma_ops;
+
+        return mac;
+}
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c
new file mode 100644
index 000000000000..d4952c7a836d
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.c
@@ -0,0 +1,396 @@
+/*
+ * This contains the functions to handle the descriptors for DesignWare databook
+ * 4.xx.
+ *
+ * Copyright (C) 2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#include <linux/stmmac.h>
+#include "common.h"
+#include "dwmac4_descs.h"
+
+static int dwmac4_wrback_get_tx_status(void *data, struct stmmac_extra_stats *x,
+                                       struct dma_desc *p,
+                                       void __iomem *ioaddr)
+{
+        struct net_device_stats *stats = (struct net_device_stats *)data;
+        unsigned int tdes3;
+        int ret = tx_done;
+
+        tdes3 = p->des3;
+
+        /* Get tx owner first */
+        if (unlikely(tdes3 & TDES3_OWN))
+                return tx_dma_own;
+
+        /* Verify tx error by looking at the last segment. */
+        if (likely(!(tdes3 & TDES3_LAST_DESCRIPTOR)))
+                return tx_not_ls;
+
+        if (unlikely(tdes3 & TDES3_ERROR_SUMMARY)) {
+                if (unlikely(tdes3 & TDES3_JABBER_TIMEOUT))
+                        x->tx_jabber++;
+                if (unlikely(tdes3 & TDES3_PACKET_FLUSHED))
+                        x->tx_frame_flushed++;
+                if (unlikely(tdes3 & TDES3_LOSS_CARRIER)) {
+                        x->tx_losscarrier++;
+                        stats->tx_carrier_errors++;
+                }
+                if (unlikely(tdes3 & TDES3_NO_CARRIER)) {
+                        x->tx_carrier++;
+                        stats->tx_carrier_errors++;
+                }
+                if (unlikely((tdes3 & TDES3_LATE_COLLISION) ||
+                             (tdes3 & TDES3_EXCESSIVE_COLLISION)))
+                        stats->collisions +=
+                            (tdes3 & TDES3_COLLISION_COUNT_MASK)
+                            >> TDES3_COLLISION_COUNT_SHIFT;
+
+                if (unlikely(tdes3 & TDES3_EXCESSIVE_DEFERRAL))
+                        x->tx_deferred++;
+
+                if (unlikely(tdes3 & TDES3_UNDERFLOW_ERROR))
+                        x->tx_underflow++;
+
+                if (unlikely(tdes3 & TDES3_IP_HDR_ERROR))
+                        x->tx_ip_header_error++;
+
+                if (unlikely(tdes3 & TDES3_PAYLOAD_ERROR))
+                        x->tx_payload_error++;
+
+                ret = tx_err;
+        }
+
+        if (unlikely(tdes3 & TDES3_DEFERRED))
+                x->tx_deferred++;
+
+        return ret;
+}
+
+static int dwmac4_wrback_get_rx_status(void *data, struct stmmac_extra_stats *x,
+                                       struct dma_desc *p)
+{
+        struct net_device_stats *stats = (struct net_device_stats *)data;
+        unsigned int rdes1 = p->des1;
+        unsigned int rdes2 = p->des2;
+        unsigned int rdes3 = p->des3;
+        int message_type;
+        int ret = good_frame;
+
+        if (unlikely(rdes3 & RDES3_OWN))
+                return dma_own;
+
+        /* Verify rx error by looking at the last segment. */
+        if (likely(!(rdes3 & RDES3_LAST_DESCRIPTOR)))
+                return discard_frame;
+
+        if (unlikely(rdes3 & RDES3_ERROR_SUMMARY)) {
+                if (unlikely(rdes3 & RDES3_GIANT_PACKET))
+                        stats->rx_length_errors++;
+                if (unlikely(rdes3 & RDES3_OVERFLOW_ERROR))
+                        x->rx_gmac_overflow++;
+
+                if (unlikely(rdes3 & RDES3_RECEIVE_WATCHDOG))
+                        x->rx_watchdog++;
+
+                if (unlikely(rdes3 & RDES3_RECEIVE_ERROR))
+                        x->rx_mii++;
+
+                if (unlikely(rdes3 & RDES3_CRC_ERROR)) {
+                        x->rx_crc++;
+                        stats->rx_crc_errors++;
+                }
+
+                if (unlikely(rdes3 & RDES3_DRIBBLE_ERROR))
+                        x->dribbling_bit++;
+
+                ret = discard_frame;
+        }
+
+        message_type = (rdes1 & ERDES4_MSG_TYPE_MASK) >> 8;
+
+        if (rdes1 & RDES1_IP_HDR_ERROR)
+                x->ip_hdr_err++;
+        if (rdes1 & RDES1_IP_CSUM_BYPASSED)
+                x->ip_csum_bypassed++;
+        if (rdes1 & RDES1_IPV4_HEADER)
+                x->ipv4_pkt_rcvd++;
+        if (rdes1 & RDES1_IPV6_HEADER)
+                x->ipv6_pkt_rcvd++;
+        if (message_type == RDES_EXT_SYNC)
+                x->rx_msg_type_sync++;
+        else if (message_type == RDES_EXT_FOLLOW_UP)
+                x->rx_msg_type_follow_up++;
+        else if (message_type == RDES_EXT_DELAY_REQ)
+                x->rx_msg_type_delay_req++;
+        else if (message_type == RDES_EXT_DELAY_RESP)
+                x->rx_msg_type_delay_resp++;
+        else if (message_type == RDES_EXT_PDELAY_REQ)
+                x->rx_msg_type_pdelay_req++;
+        else if (message_type == RDES_EXT_PDELAY_RESP)
+                x->rx_msg_type_pdelay_resp++;
+        else if (message_type == RDES_EXT_PDELAY_FOLLOW_UP)
+                x->rx_msg_type_pdelay_follow_up++;
+        else
+                x->rx_msg_type_ext_no_ptp++;
+
+        if (rdes1 & RDES1_PTP_PACKET_TYPE)
+                x->ptp_frame_type++;
+        if (rdes1 & RDES1_PTP_VER)
+                x->ptp_ver++;
+        if (rdes1 & RDES1_TIMESTAMP_DROPPED)
+                x->timestamp_dropped++;
+
+        if (unlikely(rdes2 & RDES2_SA_FILTER_FAIL)) {
+                x->sa_rx_filter_fail++;
+                ret = discard_frame;
+        }
+        if (unlikely(rdes2 & RDES2_DA_FILTER_FAIL)) {
+                x->da_rx_filter_fail++;
+                ret = discard_frame;
+        }
+
+        if (rdes2 & RDES2_L3_FILTER_MATCH)
+                x->l3_filter_match++;
+        if (rdes2 & RDES2_L4_FILTER_MATCH)
+                x->l4_filter_match++;
+        if ((rdes2 & RDES2_L3_L4_FILT_NB_MATCH_MASK)
+            >> RDES2_L3_L4_FILT_NB_MATCH_SHIFT)
+                x->l3_l4_filter_no_match++;
+
+        return ret;
+}
+
+static int dwmac4_rd_get_tx_len(struct dma_desc *p)
+{
+        return (p->des2 & TDES2_BUFFER1_SIZE_MASK);
+}
+
+static int dwmac4_get_tx_owner(struct dma_desc *p)
+{
+        return (p->des3 & TDES3_OWN) >> TDES3_OWN_SHIFT;
+}
+
+static void dwmac4_set_tx_owner(struct dma_desc *p)
+{
+        p->des3 |= TDES3_OWN;
+}
+
+static void dwmac4_set_rx_owner(struct dma_desc *p)
+{
+        p->des3 |= RDES3_OWN;
+}
+
+static int dwmac4_get_tx_ls(struct dma_desc *p)
+{
+        return (p->des3 & TDES3_LAST_DESCRIPTOR) >> TDES3_LAST_DESCRIPTOR_SHIFT;
+}
+
+static int dwmac4_wrback_get_rx_frame_len(struct dma_desc *p, int rx_coe)
+{
+        return (p->des3 & RDES3_PACKET_SIZE_MASK);
+}
+
+static void dwmac4_rd_enable_tx_timestamp(struct dma_desc *p)
+{
+        p->des2 |= TDES2_TIMESTAMP_ENABLE;
+}
+
+static int dwmac4_wrback_get_tx_timestamp_status(struct dma_desc *p)
+{
+        return (p->des3 & TDES3_TIMESTAMP_STATUS)
+                >> TDES3_TIMESTAMP_STATUS_SHIFT;
+}
+
+/*  NOTE: For RX CTX bit has to be checked before
+ *  HAVE a specific function for TX and another one for RX
+ */
+static u64 dwmac4_wrback_get_timestamp(void *desc, u32 ats)
+{
+        struct dma_desc *p = (struct dma_desc *)desc;
+        u64 ns;
+
+        ns = p->des0;
+        /* convert high/sec time stamp value to nanosecond */
+        ns += p->des1 * 1000000000ULL;
+
+        return ns;
+}
+
+static int dwmac4_context_get_rx_timestamp_status(void *desc, u32 ats)
+{
+        struct dma_desc *p = (struct dma_desc *)desc;
+
+        return (p->des1 & RDES1_TIMESTAMP_AVAILABLE)
+                >> RDES1_TIMESTAMP_AVAILABLE_SHIFT;
+}
+
+static void dwmac4_rd_init_rx_desc(struct dma_desc *p, int disable_rx_ic,
+                                   int mode, int end)
+{
+        p->des3 = RDES3_OWN | RDES3_BUFFER1_VALID_ADDR;
+
+        if (!disable_rx_ic)
+                p->des3 |= RDES3_INT_ON_COMPLETION_EN;
+}
+
+static void dwmac4_rd_init_tx_desc(struct dma_desc *p, int mode, int end)
+{
+        p->des0 = 0;
+        p->des1 = 0;
+        p->des2 = 0;
+        p->des3 = 0;
+}
+
+static void dwmac4_rd_prepare_tx_desc(struct dma_desc *p, int is_fs, int len,
+                                      bool csum_flag, int mode, bool tx_own,
+                                      bool ls)
+{
+        unsigned int tdes3 = p->des3;
+
+        if (unlikely(len > BUF_SIZE_16KiB)) {
+                p->des2 |= (((len - BUF_SIZE_16KiB) <<
+                             TDES2_BUFFER2_SIZE_MASK_SHIFT)
+                            & TDES2_BUFFER2_SIZE_MASK)
+                            | (BUF_SIZE_16KiB & TDES2_BUFFER1_SIZE_MASK);
+        } else {
+                p->des2 |= (len & TDES2_BUFFER1_SIZE_MASK);
+        }
+
+        if (is_fs)
+                tdes3 |= TDES3_FIRST_DESCRIPTOR;
+        else
+                tdes3 &= ~TDES3_FIRST_DESCRIPTOR;
+
+        if (likely(csum_flag))
+                tdes3 |= (TX_CIC_FULL << TDES3_CHECKSUM_INSERTION_SHIFT);
+        else
+                tdes3 &= ~(TX_CIC_FULL << TDES3_CHECKSUM_INSERTION_SHIFT);
+
+        if (ls)
+                tdes3 |= TDES3_LAST_DESCRIPTOR;
+        else
+                tdes3 &= ~TDES3_LAST_DESCRIPTOR;
+
+        /* Finally set the OWN bit. Later the DMA will start! */
+        if (tx_own)
+                tdes3 |= TDES3_OWN;
+
+        if (is_fs & tx_own)
+                /* When the own bit, for the first frame, has to be set, all
+                 * descriptors for the same frame has to be set before, to
+                 * avoid race condition.
+                 */
+                wmb();
+
+        p->des3 = tdes3;
+}
+
+static void dwmac4_rd_prepare_tso_tx_desc(struct dma_desc *p, int is_fs,
+                                          int len1, int len2, bool tx_own,
+                                          bool ls, unsigned int tcphdrlen,
+                                          unsigned int tcppayloadlen)
+{
+        unsigned int tdes3 = p->des3;
+
+        if (len1)
+                p->des2 |= (len1 & TDES2_BUFFER1_SIZE_MASK);
+
+        if (len2)
+                p->des2 |= (len2 << TDES2_BUFFER2_SIZE_MASK_SHIFT)
+                            & TDES2_BUFFER2_SIZE_MASK;
+
+        if (is_fs) {
+                tdes3 |= TDES3_FIRST_DESCRIPTOR |
+                         TDES3_TCP_SEGMENTATION_ENABLE |
+                         ((tcphdrlen << TDES3_HDR_LEN_SHIFT) &
+                          TDES3_SLOT_NUMBER_MASK) |
+                         ((tcppayloadlen & TDES3_TCP_PKT_PAYLOAD_MASK));
+        } else {
+                tdes3 &= ~TDES3_FIRST_DESCRIPTOR;
+        }
+
+        if (ls)
+                tdes3 |= TDES3_LAST_DESCRIPTOR;
+        else
+                tdes3 &= ~TDES3_LAST_DESCRIPTOR;
+
+        /* Finally set the OWN bit. Later the DMA will start! */
+        if (tx_own)
+                tdes3 |= TDES3_OWN;
+
+        if (is_fs & tx_own)
+                /* When the own bit, for the first frame, has to be set, all
+                 * descriptors for the same frame has to be set before, to
+                 * avoid race condition.
+                 */
+                wmb();
+
+        p->des3 = tdes3;
+}
+
+static void dwmac4_release_tx_desc(struct dma_desc *p, int mode)
+{
+        p->des2 = 0;
+        p->des3 = 0;
+}
+
+static void dwmac4_rd_set_tx_ic(struct dma_desc *p)
+{
+        p->des2 |= TDES2_INTERRUPT_ON_COMPLETION;
+}
+
+static void dwmac4_display_ring(void *head, unsigned int size, bool rx)
+{
+        struct dma_desc *p = (struct dma_desc *)head;
+        int i;
+
+        pr_info("%s descriptor ring:\n", rx ? "RX" : "TX");
+
+        for (i = 0; i < size; i++) {
+                if (p->des0)
+                        pr_info("%d [0x%x]: 0x%x 0x%x 0x%x 0x%x\n",
+                                i, (unsigned int)virt_to_phys(p),
+                                p->des0, p->des1, p->des2, p->des3);
+                p++;
+        }
+}
+
+static void dwmac4_set_mss_ctxt(struct dma_desc *p, unsigned int mss)
+{
+        p->des0 = 0;
+        p->des1 = 0;
+        p->des2 = mss;
+        p->des3 = TDES3_CONTEXT_TYPE | TDES3_CTXT_TCMSSV;
+}
+
+const struct stmmac_desc_ops dwmac4_desc_ops = {
+        .tx_status = dwmac4_wrback_get_tx_status,
+        .rx_status = dwmac4_wrback_get_rx_status,
+        .get_tx_len = dwmac4_rd_get_tx_len,
+        .get_tx_owner = dwmac4_get_tx_owner,
+        .set_tx_owner = dwmac4_set_tx_owner,
+        .set_rx_owner = dwmac4_set_rx_owner,
+        .get_tx_ls = dwmac4_get_tx_ls,
+        .get_rx_frame_len = dwmac4_wrback_get_rx_frame_len,
+        .enable_tx_timestamp = dwmac4_rd_enable_tx_timestamp,
+        .get_tx_timestamp_status = dwmac4_wrback_get_tx_timestamp_status,
+        .get_timestamp = dwmac4_wrback_get_timestamp,
+        .get_rx_timestamp_status = dwmac4_context_get_rx_timestamp_status,
+        .set_tx_ic = dwmac4_rd_set_tx_ic,
+        .prepare_tx_desc = dwmac4_rd_prepare_tx_desc,
+        .prepare_tso_tx_desc = dwmac4_rd_prepare_tso_tx_desc,
+        .release_tx_desc = dwmac4_release_tx_desc,
+        .init_rx_desc = dwmac4_rd_init_rx_desc,
+        .init_tx_desc = dwmac4_rd_init_tx_desc,
+        .display_ring = dwmac4_display_ring,
+        .set_mss = dwmac4_set_mss_ctxt,
+};
+
+const struct stmmac_mode_ops dwmac4_ring_mode_ops = { };
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.h b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.h
new file mode 100644
index 000000000000..0902a2edeaa9
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_descs.h
@@ -0,0 +1,129 @@
+/*
+ * Header File to describe the DMA descriptors and related definitions specific
+ * for DesignWare databook 4.xx.
+ *
+ * Copyright (C) 2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#ifndef __DWMAC4_DESCS_H__
+#define __DWMAC4_DESCS_H__
+
+#include <linux/bitops.h>
+
+/* Normal transmit descriptor defines (without split feature) */
+
+/* TDES2 (read format) */
+#define TDES2_BUFFER1_SIZE_MASK         GENMASK(13, 0)
+#define TDES2_VLAN_TAG_MASK             GENMASK(15, 14)
+#define TDES2_BUFFER2_SIZE_MASK         GENMASK(29, 16)
+#define TDES2_BUFFER2_SIZE_MASK_SHIFT   16
+#define TDES2_TIMESTAMP_ENABLE          BIT(30)
+#define TDES2_INTERRUPT_ON_COMPLETION   BIT(31)
+
+/* TDES3 (read format) */
+#define TDES3_PACKET_SIZE_MASK          GENMASK(14, 0)
+#define TDES3_CHECKSUM_INSERTION_MASK   GENMASK(17, 16)
+#define TDES3_CHECKSUM_INSERTION_SHIFT  16
+#define TDES3_TCP_PKT_PAYLOAD_MASK      GENMASK(17, 0)
+#define TDES3_TCP_SEGMENTATION_ENABLE   BIT(18)
+#define TDES3_HDR_LEN_SHIFT             19
+#define TDES3_SLOT_NUMBER_MASK          GENMASK(22, 19)
+#define TDES3_SA_INSERT_CTRL_MASK       GENMASK(25, 23)
+#define TDES3_CRC_PAD_CTRL_MASK         GENMASK(27, 26)
+
+/* TDES3 (write back format) */
+#define TDES3_IP_HDR_ERROR              BIT(0)
+#define TDES3_DEFERRED                  BIT(1)
+#define TDES3_UNDERFLOW_ERROR           BIT(2)
+#define TDES3_EXCESSIVE_DEFERRAL        BIT(3)
+#define TDES3_COLLISION_COUNT_MASK      GENMASK(7, 4)
+#define TDES3_COLLISION_COUNT_SHIFT     4
+#define TDES3_EXCESSIVE_COLLISION       BIT(8)
+#define TDES3_LATE_COLLISION            BIT(9)
+#define TDES3_NO_CARRIER                BIT(10)
+#define TDES3_LOSS_CARRIER              BIT(11)
+#define TDES3_PAYLOAD_ERROR             BIT(12)
+#define TDES3_PACKET_FLUSHED            BIT(13)
+#define TDES3_JABBER_TIMEOUT            BIT(14)
+#define TDES3_ERROR_SUMMARY             BIT(15)
+#define TDES3_TIMESTAMP_STATUS          BIT(17)
+#define TDES3_TIMESTAMP_STATUS_SHIFT    17
+
+/* TDES3 context */
+#define TDES3_CTXT_TCMSSV               BIT(26)
+
+/* TDES3 Common */
+#define TDES3_LAST_DESCRIPTOR           BIT(28)
+#define TDES3_LAST_DESCRIPTOR_SHIFT     28
+#define TDES3_FIRST_DESCRIPTOR          BIT(29)
+#define TDES3_CONTEXT_TYPE              BIT(30)
+
+/* TDS3 use for both format (read and write back) */
+#define TDES3_OWN                       BIT(31)
+#define TDES3_OWN_SHIFT                 31
+
+/* Normal receive descriptor defines (without split feature) */
+
+/* RDES0 (write back format) */
+#define RDES0_VLAN_TAG_MASK             GENMASK(15, 0)
+
+/* RDES1 (write back format) */
+#define RDES1_IP_PAYLOAD_TYPE_MASK      GENMASK(2, 0)
+#define RDES1_IP_HDR_ERROR              BIT(3)
+#define RDES1_IPV4_HEADER               BIT(4)
+#define RDES1_IPV6_HEADER               BIT(5)
+#define RDES1_IP_CSUM_BYPASSED          BIT(6)
+#define RDES1_IP_CSUM_ERROR             BIT(7)
+#define RDES1_PTP_MSG_TYPE_MASK         GENMASK(11, 8)
+#define RDES1_PTP_PACKET_TYPE           BIT(12)
+#define RDES1_PTP_VER                   BIT(13)
+#define RDES1_TIMESTAMP_AVAILABLE       BIT(14)
+#define RDES1_TIMESTAMP_AVAILABLE_SHIFT 14
+#define RDES1_TIMESTAMP_DROPPED         BIT(15)
+#define RDES1_IP_TYPE1_CSUM_MASK        GENMASK(31, 16)
+
+/* RDES2 (write back format) */
+#define RDES2_L3_L4_HEADER_SIZE_MASK    GENMASK(9, 0)
+#define RDES2_VLAN_FILTER_STATUS        BIT(15)
+#define RDES2_SA_FILTER_FAIL            BIT(16)
+#define RDES2_DA_FILTER_FAIL            BIT(17)
+#define RDES2_HASH_FILTER_STATUS        BIT(18)
+#define RDES2_MAC_ADDR_MATCH_MASK       GENMASK(26, 19)
+#define RDES2_HASH_VALUE_MATCH_MASK     GENMASK(26, 19)
+#define RDES2_L3_FILTER_MATCH           BIT(27)
+#define RDES2_L4_FILTER_MATCH           BIT(28)
+#define RDES2_L3_L4_FILT_NB_MATCH_MASK  GENMASK(27, 26)
+#define RDES2_L3_L4_FILT_NB_MATCH_SHIFT 26
+
+/* RDES3 (write back format) */
+#define RDES3_PACKET_SIZE_MASK          GENMASK(14, 0)
+#define RDES3_ERROR_SUMMARY             BIT(15)
+#define RDES3_PACKET_LEN_TYPE_MASK      GENMASK(18, 16)
+#define RDES3_DRIBBLE_ERROR             BIT(19)
+#define RDES3_RECEIVE_ERROR             BIT(20)
+#define RDES3_OVERFLOW_ERROR            BIT(21)
+#define RDES3_RECEIVE_WATCHDOG          BIT(22)
+#define RDES3_GIANT_PACKET              BIT(23)
+#define RDES3_CRC_ERROR                 BIT(24)
+#define RDES3_RDES0_VALID               BIT(25)
+#define RDES3_RDES1_VALID               BIT(26)
+#define RDES3_RDES2_VALID               BIT(27)
+#define RDES3_LAST_DESCRIPTOR           BIT(28)
+#define RDES3_FIRST_DESCRIPTOR          BIT(29)
+#define RDES3_CONTEXT_DESCRIPTOR        BIT(30)
+
+/* RDES3 (read format) */
+#define RDES3_BUFFER1_VALID_ADDR        BIT(24)
+#define RDES3_BUFFER2_VALID_ADDR        BIT(25)
+#define RDES3_INT_ON_COMPLETION_EN      BIT(30)
+
+/* TDS3 use for both format (read and write back) */
+#define RDES3_OWN                       BIT(31)
+
+#endif /* __DWMAC4_DESCS_H__ */
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c
new file mode 100644
index 000000000000..116151cd6a95
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c
@@ -0,0 +1,354 @@
+/*
+ * This is the driver for the GMAC on-chip Ethernet controller for ST SoCs.
+ * DWC Ether MAC version 4.xx  has been used for  developing this code.
+ *
+ * This contains the functions to handle the dma.
+ *
+ * Copyright (C) 2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#include <linux/io.h>
+#include "dwmac4.h"
+#include "dwmac4_dma.h"
+
+static void dwmac4_dma_axi(void __iomem *ioaddr, struct stmmac_axi *axi)
+{
+        u32 value = readl(ioaddr + DMA_SYS_BUS_MODE);
+        int i;
+
+        pr_info("dwmac4: Master AXI performs %s burst length\n",
+                (value & DMA_SYS_BUS_FB) ? "fixed" : "any");
+
+        if (axi->axi_lpi_en)
+                value |= DMA_AXI_EN_LPI;
+        if (axi->axi_xit_frm)
+                value |= DMA_AXI_LPI_XIT_FRM;
+
+        value |= (axi->axi_wr_osr_lmt & DMA_AXI_OSR_MAX) <<
+                 DMA_AXI_WR_OSR_LMT_SHIFT;
+
+        value |= (axi->axi_rd_osr_lmt & DMA_AXI_OSR_MAX) <<
+                 DMA_AXI_RD_OSR_LMT_SHIFT;
+
+        /* Depending on the UNDEF bit the Master AXI will perform any burst
+         * length according to the BLEN programmed (by default all BLEN are
+         * set).
+         */
+        for (i = 0; i < AXI_BLEN; i++) {
+                switch (axi->axi_blen[i]) {
+                case 256:
+                        value |= DMA_AXI_BLEN256;
+                        break;
+                case 128:
+                        value |= DMA_AXI_BLEN128;
+                        break;
+                case 64:
+                        value |= DMA_AXI_BLEN64;
+                        break;
+                case 32:
+                        value |= DMA_AXI_BLEN32;
+                        break;
+                case 16:
+                        value |= DMA_AXI_BLEN16;
+                        break;
+                case 8:
+                        value |= DMA_AXI_BLEN8;
+                        break;
+                case 4:
+                        value |= DMA_AXI_BLEN4;
+                        break;
+                }
+        }
+
+        writel(value, ioaddr + DMA_SYS_BUS_MODE);
+}
+
+static void dwmac4_dma_init_channel(void __iomem *ioaddr, int pbl,
+                                    u32 dma_tx_phy, u32 dma_rx_phy,
+                                    u32 channel)
+{
+        u32 value;
+
+        /* set PBL for each channels. Currently we affect same configuration
+         * on each channel
+         */
+        value = readl(ioaddr + DMA_CHAN_CONTROL(channel));
+        value = value | DMA_BUS_MODE_PBL;
+        writel(value, ioaddr + DMA_CHAN_CONTROL(channel));
+
+        value = readl(ioaddr + DMA_CHAN_TX_CONTROL(channel));
+        value = value | (pbl << DMA_BUS_MODE_PBL_SHIFT);
+        writel(value, ioaddr + DMA_CHAN_TX_CONTROL(channel));
+
+        value = readl(ioaddr + DMA_CHAN_RX_CONTROL(channel));
+        value = value | (pbl << DMA_BUS_MODE_RPBL_SHIFT);
+        writel(value, ioaddr + DMA_CHAN_RX_CONTROL(channel));
+
+        /* Mask interrupts by writing to CSR7 */
+        writel(DMA_CHAN_INTR_DEFAULT_MASK, ioaddr + DMA_CHAN_INTR_ENA(channel));
+
+        writel(dma_tx_phy, ioaddr + DMA_CHAN_TX_BASE_ADDR(channel));
+        writel(dma_rx_phy, ioaddr + DMA_CHAN_RX_BASE_ADDR(channel));
+}
+
+static void dwmac4_dma_init(void __iomem *ioaddr, int pbl, int fb, int mb,
+                            int aal, u32 dma_tx, u32 dma_rx, int atds)
+{
+        u32 value = readl(ioaddr + DMA_SYS_BUS_MODE);
+        int i;
+
+        /* Set the Fixed burst mode */
+        if (fb)
+                value |= DMA_SYS_BUS_FB;
+
+        /* Mixed Burst has no effect when fb is set */
+        if (mb)
+                value |= DMA_SYS_BUS_MB;
+
+        if (aal)
+                value |= DMA_SYS_BUS_AAL;
+
+        writel(value, ioaddr + DMA_SYS_BUS_MODE);
+
+        for (i = 0; i < DMA_CHANNEL_NB_MAX; i++)
+                dwmac4_dma_init_channel(ioaddr, pbl, dma_tx, dma_rx, i);
+}
+
+static void _dwmac4_dump_dma_regs(void __iomem *ioaddr, u32 channel)
+{
+        pr_debug(" Channel %d\n", channel);
+        pr_debug("\tDMA_CHAN_CONTROL, offset: 0x%x, val: 0x%x\n", 0,
+                 readl(ioaddr + DMA_CHAN_CONTROL(channel)));
+        pr_debug("\tDMA_CHAN_TX_CONTROL, offset: 0x%x, val: 0x%x\n", 0x4,
+                 readl(ioaddr + DMA_CHAN_TX_CONTROL(channel)));
+        pr_debug("\tDMA_CHAN_RX_CONTROL, offset: 0x%x, val: 0x%x\n", 0x8,
+                 readl(ioaddr + DMA_CHAN_RX_CONTROL(channel)));
+        pr_debug("\tDMA_CHAN_TX_BASE_ADDR, offset: 0x%x, val: 0x%x\n", 0x14,
+                 readl(ioaddr + DMA_CHAN_TX_BASE_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_RX_BASE_ADDR, offset: 0x%x, val: 0x%x\n", 0x1c,
+                 readl(ioaddr + DMA_CHAN_RX_BASE_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_TX_END_ADDR, offset: 0x%x, val: 0x%x\n", 0x20,
+                 readl(ioaddr + DMA_CHAN_TX_END_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_RX_END_ADDR, offset: 0x%x, val: 0x%x\n", 0x28,
+                 readl(ioaddr + DMA_CHAN_RX_END_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_TX_RING_LEN, offset: 0x%x, val: 0x%x\n", 0x2c,
+                 readl(ioaddr + DMA_CHAN_TX_RING_LEN(channel)));
+        pr_debug("\tDMA_CHAN_RX_RING_LEN, offset: 0x%x, val: 0x%x\n", 0x30,
+                 readl(ioaddr + DMA_CHAN_RX_RING_LEN(channel)));
+        pr_debug("\tDMA_CHAN_INTR_ENA, offset: 0x%x, val: 0x%x\n", 0x34,
+                 readl(ioaddr + DMA_CHAN_INTR_ENA(channel)));
+        pr_debug("\tDMA_CHAN_RX_WATCHDOG, offset: 0x%x, val: 0x%x\n", 0x38,
+                 readl(ioaddr + DMA_CHAN_RX_WATCHDOG(channel)));
+        pr_debug("\tDMA_CHAN_SLOT_CTRL_STATUS, offset: 0x%x, val: 0x%x\n", 0x3c,
+                 readl(ioaddr + DMA_CHAN_SLOT_CTRL_STATUS(channel)));
+        pr_debug("\tDMA_CHAN_CUR_TX_DESC, offset: 0x%x, val: 0x%x\n", 0x44,
+                 readl(ioaddr + DMA_CHAN_CUR_TX_DESC(channel)));
+        pr_debug("\tDMA_CHAN_CUR_RX_DESC, offset: 0x%x, val: 0x%x\n", 0x4c,
+                 readl(ioaddr + DMA_CHAN_CUR_RX_DESC(channel)));
+        pr_debug("\tDMA_CHAN_CUR_TX_BUF_ADDR, offset: 0x%x, val: 0x%x\n", 0x54,
+                 readl(ioaddr + DMA_CHAN_CUR_TX_BUF_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_CUR_RX_BUF_ADDR, offset: 0x%x, val: 0x%x\n", 0x5c,
+                 readl(ioaddr + DMA_CHAN_CUR_RX_BUF_ADDR(channel)));
+        pr_debug("\tDMA_CHAN_STATUS, offset: 0x%x, val: 0x%x\n", 0x60,
+                 readl(ioaddr + DMA_CHAN_STATUS(channel)));
+}
+
+static void dwmac4_dump_dma_regs(void __iomem *ioaddr)
+{
+        int i;
+
+        pr_debug(" GMAC4 DMA registers\n");
+
+        for (i = 0; i < DMA_CHANNEL_NB_MAX; i++)
+                _dwmac4_dump_dma_regs(ioaddr, i);
+}
+
+static void dwmac4_rx_watchdog(void __iomem *ioaddr, u32 riwt)
+{
+        int i;
+
+        for (i = 0; i < DMA_CHANNEL_NB_MAX; i++)
+                writel(riwt, ioaddr + DMA_CHAN_RX_WATCHDOG(i));
+}
+
+static void dwmac4_dma_chan_op_mode(void __iomem *ioaddr, int txmode,
+                                    int rxmode, u32 channel)
+{
+        u32 mtl_tx_op, mtl_rx_op, mtl_rx_int;
+
+        /* Following code only done for channel 0, other channels not yet
+         * supported.
+         */
+        mtl_tx_op = readl(ioaddr + MTL_CHAN_TX_OP_MODE(channel));
+
+        if (txmode == SF_DMA_MODE) {
+                pr_debug("GMAC: enable TX store and forward mode\n");
+                /* Transmit COE type 2 cannot be done in cut-through mode. */
+                mtl_tx_op |= MTL_OP_MODE_TSF;
+        } else {
+                pr_debug("GMAC: disabling TX SF (threshold %d)\n", txmode);
+                mtl_tx_op &= ~MTL_OP_MODE_TSF;
+                mtl_tx_op &= MTL_OP_MODE_TTC_MASK;
+                /* Set the transmit threshold */
+                if (txmode <= 32)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_32;
+                else if (txmode <= 64)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_64;
+                else if (txmode <= 96)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_96;
+                else if (txmode <= 128)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_128;
+                else if (txmode <= 192)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_192;
+                else if (txmode <= 256)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_256;
+                else if (txmode <= 384)
+                        mtl_tx_op |= MTL_OP_MODE_TTC_384;
+                else
+                        mtl_tx_op |= MTL_OP_MODE_TTC_512;
+        }
+
+        writel(mtl_tx_op, ioaddr +  MTL_CHAN_TX_OP_MODE(channel));
+
+        mtl_rx_op = readl(ioaddr + MTL_CHAN_RX_OP_MODE(channel));
+
+        if (rxmode == SF_DMA_MODE) {
+                pr_debug("GMAC: enable RX store and forward mode\n");
+                mtl_rx_op |= MTL_OP_MODE_RSF;
+        } else {
+                pr_debug("GMAC: disable RX SF mode (threshold %d)\n", rxmode);
+                mtl_rx_op &= ~MTL_OP_MODE_RSF;
+                mtl_rx_op &= MTL_OP_MODE_RTC_MASK;
+                if (rxmode <= 32)
+                        mtl_rx_op |= MTL_OP_MODE_RTC_32;
+                else if (rxmode <= 64)
+                        mtl_rx_op |= MTL_OP_MODE_RTC_64;
+                else if (rxmode <= 96)
+                        mtl_rx_op |= MTL_OP_MODE_RTC_96;
+                else
+                        mtl_rx_op |= MTL_OP_MODE_RTC_128;
+        }
+
+        writel(mtl_rx_op, ioaddr + MTL_CHAN_RX_OP_MODE(channel));
+
+        /* Enable MTL RX overflow */
+        mtl_rx_int = readl(ioaddr + MTL_CHAN_INT_CTRL(channel));
+        writel(mtl_rx_int | MTL_RX_OVERFLOW_INT_EN,
+               ioaddr + MTL_CHAN_INT_CTRL(channel));
+}
+
+static void dwmac4_dma_operation_mode(void __iomem *ioaddr, int txmode,
+                                      int rxmode, int rxfifosz)
+{
+        /* Only Channel 0 is actually configured and used */
+        dwmac4_dma_chan_op_mode(ioaddr, txmode, rxmode, 0);
+}
+
+static void dwmac4_get_hw_feature(void __iomem *ioaddr,
+                                  struct dma_features *dma_cap)
+{
+        u32 hw_cap = readl(ioaddr + GMAC_HW_FEATURE0);
+
+        /*  MAC HW feature0 */
+        dma_cap->mbps_10_100 = (hw_cap & GMAC_HW_FEAT_MIISEL);
+        dma_cap->mbps_1000 = (hw_cap & GMAC_HW_FEAT_GMIISEL) >> 1;
+        dma_cap->half_duplex = (hw_cap & GMAC_HW_FEAT_HDSEL) >> 2;
+        dma_cap->hash_filter = (hw_cap & GMAC_HW_FEAT_VLHASH) >> 4;
+        dma_cap->multi_addr = (hw_cap & GMAC_HW_FEAT_ADDMAC) >> 18;
+        dma_cap->pcs = (hw_cap & GMAC_HW_FEAT_PCSSEL) >> 3;
+        dma_cap->sma_mdio = (hw_cap & GMAC_HW_FEAT_SMASEL) >> 5;
+        dma_cap->pmt_remote_wake_up = (hw_cap & GMAC_HW_FEAT_RWKSEL) >> 6;
+        dma_cap->pmt_magic_frame = (hw_cap & GMAC_HW_FEAT_MGKSEL) >> 7;
+        /* MMC */
+        dma_cap->rmon = (hw_cap & GMAC_HW_FEAT_MMCSEL) >> 8;
+        /* IEEE 1588-2008 */
+        dma_cap->atime_stamp = (hw_cap & GMAC_HW_FEAT_TSSEL) >> 12;
+        /* 802.3az - Energy-Efficient Ethernet (EEE) */
+        dma_cap->eee = (hw_cap & GMAC_HW_FEAT_EEESEL) >> 13;
+        /* TX and RX csum */
+        dma_cap->tx_coe = (hw_cap & GMAC_HW_FEAT_TXCOSEL) >> 14;
+        dma_cap->rx_coe =  (hw_cap & GMAC_HW_FEAT_RXCOESEL) >> 16;
+
+        /* MAC HW feature1 */
+        hw_cap = readl(ioaddr + GMAC_HW_FEATURE1);
+        dma_cap->av = (hw_cap & GMAC_HW_FEAT_AVSEL) >> 20;
+        dma_cap->tsoen = (hw_cap & GMAC_HW_TSOEN) >> 18;
+        /* MAC HW feature2 */
+        hw_cap = readl(ioaddr + GMAC_HW_FEATURE2);
+        /* TX and RX number of channels */
+        dma_cap->number_rx_channel =
+                ((hw_cap & GMAC_HW_FEAT_RXCHCNT) >> 12) + 1;
+        dma_cap->number_tx_channel =
+                ((hw_cap & GMAC_HW_FEAT_TXCHCNT) >> 18) + 1;
+
+        /* IEEE 1588-2002 */
+        dma_cap->time_stamp = 0;
+}
+
+/* Enable/disable TSO feature and set MSS */
+static void dwmac4_enable_tso(void __iomem *ioaddr, bool en, u32 chan)
+{
+        u32 value;
+
+        if (en) {
+                /* enable TSO */
+                value = readl(ioaddr + DMA_CHAN_TX_CONTROL(chan));
+                writel(value | DMA_CONTROL_TSE,
+                       ioaddr + DMA_CHAN_TX_CONTROL(chan));
+        } else {
+                /* enable TSO */
+                value = readl(ioaddr + DMA_CHAN_TX_CONTROL(chan));
+                writel(value & ~DMA_CONTROL_TSE,
+                       ioaddr + DMA_CHAN_TX_CONTROL(chan));
+        }
+}
+
+const struct stmmac_dma_ops dwmac4_dma_ops = {
+        .reset = dwmac4_dma_reset,
+        .init = dwmac4_dma_init,
+        .axi = dwmac4_dma_axi,
+        .dump_regs = dwmac4_dump_dma_regs,
+        .dma_mode = dwmac4_dma_operation_mode,
+        .enable_dma_irq = dwmac4_enable_dma_irq,
+        .disable_dma_irq = dwmac4_disable_dma_irq,
+        .start_tx = dwmac4_dma_start_tx,
+        .stop_tx = dwmac4_dma_stop_tx,
+        .start_rx = dwmac4_dma_start_rx,
+        .stop_rx = dwmac4_dma_stop_rx,
+        .dma_interrupt = dwmac4_dma_interrupt,
+        .get_hw_feature = dwmac4_get_hw_feature,
+        .rx_watchdog = dwmac4_rx_watchdog,
+        .set_rx_ring_len = dwmac4_set_rx_ring_len,
+        .set_tx_ring_len = dwmac4_set_tx_ring_len,
+        .set_rx_tail_ptr = dwmac4_set_rx_tail_ptr,
+        .set_tx_tail_ptr = dwmac4_set_tx_tail_ptr,
+        .enable_tso = dwmac4_enable_tso,
+};
+
+const struct stmmac_dma_ops dwmac410_dma_ops = {
+        .reset = dwmac4_dma_reset,
+        .init = dwmac4_dma_init,
+        .axi = dwmac4_dma_axi,
+        .dump_regs = dwmac4_dump_dma_regs,
+        .dma_mode = dwmac4_dma_operation_mode,
+        .enable_dma_irq = dwmac410_enable_dma_irq,
+        .disable_dma_irq = dwmac4_disable_dma_irq,
+        .start_tx = dwmac4_dma_start_tx,
+        .stop_tx = dwmac4_dma_stop_tx,
+        .start_rx = dwmac4_dma_start_rx,
+        .stop_rx = dwmac4_dma_stop_rx,
+        .dma_interrupt = dwmac4_dma_interrupt,
+        .get_hw_feature = dwmac4_get_hw_feature,
+        .rx_watchdog = dwmac4_rx_watchdog,
+        .set_rx_ring_len = dwmac4_set_rx_ring_len,
+        .set_tx_ring_len = dwmac4_set_tx_ring_len,
+        .set_rx_tail_ptr = dwmac4_set_rx_tail_ptr,
+        .set_tx_tail_ptr = dwmac4_set_tx_tail_ptr,
+        .enable_tso = dwmac4_enable_tso,
+};
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.h b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.h
new file mode 100644
index 000000000000..1b06df749e2b
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.h
@@ -0,0 +1,202 @@
+/*
+ * DWMAC4 DMA Header file.
+ *
+ *
+ * Copyright (C) 2007-2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#ifndef __DWMAC4_DMA_H__
+#define __DWMAC4_DMA_H__
+
+/* Define the max channel number used for tx (also rx).
+ * dwmac4 accepts up to 8 channels for TX (and also 8 channels for RX
+ */
+#define DMA_CHANNEL_NB_MAX              1
+
+#define DMA_BUS_MODE                    0x00001000
+#define DMA_SYS_BUS_MODE                0x00001004
+#define DMA_STATUS                      0x00001008
+#define DMA_DEBUG_STATUS_0              0x0000100c
+#define DMA_DEBUG_STATUS_1              0x00001010
+#define DMA_DEBUG_STATUS_2              0x00001014
+#define DMA_AXI_BUS_MODE                0x00001028
+
+/* DMA Bus Mode bitmap */
+#define DMA_BUS_MODE_SFT_RESET          BIT(0)
+
+/* DMA SYS Bus Mode bitmap */
+#define DMA_BUS_MODE_SPH                BIT(24)
+#define DMA_BUS_MODE_PBL                BIT(16)
+#define DMA_BUS_MODE_PBL_SHIFT          16
+#define DMA_BUS_MODE_RPBL_SHIFT         16
+#define DMA_BUS_MODE_MB                 BIT(14)
+#define DMA_BUS_MODE_FB                 BIT(0)
+
+/* DMA Interrupt top status */
+#define DMA_STATUS_MAC                  BIT(17)
+#define DMA_STATUS_MTL                  BIT(16)
+#define DMA_STATUS_CHAN7                BIT(7)
+#define DMA_STATUS_CHAN6                BIT(6)
+#define DMA_STATUS_CHAN5                BIT(5)
+#define DMA_STATUS_CHAN4                BIT(4)
+#define DMA_STATUS_CHAN3                BIT(3)
+#define DMA_STATUS_CHAN2                BIT(2)
+#define DMA_STATUS_CHAN1                BIT(1)
+#define DMA_STATUS_CHAN0                BIT(0)
+
+/* DMA debug status bitmap */
+#define DMA_DEBUG_STATUS_TS_MASK        0xf
+#define DMA_DEBUG_STATUS_RS_MASK        0xf
+
+/* DMA AXI bitmap */
+#define DMA_AXI_EN_LPI                  BIT(31)
+#define DMA_AXI_LPI_XIT_FRM             BIT(30)
+#define DMA_AXI_WR_OSR_LMT              GENMASK(27, 24)
+#define DMA_AXI_WR_OSR_LMT_SHIFT        24
+#define DMA_AXI_RD_OSR_LMT              GENMASK(19, 16)
+#define DMA_AXI_RD_OSR_LMT_SHIFT        16
+
+#define DMA_AXI_OSR_MAX                 0xf
+#define DMA_AXI_MAX_OSR_LIMIT ((DMA_AXI_OSR_MAX << DMA_AXI_WR_OSR_LMT_SHIFT) | \
+                                (DMA_AXI_OSR_MAX << DMA_AXI_RD_OSR_LMT_SHIFT))
+
+#define DMA_SYS_BUS_MB                  BIT(14)
+#define DMA_AXI_1KBBE                   BIT(13)
+#define DMA_SYS_BUS_AAL                 BIT(12)
+#define DMA_AXI_BLEN256                 BIT(7)
+#define DMA_AXI_BLEN128                 BIT(6)
+#define DMA_AXI_BLEN64                  BIT(5)
+#define DMA_AXI_BLEN32                  BIT(4)
+#define DMA_AXI_BLEN16                  BIT(3)
+#define DMA_AXI_BLEN8                   BIT(2)
+#define DMA_AXI_BLEN4                   BIT(1)
+#define DMA_SYS_BUS_FB                  BIT(0)
+
+#define DMA_BURST_LEN_DEFAULT           (DMA_AXI_BLEN256 | DMA_AXI_BLEN128 | \
+                                        DMA_AXI_BLEN64 | DMA_AXI_BLEN32 | \
+                                        DMA_AXI_BLEN16 | DMA_AXI_BLEN8 | \
+                                        DMA_AXI_BLEN4)
+
+#define DMA_AXI_BURST_LEN_MASK          0x000000FE
+
+/* Following DMA defines are chanels oriented */
+#define DMA_CHAN_BASE_ADDR              0x00001100
+#define DMA_CHAN_BASE_OFFSET            0x80
+#define DMA_CHANX_BASE_ADDR(x)          (DMA_CHAN_BASE_ADDR + \
+                                        (x * DMA_CHAN_BASE_OFFSET))
+#define DMA_CHAN_REG_NUMBER             17
+
+#define DMA_CHAN_CONTROL(x)             DMA_CHANX_BASE_ADDR(x)
+#define DMA_CHAN_TX_CONTROL(x)          (DMA_CHANX_BASE_ADDR(x) + 0x4)
+#define DMA_CHAN_RX_CONTROL(x)          (DMA_CHANX_BASE_ADDR(x) + 0x8)
+#define DMA_CHAN_TX_BASE_ADDR(x)        (DMA_CHANX_BASE_ADDR(x) + 0x14)
+#define DMA_CHAN_RX_BASE_ADDR(x)        (DMA_CHANX_BASE_ADDR(x) + 0x1c)
+#define DMA_CHAN_TX_END_ADDR(x)         (DMA_CHANX_BASE_ADDR(x) + 0x20)
+#define DMA_CHAN_RX_END_ADDR(x)         (DMA_CHANX_BASE_ADDR(x) + 0x28)
+#define DMA_CHAN_TX_RING_LEN(x)         (DMA_CHANX_BASE_ADDR(x) + 0x2c)
+#define DMA_CHAN_RX_RING_LEN(x)         (DMA_CHANX_BASE_ADDR(x) + 0x30)
+#define DMA_CHAN_INTR_ENA(x)            (DMA_CHANX_BASE_ADDR(x) + 0x34)
+#define DMA_CHAN_RX_WATCHDOG(x)         (DMA_CHANX_BASE_ADDR(x) + 0x38)
+#define DMA_CHAN_SLOT_CTRL_STATUS(x)    (DMA_CHANX_BASE_ADDR(x) + 0x3c)
+#define DMA_CHAN_CUR_TX_DESC(x)         (DMA_CHANX_BASE_ADDR(x) + 0x44)
+#define DMA_CHAN_CUR_RX_DESC(x)         (DMA_CHANX_BASE_ADDR(x) + 0x4c)
+#define DMA_CHAN_CUR_TX_BUF_ADDR(x)     (DMA_CHANX_BASE_ADDR(x) + 0x54)
+#define DMA_CHAN_CUR_RX_BUF_ADDR(x)     (DMA_CHANX_BASE_ADDR(x) + 0x5c)
+#define DMA_CHAN_STATUS(x)              (DMA_CHANX_BASE_ADDR(x) + 0x60)
+
+/* DMA Control X */
+#define DMA_CONTROL_MSS_MASK            GENMASK(13, 0)
+
+/* DMA Tx Channel X Control register defines */
+#define DMA_CONTROL_TSE                 BIT(12)
+#define DMA_CONTROL_OSP                 BIT(4)
+#define DMA_CONTROL_ST                  BIT(0)
+
+/* DMA Rx Channel X Control register defines */
+#define DMA_CONTROL_SR                  BIT(0)
+
+/* Interrupt status per channel */
+#define DMA_CHAN_STATUS_REB             GENMASK(21, 19)
+#define DMA_CHAN_STATUS_REB_SHIFT       19
+#define DMA_CHAN_STATUS_TEB             GENMASK(18, 16)
+#define DMA_CHAN_STATUS_TEB_SHIFT       16
+#define DMA_CHAN_STATUS_NIS             BIT(15)
+#define DMA_CHAN_STATUS_AIS             BIT(14)
+#define DMA_CHAN_STATUS_CDE             BIT(13)
+#define DMA_CHAN_STATUS_FBE             BIT(12)
+#define DMA_CHAN_STATUS_ERI             BIT(11)
+#define DMA_CHAN_STATUS_ETI             BIT(10)
+#define DMA_CHAN_STATUS_RWT             BIT(9)
+#define DMA_CHAN_STATUS_RPS             BIT(8)
+#define DMA_CHAN_STATUS_RBU             BIT(7)
+#define DMA_CHAN_STATUS_RI              BIT(6)
+#define DMA_CHAN_STATUS_TBU             BIT(2)
+#define DMA_CHAN_STATUS_TPS             BIT(1)
+#define DMA_CHAN_STATUS_TI              BIT(0)
+
+/* Interrupt enable bits per channel */
+#define DMA_CHAN_INTR_ENA_NIE           BIT(16)
+#define DMA_CHAN_INTR_ENA_AIE           BIT(15)
+#define DMA_CHAN_INTR_ENA_NIE_4_10      BIT(15)
+#define DMA_CHAN_INTR_ENA_AIE_4_10      BIT(14)
+#define DMA_CHAN_INTR_ENA_CDE           BIT(13)
+#define DMA_CHAN_INTR_ENA_FBE           BIT(12)
+#define DMA_CHAN_INTR_ENA_ERE           BIT(11)
+#define DMA_CHAN_INTR_ENA_ETE           BIT(10)
+#define DMA_CHAN_INTR_ENA_RWE           BIT(9)
+#define DMA_CHAN_INTR_ENA_RSE           BIT(8)
+#define DMA_CHAN_INTR_ENA_RBUE          BIT(7)
+#define DMA_CHAN_INTR_ENA_RIE           BIT(6)
+#define DMA_CHAN_INTR_ENA_TBUE          BIT(2)
+#define DMA_CHAN_INTR_ENA_TSE           BIT(1)
+#define DMA_CHAN_INTR_ENA_TIE           BIT(0)
+
+#define DMA_CHAN_INTR_NORMAL            (DMA_CHAN_INTR_ENA_NIE | \
+                                         DMA_CHAN_INTR_ENA_RIE | \
+                                         DMA_CHAN_INTR_ENA_TIE)
+
+#define DMA_CHAN_INTR_ABNORMAL          (DMA_CHAN_INTR_ENA_AIE | \
+                                         DMA_CHAN_INTR_ENA_FBE)
+/* DMA default interrupt mask for 4.00 */
+#define DMA_CHAN_INTR_DEFAULT_MASK      (DMA_CHAN_INTR_NORMAL | \
+                                         DMA_CHAN_INTR_ABNORMAL)
+
+#define DMA_CHAN_INTR_NORMAL_4_10       (DMA_CHAN_INTR_ENA_NIE_4_10 | \
+                                         DMA_CHAN_INTR_ENA_RIE | \
+                                         DMA_CHAN_INTR_ENA_TIE)
+
+#define DMA_CHAN_INTR_ABNORMAL_4_10     (DMA_CHAN_INTR_ENA_AIE_4_10 | \
+                                         DMA_CHAN_INTR_ENA_FBE)
+/* DMA default interrupt mask for 4.10a */
+#define DMA_CHAN_INTR_DEFAULT_MASK_4_10 (DMA_CHAN_INTR_NORMAL_4_10 | \
+                                         DMA_CHAN_INTR_ABNORMAL_4_10)
+
+/* channel 0 specific fields */
+#define DMA_CHAN0_DBG_STAT_TPS          GENMASK(15, 12)
+#define DMA_CHAN0_DBG_STAT_TPS_SHIFT    12
+#define DMA_CHAN0_DBG_STAT_RPS          GENMASK(11, 8)
+#define DMA_CHAN0_DBG_STAT_RPS_SHIFT    8
+
+int dwmac4_dma_reset(void __iomem *ioaddr);
+void dwmac4_enable_dma_transmission(void __iomem *ioaddr, u32 tail_ptr);
+void dwmac4_enable_dma_irq(void __iomem *ioaddr);
+void dwmac410_enable_dma_irq(void __iomem *ioaddr);
+void dwmac4_disable_dma_irq(void __iomem *ioaddr);
+void dwmac4_dma_start_tx(void __iomem *ioaddr);
+void dwmac4_dma_stop_tx(void __iomem *ioaddr);
+void dwmac4_dma_start_rx(void __iomem *ioaddr);
+void dwmac4_dma_stop_rx(void __iomem *ioaddr);
+int dwmac4_dma_interrupt(void __iomem *ioaddr,
+                         struct stmmac_extra_stats *x);
+void dwmac4_set_rx_ring_len(void __iomem *ioaddr, u32 len);
+void dwmac4_set_tx_ring_len(void __iomem *ioaddr, u32 len);
+void dwmac4_set_rx_tail_ptr(void __iomem *ioaddr, u32 tail_ptr, u32 chan);
+void dwmac4_set_tx_tail_ptr(void __iomem *ioaddr, u32 tail_ptr, u32 chan);
+
+#endif /* __DWMAC4_DMA_H__ */
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c
new file mode 100644
index 000000000000..c7326d5b2f43
--- /dev/null
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2007-2015  STMicroelectronics Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * Author: Alexandre Torgue <alexandre.torgue@st.com>
+ */
+
+#include <linux/io.h>
+#include <linux/delay.h>
+#include "common.h"
+#include "dwmac4_dma.h"
+#include "dwmac4.h"
+
+int dwmac4_dma_reset(void __iomem *ioaddr)
+{
+        u32 value = readl(ioaddr + DMA_BUS_MODE);
+        int limit;
+
+        /* DMA SW reset */
+        value |= DMA_BUS_MODE_SFT_RESET;
+        writel(value, ioaddr + DMA_BUS_MODE);
+        limit = 10;
+        while (limit--) {
+                if (!(readl(ioaddr + DMA_BUS_MODE) & DMA_BUS_MODE_SFT_RESET))
+                        break;
+                mdelay(10);
+        }
+
+        if (limit < 0)
+                return -EBUSY;
+
+        return 0;
+}
+
+void dwmac4_set_rx_tail_ptr(void __iomem *ioaddr, u32 tail_ptr, u32 chan)
+{
+        writel(tail_ptr, ioaddr + DMA_CHAN_RX_END_ADDR(0));
+}
+
+void dwmac4_set_tx_tail_ptr(void __iomem *ioaddr, u32 tail_ptr, u32 chan)
+{
+        writel(tail_ptr, ioaddr + DMA_CHAN_TX_END_ADDR(0));
+}
+
+void dwmac4_dma_start_tx(void __iomem *ioaddr)
+{
+        u32 value = readl(ioaddr + DMA_CHAN_TX_CONTROL(STMMAC_CHAN0));
+
+        value |= DMA_CONTROL_ST;
+        writel(value, ioaddr + DMA_CHAN_TX_CONTROL(STMMAC_CHAN0));
+
+        value = readl(ioaddr + GMAC_CONFIG);
+        value |= GMAC_CONFIG_TE;
+        writel(value, ioaddr + GMAC_CONFIG);
+}
+
+void dwmac4_dma_stop_tx(void __iomem *ioaddr)
+{
+        u32 value = readl(ioaddr + DMA_CHAN_TX_CONTROL(STMMAC_CHAN0));
+
+        value &= ~DMA_CONTROL_ST;
+        writel(value, ioaddr + DMA_CHAN_TX_CONTROL(STMMAC_CHAN0));
+
+        value = readl(ioaddr + GMAC_CONFIG);
+        value &= ~GMAC_CONFIG_TE;
+        writel(value, ioaddr + GMAC_CONFIG);
+}
+
+void dwmac4_dma_start_rx(void __iomem *ioaddr)
+{
+        u32 value = readl(ioaddr + DMA_CHAN_RX_CONTROL(STMMAC_CHAN0));
+
+        value |= DMA_CONTROL_SR;
+
+        writel(value, ioaddr + DMA_CHAN_RX_CONTROL(STMMAC_CHAN0));
+
+        value = readl(ioaddr + GMAC_CONFIG);
+        value |= GMAC_CONFIG_RE;
+        writel(value, ioaddr + GMAC_CONFIG);
+}
+
+void dwmac4_dma_stop_rx(void __iomem *ioaddr)
+{
+        u32 value = readl(ioaddr + DMA_CHAN_RX_CONTROL(STMMAC_CHAN0));
+
+        value &= ~DMA_CONTROL_SR;
+        writel(value, ioaddr + DMA_CHAN_RX_CONTROL(STMMAC_CHAN0));
+
+        value = readl(ioaddr + GMAC_CONFIG);
+        value &= ~GMAC_CONFIG_RE;
+        writel(value, ioaddr + GMAC_CONFIG);
+}
+
+void dwmac4_set_tx_ring_len(void __iomem *ioaddr, u32 len)
+{
+        writel(len, ioaddr + DMA_CHAN_TX_RING_LEN(STMMAC_CHAN0));
+}
+
+void dwmac4_set_rx_ring_len(void __iomem *ioaddr, u32 len)
+{
+        writel(len, ioaddr + DMA_CHAN_RX_RING_LEN(STMMAC_CHAN0));
+}
+
+void dwmac4_enable_dma_irq(void __iomem *ioaddr)
+{
+        writel(DMA_CHAN_INTR_DEFAULT_MASK, ioaddr +
+               DMA_CHAN_INTR_ENA(STMMAC_CHAN0));
+}
+
+void dwmac410_enable_dma_irq(void __iomem *ioaddr)
+{
+        writel(DMA_CHAN_INTR_DEFAULT_MASK_4_10,
+               ioaddr + DMA_CHAN_INTR_ENA(STMMAC_CHAN0));
+}
+
+void dwmac4_disable_dma_irq(void __iomem *ioaddr)
+{
+        writel(0, ioaddr + DMA_CHAN_INTR_ENA(STMMAC_CHAN0));
+}
+
+int dwmac4_dma_interrupt(void __iomem *ioaddr,
+                         struct stmmac_extra_stats *x)
+{
+        int ret = 0;
+
+        u32 intr_status = readl(ioaddr + DMA_CHAN_STATUS(0));
+
+        /* ABNORMAL interrupts */
+        if (unlikely(intr_status & DMA_CHAN_STATUS_AIS)) {
+                if (unlikely(intr_status & DMA_CHAN_STATUS_RBU))
+                        x->rx_buf_unav_irq++;
+                if (unlikely(intr_status & DMA_CHAN_STATUS_RPS))
+                        x->rx_process_stopped_irq++;
+                if (unlikely(intr_status & DMA_CHAN_STATUS_RWT))
+                        x->rx_watchdog_irq++;
+                if (unlikely(intr_status & DMA_CHAN_STATUS_ETI))
+                        x->tx_early_irq++;
+                if (unlikely(intr_status & DMA_CHAN_STATUS_TPS)) {
+                        x->tx_process_stopped_irq++;
+                        ret = tx_hard_error;
+                }
+                if (unlikely(intr_status & DMA_CHAN_STATUS_FBE)) {
+                        x->fatal_bus_error_irq++;
+                        ret = tx_hard_error;
+                }
+        }
+        /* TX/RX NORMAL interrupts */
+        if (likely(intr_status & DMA_CHAN_STATUS_NIS)) {
+                x->normal_irq_n++;
+                if (likely(intr_status & DMA_CHAN_STATUS_RI)) {
+                        u32 value;
+
+                        value = readl(ioaddr + DMA_CHAN_INTR_ENA(STMMAC_CHAN0));
+                        /* to schedule NAPI on real RIE event. */
+                        if (likely(value & DMA_CHAN_INTR_ENA_RIE)) {
+                                x->rx_normal_irq_n++;
+                                ret |= handle_rx;
+                        }
+                }
+                if (likely(intr_status & DMA_CHAN_STATUS_TI)) {
+                        x->tx_normal_irq_n++;
+                        ret |= handle_tx;
+                }
+                if (unlikely(intr_status & DMA_CHAN_STATUS_ERI))
+                        x->rx_early_irq++;
+        }
+
+        /* Clear the interrupt by writing a logic 1 to the chanX interrupt
+         * status [21-0] expect reserved bits [5-3]
+         */
+        writel((intr_status & 0x3fffc7),
+               ioaddr + DMA_CHAN_STATUS(STMMAC_CHAN0));
+
+        return ret;
+}
+
+void stmmac_dwmac4_set_mac_addr(void __iomem *ioaddr, u8 addr[6],
+                                unsigned int high, unsigned int low)
+{
+        unsigned long data;
+
+        data = (addr[5] << 8) | addr[4];
+        /* For MAC Addr registers se have to set the Address Enable (AE)
+         * bit that has no effect on the High Reg 0 where the bit 31 (MO)
+         * is RO.
+         */
+        data |= (STMMAC_CHAN0 << GMAC_HI_DCS_SHIFT);
+        writel(data | GMAC_HI_REG_AE, ioaddr + high);
+        data = (addr[3] << 24) | (addr[2] << 16) | (addr[1] << 8) | addr[0];
+        writel(data, ioaddr + low);
+}
+
+/* Enable disable MAC RX/TX */
+void stmmac_dwmac4_set_mac(void __iomem *ioaddr, bool enable)
+{
+        u32 value = readl(ioaddr + GMAC_CONFIG);
+
+        if (enable)
+                value |= GMAC_CONFIG_RE | GMAC_CONFIG_TE;
+        else
+                value &= ~(GMAC_CONFIG_TE | GMAC_CONFIG_RE);
+
+        writel(value, ioaddr + GMAC_CONFIG);
+}
+
+void stmmac_dwmac4_get_mac_addr(void __iomem *ioaddr, unsigned char *addr,
+                                unsigned int high, unsigned int low)
+{
+        unsigned int hi_addr, lo_addr;
+
+        /* Read the MAC address from the hardware */
+        hi_addr = readl(ioaddr + high);
+        lo_addr = readl(ioaddr + low);
+
+        /* Extract the MAC address from the high and low words */
+        addr[0] = lo_addr & 0xff;
+        addr[1] = (lo_addr >> 8) & 0xff;
+        addr[2] = (lo_addr >> 16) & 0xff;
+        addr[3] = (lo_addr >> 24) & 0xff;
+        addr[4] = hi_addr & 0xff;
+        addr[5] = (hi_addr >> 8) & 0xff;
+}
diff --git a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c
index cfb018c7c5eb..38f19c99cf59 100644
--- a/drivers/net/ethernet/stmicro/stmmac/enh_desc.c
+++ b/drivers/net/ethernet/stmicro/stmmac/enh_desc.c
@@ -411,6 +411,26 @@ static int enh_desc_get_rx_timestamp_status(void *desc, u32 ats)
         }
 }
 
+static void enh_desc_display_ring(void *head, unsigned int size, bool rx)
+{
+        struct dma_extended_desc *ep = (struct dma_extended_desc *)head;
+        int i;
+
+        pr_info("Extended %s descriptor ring:\n", rx ? "RX" : "TX");
+
+        for (i = 0; i < size; i++) {
+                u64 x;
+
+                x = *(u64 *)ep;
+                pr_info("%d [0x%x]: 0x%x 0x%x 0x%x 0x%x\n",
+                        i, (unsigned int)virt_to_phys(ep),
+                        (unsigned int)x, (unsigned int)(x >> 32),
+                        ep->basic.des2, ep->basic.des3);
+                ep++;
+        }
+        pr_info("\n");
+}
+
 const struct stmmac_desc_ops enh_desc_ops = {
         .tx_status = enh_desc_get_tx_status,
         .rx_status = enh_desc_get_rx_status,
@@ -430,4 +450,5 @@ const struct stmmac_desc_ops enh_desc_ops = {
         .get_tx_timestamp_status = enh_desc_get_tx_timestamp_status,
         .get_timestamp = enh_desc_get_timestamp,
         .get_rx_timestamp_status = enh_desc_get_rx_timestamp_status,
+        .display_ring = enh_desc_display_ring,
 };
diff --git a/drivers/net/ethernet/stmicro/stmmac/mmc.h b/drivers/net/ethernet/stmicro/stmmac/mmc.h
index 192c2491330b..38a1a5603293 100644
--- a/drivers/net/ethernet/stmicro/stmmac/mmc.h
+++ b/drivers/net/ethernet/stmicro/stmmac/mmc.h
@@ -35,6 +35,10 @@
                                                  * current value.*/
 #define MMC_CNTRL_PRESET                0x10
 #define MMC_CNTRL_FULL_HALF_PRESET      0x20
+
+#define MMC_GMAC4_OFFSET                0x700
+#define MMC_GMAC3_X_OFFSET              0x100
+
 struct stmmac_counters {
         unsigned int mmc_tx_octetcount_gb;
         unsigned int mmc_tx_framecount_gb;
diff --git a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
index 3f20bb1fe570..ce9aa792857b 100644
--- a/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
+++ b/drivers/net/ethernet/stmicro/stmmac/mmc_core.c
@@ -28,12 +28,12 @@
 
 /* MAC Management Counters register offset */
 
-#define MMC_CNTRL               0x00000100      /* MMC Control */
-#define MMC_RX_INTR             0x00000104      /* MMC RX Interrupt */
-#define MMC_TX_INTR             0x00000108      /* MMC TX Interrupt */
-#define MMC_RX_INTR_MASK        0x0000010c      /* MMC Interrupt Mask */
-#define MMC_TX_INTR_MASK        0x00000110      /* MMC Interrupt Mask */
-#define MMC_DEFAULT_MASK                0xffffffff
+#define MMC_CNTRL               0x00    /* MMC Control */
+#define MMC_RX_INTR             0x04    /* MMC RX Interrupt */
+#define MMC_TX_INTR             0x08    /* MMC TX Interrupt */
+#define MMC_RX_INTR_MASK        0x0c    /* MMC Interrupt Mask */
+#define MMC_TX_INTR_MASK        0x10    /* MMC Interrupt Mask */
+#define MMC_DEFAULT_MASK        0xffffffff
 
 /* MMC TX counter registers */
 
@@ -41,115 +41,115 @@
  * _GB register stands for good and bad frames
  * _G is for good only.
  */
-#define MMC_TX_OCTETCOUNT_GB            0x00000114
-#define MMC_TX_FRAMECOUNT_GB            0x00000118
-#define MMC_TX_BROADCASTFRAME_G         0x0000011c
-#define MMC_TX_MULTICASTFRAME_G         0x00000120
-#define MMC_TX_64_OCTETS_GB             0x00000124
-#define MMC_TX_65_TO_127_OCTETS_GB      0x00000128
-#define MMC_TX_128_TO_255_OCTETS_GB     0x0000012c
-#define MMC_TX_256_TO_511_OCTETS_GB     0x00000130
-#define MMC_TX_512_TO_1023_OCTETS_GB    0x00000134
-#define MMC_TX_1024_TO_MAX_OCTETS_GB    0x00000138
-#define MMC_TX_UNICAST_GB               0x0000013c
-#define MMC_TX_MULTICAST_GB             0x00000140
-#define MMC_TX_BROADCAST_GB             0x00000144
-#define MMC_TX_UNDERFLOW_ERROR          0x00000148
-#define MMC_TX_SINGLECOL_G              0x0000014c
-#define MMC_TX_MULTICOL_G               0x00000150
-#define MMC_TX_DEFERRED                 0x00000154
-#define MMC_TX_LATECOL                  0x00000158
-#define MMC_TX_EXESSCOL                 0x0000015c
-#define MMC_TX_CARRIER_ERROR            0x00000160
-#define MMC_TX_OCTETCOUNT_G             0x00000164
-#define MMC_TX_FRAMECOUNT_G             0x00000168
-#define MMC_TX_EXCESSDEF                0x0000016c
-#define MMC_TX_PAUSE_FRAME              0x00000170
-#define MMC_TX_VLAN_FRAME_G             0x00000174
+#define MMC_TX_OCTETCOUNT_GB            0x14
+#define MMC_TX_FRAMECOUNT_GB            0x18
+#define MMC_TX_BROADCASTFRAME_G         0x1c
+#define MMC_TX_MULTICASTFRAME_G         0x20
+#define MMC_TX_64_OCTETS_GB             0x24
+#define MMC_TX_65_TO_127_OCTETS_GB      0x28
+#define MMC_TX_128_TO_255_OCTETS_GB     0x2c
+#define MMC_TX_256_TO_511_OCTETS_GB     0x30
+#define MMC_TX_512_TO_1023_OCTETS_GB    0x34
+#define MMC_TX_1024_TO_MAX_OCTETS_GB    0x38
+#define MMC_TX_UNICAST_GB               0x3c
+#define MMC_TX_MULTICAST_GB             0x40
+#define MMC_TX_BROADCAST_GB             0x44
+#define MMC_TX_UNDERFLOW_ERROR          0x48
+#define MMC_TX_SINGLECOL_G              0x4c
+#define MMC_TX_MULTICOL_G               0x50
+#define MMC_TX_DEFERRED                 0x54
+#define MMC_TX_LATECOL                  0x58
+#define MMC_TX_EXESSCOL                 0x5c
+#define MMC_TX_CARRIER_ERROR            0x60
+#define MMC_TX_OCTETCOUNT_G             0x64
+#define MMC_TX_FRAMECOUNT_G             0x68
+#define MMC_TX_EXCESSDEF                0x6c
+#define MMC_TX_PAUSE_FRAME              0x70
+#define MMC_TX_VLAN_FRAME_G             0x74
 
 /* MMC RX counter registers */
-#define MMC_RX_FRAMECOUNT_GB            0x00000180
-#define MMC_RX_OCTETCOUNT_GB            0x00000184
-#define MMC_RX_OCTETCOUNT_G             0x00000188
-#define MMC_RX_BROADCASTFRAME_G         0x0000018c
-#define MMC_RX_MULTICASTFRAME_G         0x00000190
-#define MMC_RX_CRC_ERROR                0x00000194
-#define MMC_RX_ALIGN_ERROR              0x00000198
-#define MMC_RX_RUN_ERROR                0x0000019C
-#define MMC_RX_JABBER_ERROR             0x000001A0
-#define MMC_RX_UNDERSIZE_G              0x000001A4
-#define MMC_RX_OVERSIZE_G               0x000001A8
-#define MMC_RX_64_OCTETS_GB             0x000001AC
-#define MMC_RX_65_TO_127_OCTETS_GB      0x000001b0
-#define MMC_RX_128_TO_255_OCTETS_GB     0x000001b4
-#define MMC_RX_256_TO_511_OCTETS_GB     0x000001b8
-#define MMC_RX_512_TO_1023_OCTETS_GB    0x000001bc
-#define MMC_RX_1024_TO_MAX_OCTETS_GB    0x000001c0
-#define MMC_RX_UNICAST_G                0x000001c4
-#define MMC_RX_LENGTH_ERROR             0x000001c8
-#define MMC_RX_AUTOFRANGETYPE           0x000001cc
-#define MMC_RX_PAUSE_FRAMES             0x000001d0
-#define MMC_RX_FIFO_OVERFLOW            0x000001d4
-#define MMC_RX_VLAN_FRAMES_GB           0x000001d8
-#define MMC_RX_WATCHDOG_ERROR           0x000001dc
+#define MMC_RX_FRAMECOUNT_GB            0x80
+#define MMC_RX_OCTETCOUNT_GB            0x84
+#define MMC_RX_OCTETCOUNT_G             0x88
+#define MMC_RX_BROADCASTFRAME_G         0x8c
+#define MMC_RX_MULTICASTFRAME_G         0x90
+#define MMC_RX_CRC_ERROR                0x94
+#define MMC_RX_ALIGN_ERROR              0x98
+#define MMC_RX_RUN_ERROR                0x9C
+#define MMC_RX_JABBER_ERROR             0xA0
+#define MMC_RX_UNDERSIZE_G              0xA4
+#define MMC_RX_OVERSIZE_G               0xA8
+#define MMC_RX_64_OCTETS_GB             0xAC
+#define MMC_RX_65_TO_127_OCTETS_GB      0xb0
+#define MMC_RX_128_TO_255_OCTETS_GB     0xb4
+#define MMC_RX_256_TO_511_OCTETS_GB     0xb8
+#define MMC_RX_512_TO_1023_OCTETS_GB    0xbc
+#define MMC_RX_1024_TO_MAX_OCTETS_GB    0xc0
+#define MMC_RX_UNICAST_G                0xc4
+#define MMC_RX_LENGTH_ERROR             0xc8
+#define MMC_RX_AUTOFRANGETYPE           0xcc
+#define MMC_RX_PAUSE_FRAMES             0xd0
+#define MMC_RX_FIFO_OVERFLOW            0xd4
+#define MMC_RX_VLAN_FRAMES_GB           0xd8
+#define MMC_RX_WATCHDOG_ERROR           0xdc
 /* IPC*/
-#define MMC_RX_IPC_INTR_MASK            0x00000200
-#define MMC_RX_IPC_INTR                 0x00000208
+#define MMC_RX_IPC_INTR_MASK            0x100
+#define MMC_RX_IPC_INTR                 0x108
 /* IPv4*/
-#define MMC_RX_IPV4_GD                  0x00000210
-#define MMC_RX_IPV4_HDERR               0x00000214
-#define MMC_RX_IPV4_NOPAY               0x00000218
-#define MMC_RX_IPV4_FRAG                0x0000021C
-#define MMC_RX_IPV4_UDSBL               0x00000220
+#define MMC_RX_IPV4_GD                  0x110
+#define MMC_RX_IPV4_HDERR               0x114
+#define MMC_RX_IPV4_NOPAY               0x118
+#define MMC_RX_IPV4_FRAG                0x11C
+#define MMC_RX_IPV4_UDSBL               0x120
 
-#define MMC_RX_IPV4_GD_OCTETS           0x00000250
-#define MMC_RX_IPV4_HDERR_OCTETS        0x00000254
-#define MMC_RX_IPV4_NOPAY_OCTETS        0x00000258
-#define MMC_RX_IPV4_FRAG_OCTETS         0x0000025c
-#define MMC_RX_IPV4_UDSBL_OCTETS        0x00000260
+#define MMC_RX_IPV4_GD_OCTETS           0x150
+#define MMC_RX_IPV4_HDERR_OCTETS        0x154
+#define MMC_RX_IPV4_NOPAY_OCTETS        0x158
+#define MMC_RX_IPV4_FRAG_OCTETS         0x15c
+#define MMC_RX_IPV4_UDSBL_OCTETS        0x160
 
 /* IPV6*/
-#define MMC_RX_IPV6_GD_OCTETS           0x00000264
-#define MMC_RX_IPV6_HDERR_OCTETS        0x00000268
-#define MMC_RX_IPV6_NOPAY_OCTETS        0x0000026c
+#define MMC_RX_IPV6_GD_OCTETS           0x164
+#define MMC_RX_IPV6_HDERR_OCTETS        0x168
+#define MMC_RX_IPV6_NOPAY_OCTETS        0x16c
 
-#define MMC_RX_IPV6_GD                  0x00000224
-#define MMC_RX_IPV6_HDERR               0x00000228
-#define MMC_RX_IPV6_NOPAY               0x0000022c
+#define MMC_RX_IPV6_GD                  0x124
+#define MMC_RX_IPV6_HDERR               0x128
+#define MMC_RX_IPV6_NOPAY               0x12c
 
 /* Protocols*/
-#define MMC_RX_UDP_GD                   0x00000230
-#define MMC_RX_UDP_ERR                  0x00000234
-#define MMC_RX_TCP_GD                   0x00000238
-#define MMC_RX_TCP_ERR                  0x0000023c
-#define MMC_RX_ICMP_GD                  0x00000240
-#define MMC_RX_ICMP_ERR                 0x00000244
+#define MMC_RX_UDP_GD                   0x130
+#define MMC_RX_UDP_ERR                  0x134
+#define MMC_RX_TCP_GD                   0x138
+#define MMC_RX_TCP_ERR                  0x13c
+#define MMC_RX_ICMP_GD                  0x140
+#define MMC_RX_ICMP_ERR                 0x144
 
-#define MMC_RX_UDP_GD_OCTETS            0x00000270
-#define MMC_RX_UDP_ERR_OCTETS           0x00000274
-#define MMC_RX_TCP_GD_OCTETS            0x00000278
-#define MMC_RX_TCP_ERR_OCTETS           0x0000027c
-#define MMC_RX_ICMP_GD_OCTETS           0x00000280
-#define MMC_RX_ICMP_ERR_OCTETS          0x00000284
+#define MMC_RX_UDP_GD_OCTETS            0x170
+#define MMC_RX_UDP_ERR_OCTETS           0x174
+#define MMC_RX_TCP_GD_OCTETS            0x178
+#define MMC_RX_TCP_ERR_OCTETS           0x17c
+#define MMC_RX_ICMP_GD_OCTETS           0x180
+#define MMC_RX_ICMP_ERR_OCTETS          0x184
 
-void dwmac_mmc_ctrl(void __iomem *ioaddr, unsigned int mode)
+void dwmac_mmc_ctrl(void __iomem *mmcaddr, unsigned int mode)
 {
-        u32 value = readl(ioaddr + MMC_CNTRL);
+        u32 value = readl(mmcaddr + MMC_CNTRL);
 
         value |= (mode & 0x3F);
 
-        writel(value, ioaddr + MMC_CNTRL);
+        writel(value, mmcaddr + MMC_CNTRL);
 
         pr_debug("stmmac: MMC ctrl register (offset 0x%x): 0x%08x\n",
                  MMC_CNTRL, value);
 }
 
 /* To mask all all interrupts.*/
-void dwmac_mmc_intr_all_mask(void __iomem *ioaddr)
+void dwmac_mmc_intr_all_mask(void __iomem *mmcaddr)
 {
-        writel(MMC_DEFAULT_MASK, ioaddr + MMC_RX_INTR_MASK);
-        writel(MMC_DEFAULT_MASK, ioaddr + MMC_TX_INTR_MASK);
-        writel(MMC_DEFAULT_MASK, ioaddr + MMC_RX_IPC_INTR_MASK);
+        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_RX_INTR_MASK);
+        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_TX_INTR_MASK);
+        writel(MMC_DEFAULT_MASK, mmcaddr + MMC_RX_IPC_INTR_MASK);
 }
 
 /* This reads the MAC core counters (if actaully supported).
@@ -157,111 +157,116 @@ void dwmac_mmc_intr_all_mask(void __iomem *ioaddr)
  * counter after a read. So all the field of the mmc struct
  * have to be incremented.
  */
-void dwmac_mmc_read(void __iomem *ioaddr, struct stmmac_counters *mmc)
+void dwmac_mmc_read(void __iomem *mmcaddr, struct stmmac_counters *mmc)
 {
-        mmc->mmc_tx_octetcount_gb += readl(ioaddr + MMC_TX_OCTETCOUNT_GB);
-        mmc->mmc_tx_framecount_gb += readl(ioaddr + MMC_TX_FRAMECOUNT_GB);
-        mmc->mmc_tx_broadcastframe_g += readl(ioaddr + MMC_TX_BROADCASTFRAME_G);
-        mmc->mmc_tx_multicastframe_g += readl(ioaddr + MMC_TX_MULTICASTFRAME_G);
-        mmc->mmc_tx_64_octets_gb += readl(ioaddr + MMC_TX_64_OCTETS_GB);
+        mmc->mmc_tx_octetcount_gb += readl(mmcaddr + MMC_TX_OCTETCOUNT_GB);
+        mmc->mmc_tx_framecount_gb += readl(mmcaddr + MMC_TX_FRAMECOUNT_GB);
+        mmc->mmc_tx_broadcastframe_g += readl(mmcaddr +
+                                              MMC_TX_BROADCASTFRAME_G);
+        mmc->mmc_tx_multicastframe_g += readl(mmcaddr +
+                                              MMC_TX_MULTICASTFRAME_G);
+        mmc->mmc_tx_64_octets_gb += readl(mmcaddr + MMC_TX_64_OCTETS_GB);
         mmc->mmc_tx_65_to_127_octets_gb +=
-            readl(ioaddr + MMC_TX_65_TO_127_OCTETS_GB);
+            readl(mmcaddr + MMC_TX_65_TO_127_OCTETS_GB);
         mmc->mmc_tx_128_to_255_octets_gb +=
-            readl(ioaddr + MMC_TX_128_TO_255_OCTETS_GB);
+            readl(mmcaddr + MMC_TX_128_TO_255_OCTETS_GB);
         mmc->mmc_tx_256_to_511_octets_gb +=
-            readl(ioaddr + MMC_TX_256_TO_511_OCTETS_GB);
+            readl(mmcaddr + MMC_TX_256_TO_511_OCTETS_GB);
         mmc->mmc_tx_512_to_1023_octets_gb +=
-            readl(ioaddr + MMC_TX_512_TO_1023_OCTETS_GB);
+            readl(mmcaddr + MMC_TX_512_TO_1023_OCTETS_GB);
         mmc->mmc_tx_1024_to_max_octets_gb +=
-            readl(ioaddr + MMC_TX_1024_TO_MAX_OCTETS_GB);
-        mmc->mmc_tx_unicast_gb += readl(ioaddr + MMC_TX_UNICAST_GB);
-        mmc->mmc_tx_multicast_gb += readl(ioaddr + MMC_TX_MULTICAST_GB);
-        mmc->mmc_tx_broadcast_gb += readl(ioaddr + MMC_TX_BROADCAST_GB);
-        mmc->mmc_tx_underflow_error += readl(ioaddr + MMC_TX_UNDERFLOW_ERROR);
-        mmc->mmc_tx_singlecol_g += readl(ioaddr + MMC_TX_SINGLECOL_G);
-        mmc->mmc_tx_multicol_g += readl(ioaddr + MMC_TX_MULTICOL_G);
-        mmc->mmc_tx_deferred += readl(ioaddr + MMC_TX_DEFERRED);
-        mmc->mmc_tx_latecol += readl(ioaddr + MMC_TX_LATECOL);
-        mmc->mmc_tx_exesscol += readl(ioaddr + MMC_TX_EXESSCOL);
-        mmc->mmc_tx_carrier_error += readl(ioaddr + MMC_TX_CARRIER_ERROR);
-        mmc->mmc_tx_octetcount_g += readl(ioaddr + MMC_TX_OCTETCOUNT_G);
-        mmc->mmc_tx_framecount_g += readl(ioaddr + MMC_TX_FRAMECOUNT_G);
-        mmc->mmc_tx_excessdef += readl(ioaddr + MMC_TX_EXCESSDEF);
-        mmc->mmc_tx_pause_frame += readl(ioaddr + MMC_TX_PAUSE_FRAME);
-        mmc->mmc_tx_vlan_frame_g += readl(ioaddr + MMC_TX_VLAN_FRAME_G);
+            readl(mmcaddr + MMC_TX_1024_TO_MAX_OCTETS_GB);
+        mmc->mmc_tx_unicast_gb += readl(mmcaddr + MMC_TX_UNICAST_GB);
+        mmc->mmc_tx_multicast_gb += readl(mmcaddr + MMC_TX_MULTICAST_GB);
+        mmc->mmc_tx_broadcast_gb += readl(mmcaddr + MMC_TX_BROADCAST_GB);
+        mmc->mmc_tx_underflow_error += readl(mmcaddr + MMC_TX_UNDERFLOW_ERROR);
+        mmc->mmc_tx_singlecol_g += readl(mmcaddr + MMC_TX_SINGLECOL_G);
+        mmc->mmc_tx_multicol_g += readl(mmcaddr + MMC_TX_MULTICOL_G);
+        mmc->mmc_tx_deferred += readl(mmcaddr + MMC_TX_DEFERRED);
+        mmc->mmc_tx_latecol += readl(mmcaddr + MMC_TX_LATECOL);
+        mmc->mmc_tx_exesscol += readl(mmcaddr + MMC_TX_EXESSCOL);
+        mmc->mmc_tx_carrier_error += readl(mmcaddr + MMC_TX_CARRIER_ERROR);
+        mmc->mmc_tx_octetcount_g += readl(mmcaddr + MMC_TX_OCTETCOUNT_G);
+        mmc->mmc_tx_framecount_g += readl(mmcaddr + MMC_TX_FRAMECOUNT_G);
+        mmc->mmc_tx_excessdef += readl(mmcaddr + MMC_TX_EXCESSDEF);
+        mmc->mmc_tx_pause_frame += readl(mmcaddr + MMC_TX_PAUSE_FRAME);
+        mmc->mmc_tx_vlan_frame_g += readl(mmcaddr + MMC_TX_VLAN_FRAME_G);
 
         /* MMC RX counter registers */
-        mmc->mmc_rx_framecount_gb += readl(ioaddr + MMC_RX_FRAMECOUNT_GB);
-        mmc->mmc_rx_octetcount_gb += readl(ioaddr + MMC_RX_OCTETCOUNT_GB);
-        mmc->mmc_rx_octetcount_g += readl(ioaddr + MMC_RX_OCTETCOUNT_G);
-        mmc->mmc_rx_broadcastframe_g += readl(ioaddr + MMC_RX_BROADCASTFRAME_G);
-        mmc->mmc_rx_multicastframe_g += readl(ioaddr + MMC_RX_MULTICASTFRAME_G);
-        mmc->mmc_rx_crc_error += readl(ioaddr + MMC_RX_CRC_ERROR);
-        mmc->mmc_rx_align_error += readl(ioaddr + MMC_RX_ALIGN_ERROR);
-        mmc->mmc_rx_run_error += readl(ioaddr + MMC_RX_RUN_ERROR);
-        mmc->mmc_rx_jabber_error += readl(ioaddr + MMC_RX_JABBER_ERROR);
-        mmc->mmc_rx_undersize_g += readl(ioaddr + MMC_RX_UNDERSIZE_G);
-        mmc->mmc_rx_oversize_g += readl(ioaddr + MMC_RX_OVERSIZE_G);
-        mmc->mmc_rx_64_octets_gb += readl(ioaddr + MMC_RX_64_OCTETS_GB);
+        mmc->mmc_rx_framecount_gb += readl(mmcaddr + MMC_RX_FRAMECOUNT_GB);
+        mmc->mmc_rx_octetcount_gb += readl(mmcaddr + MMC_RX_OCTETCOUNT_GB);
+        mmc->mmc_rx_octetcount_g += readl(mmcaddr + MMC_RX_OCTETCOUNT_G);
+        mmc->mmc_rx_broadcastframe_g += readl(mmcaddr +
+                                              MMC_RX_BROADCASTFRAME_G);
+        mmc->mmc_rx_multicastframe_g += readl(mmcaddr +
+                                              MMC_RX_MULTICASTFRAME_G);
+        mmc->mmc_rx_crc_error += readl(mmcaddr + MMC_RX_CRC_ERROR);
+        mmc->mmc_rx_align_error += readl(mmcaddr + MMC_RX_ALIGN_ERROR);
+        mmc->mmc_rx_run_error += readl(mmcaddr + MMC_RX_RUN_ERROR);
+        mmc->mmc_rx_jabber_error += readl(mmcaddr + MMC_RX_JABBER_ERROR);
+        mmc->mmc_rx_undersize_g += readl(mmcaddr + MMC_RX_UNDERSIZE_G);
+        mmc->mmc_rx_oversize_g += readl(mmcaddr + MMC_RX_OVERSIZE_G);
+        mmc->mmc_rx_64_octets_gb += readl(mmcaddr + MMC_RX_64_OCTETS_GB);
         mmc->mmc_rx_65_to_127_octets_gb +=
-            readl(ioaddr + MMC_RX_65_TO_127_OCTETS_GB);
+            readl(mmcaddr + MMC_RX_65_TO_127_OCTETS_GB);
         mmc->mmc_rx_128_to_255_octets_gb +=
-            readl(ioaddr + MMC_RX_128_TO_255_OCTETS_GB);
+            readl(mmcaddr + MMC_RX_128_TO_255_OCTETS_GB);
         mmc->mmc_rx_256_to_511_octets_gb +=
-            readl(ioaddr + MMC_RX_256_TO_511_OCTETS_GB);
+            readl(mmcaddr + MMC_RX_256_TO_511_OCTETS_GB);
         mmc->mmc_rx_512_to_1023_octets_gb +=
-            readl(ioaddr + MMC_RX_512_TO_1023_OCTETS_GB);
+            readl(mmcaddr + MMC_RX_512_TO_1023_OCTETS_GB);
         mmc->mmc_rx_1024_to_max_octets_gb +=
-            readl(ioaddr + MMC_RX_1024_TO_MAX_OCTETS_GB);
-        mmc->mmc_rx_unicast_g += readl(ioaddr + MMC_RX_UNICAST_G);
-        mmc->mmc_rx_length_error += readl(ioaddr + MMC_RX_LENGTH_ERROR);
-        mmc->mmc_rx_autofrangetype += readl(ioaddr + MMC_RX_AUTOFRANGETYPE);
-        mmc->mmc_rx_pause_frames += readl(ioaddr + MMC_RX_PAUSE_FRAMES);
-        mmc->mmc_rx_fifo_overflow += readl(ioaddr + MMC_RX_FIFO_OVERFLOW);
-        mmc->mmc_rx_vlan_frames_gb += readl(ioaddr + MMC_RX_VLAN_FRAMES_GB);
-        mmc->mmc_rx_watchdog_error += readl(ioaddr + MMC_RX_WATCHDOG_ERROR);
+            readl(mmcaddr + MMC_RX_1024_TO_MAX_OCTETS_GB);
+        mmc->mmc_rx_unicast_g += readl(mmcaddr + MMC_RX_UNICAST_G);
+        mmc->mmc_rx_length_error += readl(mmcaddr + MMC_RX_LENGTH_ERROR);
+        mmc->mmc_rx_autofrangetype += readl(mmcaddr + MMC_RX_AUTOFRANGETYPE);
+        mmc->mmc_rx_pause_frames += readl(mmcaddr + MMC_RX_PAUSE_FRAMES);
+        mmc->mmc_rx_fifo_overflow += readl(mmcaddr + MMC_RX_FIFO_OVERFLOW);
+        mmc->mmc_rx_vlan_frames_gb += readl(mmcaddr + MMC_RX_VLAN_FRAMES_GB);
+        mmc->mmc_rx_watchdog_error += readl(mmcaddr + MMC_RX_WATCHDOG_ERROR);
         /* IPC */
-        mmc->mmc_rx_ipc_intr_mask += readl(ioaddr + MMC_RX_IPC_INTR_MASK);
-        mmc->mmc_rx_ipc_intr += readl(ioaddr + MMC_RX_IPC_INTR);
+        mmc->mmc_rx_ipc_intr_mask += readl(mmcaddr + MMC_RX_IPC_INTR_MASK);
+        mmc->mmc_rx_ipc_intr += readl(mmcaddr + MMC_RX_IPC_INTR);
         /* IPv4 */
-        mmc->mmc_rx_ipv4_gd += readl(ioaddr + MMC_RX_IPV4_GD);
-        mmc->mmc_rx_ipv4_hderr += readl(ioaddr + MMC_RX_IPV4_HDERR);
-        mmc->mmc_rx_ipv4_nopay += readl(ioaddr + MMC_RX_IPV4_NOPAY);
-        mmc->mmc_rx_ipv4_frag += readl(ioaddr + MMC_RX_IPV4_FRAG);
-        mmc->mmc_rx_ipv4_udsbl += readl(ioaddr + MMC_RX_IPV4_UDSBL);
+        mmc->mmc_rx_ipv4_gd += readl(mmcaddr + MMC_RX_IPV4_GD);
+        mmc->mmc_rx_ipv4_hderr += readl(mmcaddr + MMC_RX_IPV4_HDERR);
+        mmc->mmc_rx_ipv4_nopay += readl(mmcaddr + MMC_RX_IPV4_NOPAY);
+        mmc->mmc_rx_ipv4_frag += readl(mmcaddr + MMC_RX_IPV4_FRAG);
+        mmc->mmc_rx_ipv4_udsbl += readl(mmcaddr + MMC_RX_IPV4_UDSBL);
 
-        mmc->mmc_rx_ipv4_gd_octets += readl(ioaddr + MMC_RX_IPV4_GD_OCTETS);
+        mmc->mmc_rx_ipv4_gd_octets += readl(mmcaddr + MMC_RX_IPV4_GD_OCTETS);
         mmc->mmc_rx_ipv4_hderr_octets +=
-            readl(ioaddr + MMC_RX_IPV4_HDERR_OCTETS);
+            readl(mmcaddr + MMC_RX_IPV4_HDERR_OCTETS);
         mmc->mmc_rx_ipv4_nopay_octets +=
-            readl(ioaddr + MMC_RX_IPV4_NOPAY_OCTETS);
-        mmc->mmc_rx_ipv4_frag_octets += readl(ioaddr + MMC_RX_IPV4_FRAG_OCTETS);
+            readl(mmcaddr + MMC_RX_IPV4_NOPAY_OCTETS);
+        mmc->mmc_rx_ipv4_frag_octets += readl(mmcaddr +
+                                              MMC_RX_IPV4_FRAG_OCTETS);
         mmc->mmc_rx_ipv4_udsbl_octets +=
-            readl(ioaddr + MMC_RX_IPV4_UDSBL_OCTETS);
+            readl(mmcaddr + MMC_RX_IPV4_UDSBL_OCTETS);
 
         /* IPV6 */
-        mmc->mmc_rx_ipv6_gd_octets += readl(ioaddr + MMC_RX_IPV6_GD_OCTETS);
+        mmc->mmc_rx_ipv6_gd_octets += readl(mmcaddr + MMC_RX_IPV6_GD_OCTETS);
         mmc->mmc_rx_ipv6_hderr_octets +=
-            readl(ioaddr + MMC_RX_IPV6_HDERR_OCTETS);
+            readl(mmcaddr + MMC_RX_IPV6_HDERR_OCTETS);
         mmc->mmc_rx_ipv6_nopay_octets +=
-            readl(ioaddr + MMC_RX_IPV6_NOPAY_OCTETS);
+            readl(mmcaddr + MMC_RX_IPV6_NOPAY_OCTETS);
 
-        mmc->mmc_rx_ipv6_gd += readl(ioaddr + MMC_RX_IPV6_GD);
-        mmc->mmc_rx_ipv6_hderr += readl(ioaddr + MMC_RX_IPV6_HDERR);
-        mmc->mmc_rx_ipv6_nopay += readl(ioaddr + MMC_RX_IPV6_NOPAY);
+        mmc->mmc_rx_ipv6_gd += readl(mmcaddr + MMC_RX_IPV6_GD);
+        mmc->mmc_rx_ipv6_hderr += readl(mmcaddr + MMC_RX_IPV6_HDERR);
+        mmc->mmc_rx_ipv6_nopay += readl(mmcaddr + MMC_RX_IPV6_NOPAY);
 
         /* Protocols */
-        mmc->mmc_rx_udp_gd += readl(ioaddr + MMC_RX_UDP_GD);
-        mmc->mmc_rx_udp_err += readl(ioaddr + MMC_RX_UDP_ERR);
-        mmc->mmc_rx_tcp_gd += readl(ioaddr + MMC_RX_TCP_GD);
-        mmc->mmc_rx_tcp_err += readl(ioaddr + MMC_RX_TCP_ERR);
-        mmc->mmc_rx_icmp_gd += readl(ioaddr + MMC_RX_ICMP_GD);
-        mmc->mmc_rx_icmp_err += readl(ioaddr + MMC_RX_ICMP_ERR);
+        mmc->mmc_rx_udp_gd += readl(mmcaddr + MMC_RX_UDP_GD);
+        mmc->mmc_rx_udp_err += readl(mmcaddr + MMC_RX_UDP_ERR);
+        mmc->mmc_rx_tcp_gd += readl(mmcaddr + MMC_RX_TCP_GD);
+        mmc->mmc_rx_tcp_err += readl(mmcaddr + MMC_RX_TCP_ERR);
+        mmc->mmc_rx_icmp_gd += readl(mmcaddr + MMC_RX_ICMP_GD);
+        mmc->mmc_rx_icmp_err += readl(mmcaddr + MMC_RX_ICMP_ERR);
 
-        mmc->mmc_rx_udp_gd_octets += readl(ioaddr + MMC_RX_UDP_GD_OCTETS);
-        mmc->mmc_rx_udp_err_octets += readl(ioaddr + MMC_RX_UDP_ERR_OCTETS);
-        mmc->mmc_rx_tcp_gd_octets += readl(ioaddr + MMC_RX_TCP_GD_OCTETS);
-        mmc->mmc_rx_tcp_err_octets += readl(ioaddr + MMC_RX_TCP_ERR_OCTETS);
-        mmc->mmc_rx_icmp_gd_octets += readl(ioaddr + MMC_RX_ICMP_GD_OCTETS);
-        mmc->mmc_rx_icmp_err_octets += readl(ioaddr + MMC_RX_ICMP_ERR_OCTETS);
+        mmc->mmc_rx_udp_gd_octets += readl(mmcaddr + MMC_RX_UDP_GD_OCTETS);
+        mmc->mmc_rx_udp_err_octets += readl(mmcaddr + MMC_RX_UDP_ERR_OCTETS);
+        mmc->mmc_rx_tcp_gd_octets += readl(mmcaddr + MMC_RX_TCP_GD_OCTETS);
+        mmc->mmc_rx_tcp_err_octets += readl(mmcaddr + MMC_RX_TCP_ERR_OCTETS);
+        mmc->mmc_rx_icmp_gd_octets += readl(mmcaddr + MMC_RX_ICMP_GD_OCTETS);
+        mmc->mmc_rx_icmp_err_octets += readl(mmcaddr + MMC_RX_ICMP_ERR_OCTETS);
 }
diff --git a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
index e13228f115f0..2beacd0d3043 100644
--- a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
+++ b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
@@ -199,11 +199,6 @@ static void ndesc_prepare_tx_desc(struct dma_desc *p, int is_fs, int len,
 {
         unsigned int tdes1 = p->des1;
 
-        if (mode == STMMAC_CHAIN_MODE)
-                norm_set_tx_desc_len_on_chain(p, len);
-        else
-                norm_set_tx_desc_len_on_ring(p, len);
-
         if (is_fs)
                 tdes1 |= TDES1_FIRST_SEGMENT;
         else
@@ -217,10 +212,15 @@ static void ndesc_prepare_tx_desc(struct dma_desc *p, int is_fs, int len,
         if (ls)
                 tdes1 |= TDES1_LAST_SEGMENT;
 
-        if (tx_own)
-                tdes1 |= TDES0_OWN;
-
         p->des1 = tdes1;
+
+        if (mode == STMMAC_CHAIN_MODE)
+                norm_set_tx_desc_len_on_chain(p, len);
+        else
+                norm_set_tx_desc_len_on_ring(p, len);
+
+        if (tx_own)
+                p->des0 |= TDES0_OWN;
 }
 
 static void ndesc_set_tx_ic(struct dma_desc *p)
@@ -279,6 +279,26 @@ static int ndesc_get_rx_timestamp_status(void *desc, u32 ats)
                 return 1;
 }
 
+static void ndesc_display_ring(void *head, unsigned int size, bool rx)
+{
+        struct dma_desc *p = (struct dma_desc *)head;
+        int i;
+
+        pr_info("%s descriptor ring:\n", rx ? "RX" : "TX");
+
+        for (i = 0; i < size; i++) {
+                u64 x;
+
+                x = *(u64 *)p;
+                pr_info("%d [0x%x]: 0x%x 0x%x 0x%x 0x%x",
+                        i, (unsigned int)virt_to_phys(p),
+                        (unsigned int)x, (unsigned int)(x >> 32),
+                        p->des2, p->des3);
+                p++;
+        }
+        pr_info("\n");
+}
+
 const struct stmmac_desc_ops ndesc_ops = {
         .tx_status = ndesc_get_tx_status,
         .rx_status = ndesc_get_rx_status,
@@ -297,4 +317,5 @@ const struct stmmac_desc_ops ndesc_ops = {
         .get_tx_timestamp_status = ndesc_get_tx_timestamp_status,
         .get_timestamp = ndesc_get_timestamp,
         .get_rx_timestamp_status = ndesc_get_rx_timestamp_status,
+        .display_ring = ndesc_display_ring,
 };
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac.h b/drivers/net/ethernet/stmicro/stmmac/stmmac.h
index 8bbab97895fe..ff6750621ff7 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac.h
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac.h
@@ -24,7 +24,7 @@
 #define __STMMAC_H__
 
 #define STMMAC_RESOURCE_NAME   "stmmaceth"
-#define DRV_MODULE_VERSION      "Oct_2015"
+#define DRV_MODULE_VERSION      "Jan_2016"
 
 #include <linux/clk.h>
 #include <linux/stmmac.h>
@@ -67,6 +67,7 @@ struct stmmac_priv {
         spinlock_t tx_lock;
         bool tx_path_in_lpi_mode;
         struct timer_list txtimer;
+        bool tso;
 
         struct dma_desc *dma_rx ____cacheline_aligned_in_smp;
         struct dma_extended_desc *dma_erx;
@@ -128,6 +129,10 @@ struct stmmac_priv {
         int use_riwt;
         int irq_wake;
         spinlock_t ptp_lock;
+        void __iomem *mmcaddr;
+        u32 rx_tail_addr;
+        u32 tx_tail_addr;
+        u32 mss;
 
 #ifdef CONFIG_DEBUG_FS
         struct dentry *dbgfs_dir;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c
index 3c7928edfebb..e2b98b01647e 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c
@@ -161,6 +161,9 @@ static const struct stmmac_stats stmmac_gstrings_stats[] = {
         STMMAC_STAT(mtl_rx_fifo_ctrl_active),
         STMMAC_STAT(mac_rx_frame_ctrl_fifo),
         STMMAC_STAT(mac_gmii_rx_proto_engine),
+        /* TSO */
+        STMMAC_STAT(tx_tso_frames),
+        STMMAC_STAT(tx_tso_nfrags),
 };
 #define STMMAC_STATS_LEN ARRAY_SIZE(stmmac_gstrings_stats)
 
@@ -499,14 +502,14 @@ static void stmmac_get_ethtool_stats(struct net_device *dev,
         int i, j = 0;
 
         /* Update the DMA HW counters for dwmac10/100 */
-        if (!priv->plat->has_gmac)
+        if (priv->hw->dma->dma_diagnostic_fr)
                 priv->hw->dma->dma_diagnostic_fr(&dev->stats,
                                                  (void *) &priv->xstats,
                                                  priv->ioaddr);
         else {
                 /* If supported, for new GMAC chips expose the MMC counters */
                 if (priv->dma_cap.rmon) {
-                        dwmac_mmc_read(priv->ioaddr, &priv->mmc);
+                        dwmac_mmc_read(priv->mmcaddr, &priv->mmc);
 
                         for (i = 0; i < STMMAC_MMC_STATS_LEN; i++) {
                                 char *p;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 4c5ce9848ca9..b87edb72e80a 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -56,6 +56,7 @@
 #include "dwmac1000.h"
 
 #define STMMAC_ALIGN(x) L1_CACHE_ALIGN(x)
+#define TSO_MAX_BUFF_SIZE       (SZ_16K - 1)
 
 /* Module parameters */
 #define TX_TIMEO        5000
@@ -278,7 +279,6 @@ static void stmmac_eee_ctrl_timer(unsigned long arg)
  */
 bool stmmac_eee_init(struct stmmac_priv *priv)
 {
-        char *phy_bus_name = priv->plat->phy_bus_name;
         unsigned long flags;
         bool ret = false;
 
@@ -289,10 +289,6 @@ bool stmmac_eee_init(struct stmmac_priv *priv)
             (priv->pcs == STMMAC_PCS_RTBI))
                 goto out;
 
-        /* Never init EEE in case of a switch is attached */
-        if (phy_bus_name && (!strcmp(phy_bus_name, "fixed")))
-                goto out;
-
         /* MAC core supports the EEE feature. */
         if (priv->dma_cap.eee) {
                 int tx_lpi_timer = priv->tx_lpi_timer;
@@ -726,13 +722,15 @@ static void stmmac_adjust_link(struct net_device *dev)
                         new_state = 1;
                         switch (phydev->speed) {
                         case 1000:
-                                if (likely(priv->plat->has_gmac))
+                                if (likely((priv->plat->has_gmac) ||
+                                           (priv->plat->has_gmac4)))
                                         ctrl &= ~priv->hw->link.port;
                                 stmmac_hw_fix_mac_speed(priv);
                                 break;
                         case 100:
                         case 10:
-                                if (priv->plat->has_gmac) {
+                                if (likely((priv->plat->has_gmac) ||
+                                           (priv->plat->has_gmac4))) {
                                         ctrl |= priv->hw->link.port;
                                         if (phydev->speed == SPEED_100) {
                                                 ctrl |= priv->hw->link.speed;
@@ -772,10 +770,16 @@ static void stmmac_adjust_link(struct net_device *dev)
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* At this stage, it could be needed to setup the EEE or adjust some
-         * MAC related HW registers.
-         */
-        priv->eee_enabled = stmmac_eee_init(priv);
+        if (phydev->is_pseudo_fixed_link)
+                /* Stop PHY layer to call the hook to adjust the link in case
+                 * of a switch is attached to the stmmac driver.
+                 */
+                phydev->irq = PHY_IGNORE_INTERRUPT;
+        else
+                /* At this stage, init the EEE if supported.
+                 * Never called in case of fixed_link.
+                 */
+                priv->eee_enabled = stmmac_eee_init(priv);
 }
 
 /**
@@ -827,12 +831,8 @@ static int stmmac_init_phy(struct net_device *dev)
                 phydev = of_phy_connect(dev, priv->plat->phy_node,
                                         &stmmac_adjust_link, 0, interface);
         } else {
-                if (priv->plat->phy_bus_name)
-                        snprintf(bus_id, MII_BUS_ID_SIZE, "%s-%x",
-                                 priv->plat->phy_bus_name, priv->plat->bus_id);
-                else
-                        snprintf(bus_id, MII_BUS_ID_SIZE, "stmmac-%x",
-                                 priv->plat->bus_id);
+                snprintf(bus_id, MII_BUS_ID_SIZE, "stmmac-%x",
+                         priv->plat->bus_id);
 
                 snprintf(phy_id_fmt, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id,
                          priv->plat->phy_addr);
@@ -870,11 +870,6 @@ static int stmmac_init_phy(struct net_device *dev)
                 return -ENODEV;
         }
 
-        /* If attached to a switch, there is no reason to poll phy handler */
-        if (priv->plat->phy_bus_name)
-                if (!strcmp(priv->plat->phy_bus_name, "fixed"))
-                        phydev->irq = PHY_IGNORE_INTERRUPT;
-
         pr_debug("stmmac_init_phy:  %s: attached to PHY (UID 0x%x)"
                  " Link = %d\n", dev->name, phydev->phy_id, phydev->link);
 
@@ -883,53 +878,22 @@ static int stmmac_init_phy(struct net_device *dev)
         return 0;
 }
 
-/**
- * stmmac_display_ring - display ring
- * @head: pointer to the head of the ring passed.
- * @size: size of the ring.
- * @extend_desc: to verify if extended descriptors are used.
- * Description: display the control/status and buffer descriptors.
- */
-static void stmmac_display_ring(void *head, int size, int extend_desc)
-{
-        int i;
-        struct dma_extended_desc *ep = (struct dma_extended_desc *)head;
-        struct dma_desc *p = (struct dma_desc *)head;
-
-        for (i = 0; i < size; i++) {
-                u64 x;
-                if (extend_desc) {
-                        x = *(u64 *) ep;
-                        pr_info("%d [0x%x]: 0x%x 0x%x 0x%x 0x%x\n",
-                                i, (unsigned int)virt_to_phys(ep),
-                                (unsigned int)x, (unsigned int)(x >> 32),
-                                ep->basic.des2, ep->basic.des3);
-                        ep++;
-                } else {
-                        x = *(u64 *) p;
-                        pr_info("%d [0x%x]: 0x%x 0x%x 0x%x 0x%x",
-                                i, (unsigned int)virt_to_phys(p),
-                                (unsigned int)x, (unsigned int)(x >> 32),
-                                p->des2, p->des3);
-                        p++;
-                }
-                pr_info("\n");
-        }
-}
-
 static void stmmac_display_rings(struct stmmac_priv *priv)
 {
+        void *head_rx, *head_tx;
+
         if (priv->extend_desc) {
-                pr_info("Extended RX descriptor ring:\n");
-                stmmac_display_ring((void *)priv->dma_erx, DMA_RX_SIZE, 1);
-                pr_info("Extended TX descriptor ring:\n");
-                stmmac_display_ring((void *)priv->dma_etx, DMA_TX_SIZE, 1);
+                head_rx = (void *)priv->dma_erx;
+                head_tx = (void *)priv->dma_etx;
         } else {
-                pr_info("RX descriptor ring:\n");
-                stmmac_display_ring((void *)priv->dma_rx, DMA_RX_SIZE, 0);
-                pr_info("TX descriptor ring:\n");
-                stmmac_display_ring((void *)priv->dma_tx, DMA_TX_SIZE, 0);
+                head_rx = (void *)priv->dma_rx;
+                head_tx = (void *)priv->dma_tx;
         }
+
+        /* Display Rx ring */
+        priv->hw->desc->display_ring(head_rx, DMA_RX_SIZE, true);
+        /* Display Tx ring */
+        priv->hw->desc->display_ring(head_tx, DMA_TX_SIZE, false);
 }
 
 static int stmmac_set_bfsize(int mtu, int bufsize)
@@ -1008,7 +972,10 @@ static int stmmac_init_rx_buffers(struct stmmac_priv *priv, struct dma_desc *p,
                 return -EINVAL;
         }
 
-        p->des2 = priv->rx_skbuff_dma[i];
+        if (priv->synopsys_id >= DWMAC_CORE_4_00)
+                p->des0 = priv->rx_skbuff_dma[i];
+        else
+                p->des2 = priv->rx_skbuff_dma[i];
 
         if ((priv->hw->mode->init_desc3) &&
             (priv->dma_buf_sz == BUF_SIZE_16KiB))
@@ -1099,7 +1066,16 @@ static int init_dma_desc_rings(struct net_device *dev, gfp_t flags)
                         p = &((priv->dma_etx + i)->basic);
                 else
                         p = priv->dma_tx + i;
-                p->des2 = 0;
+
+                if (priv->synopsys_id >= DWMAC_CORE_4_00) {
+                        p->des0 = 0;
+                        p->des1 = 0;
+                        p->des2 = 0;
+                        p->des3 = 0;
+                } else {
+                        p->des2 = 0;
+                }
+
                 priv->tx_skbuff_dma[i].buf = 0;
                 priv->tx_skbuff_dma[i].map_as_page = false;
                 priv->tx_skbuff_dma[i].len = 0;
@@ -1362,9 +1338,13 @@ static void stmmac_tx_clean(struct stmmac_priv *priv)
                                                  priv->tx_skbuff_dma[entry].len,
                                                  DMA_TO_DEVICE);
                         priv->tx_skbuff_dma[entry].buf = 0;
+                        priv->tx_skbuff_dma[entry].len = 0;
                         priv->tx_skbuff_dma[entry].map_as_page = false;
                 }
-                priv->hw->mode->clean_desc3(priv, p);
+
+                if (priv->hw->mode->clean_desc3)
+                        priv->hw->mode->clean_desc3(priv, p);
+
                 priv->tx_skbuff_dma[entry].last_segment = false;
                 priv->tx_skbuff_dma[entry].is_jumbo = false;
 
@@ -1487,41 +1467,23 @@ static void stmmac_dma_interrupt(struct stmmac_priv *priv)
 static void stmmac_mmc_setup(struct stmmac_priv *priv)
 {
         unsigned int mode = MMC_CNTRL_RESET_ON_READ | MMC_CNTRL_COUNTER_RESET |
-            MMC_CNTRL_PRESET | MMC_CNTRL_FULL_HALF_PRESET;
+                            MMC_CNTRL_PRESET | MMC_CNTRL_FULL_HALF_PRESET;
 
-        dwmac_mmc_intr_all_mask(priv->ioaddr);
+        if (priv->synopsys_id >= DWMAC_CORE_4_00)
+                priv->mmcaddr = priv->ioaddr + MMC_GMAC4_OFFSET;
+        else
+                priv->mmcaddr = priv->ioaddr + MMC_GMAC3_X_OFFSET;
+
+        dwmac_mmc_intr_all_mask(priv->mmcaddr);
 
         if (priv->dma_cap.rmon) {
-                dwmac_mmc_ctrl(priv->ioaddr, mode);
+                dwmac_mmc_ctrl(priv->mmcaddr, mode);
                 memset(&priv->mmc, 0, sizeof(struct stmmac_counters));
         } else
                 pr_info(" No MAC Management Counters available\n");
 }
 
 /**
- * stmmac_get_synopsys_id - return the SYINID.
- * @priv: driver private structure
- * Description: this simple function is to decode and return the SYINID
- * starting from the HW core register.
- */
-static u32 stmmac_get_synopsys_id(struct stmmac_priv *priv)
-{
-        u32 hwid = priv->hw->synopsys_uid;
-
-        /* Check Synopsys Id (not available on old chips) */
-        if (likely(hwid)) {
-                u32 uid = ((hwid & 0x0000ff00) >> 8);
-                u32 synid = (hwid & 0x000000ff);
-
-                pr_info("stmmac - user ID: 0x%x, Synopsys ID: 0x%x\n",
-                        uid, synid);
-
-                return synid;
-        }
-        return 0;
-}
-
-/**
  * stmmac_selec_desc_mode - to select among: normal/alternate/extend descriptors
  * @priv: driver private structure
  * Description: select the Enhanced/Alternate or Normal descriptors.
@@ -1558,51 +1520,15 @@ static void stmmac_selec_desc_mode(struct stmmac_priv *priv)
  */
 static int stmmac_get_hw_features(struct stmmac_priv *priv)
 {
-        u32 hw_cap = 0;
+        u32 ret = 0;
 
         if (priv->hw->dma->get_hw_feature) {
-                hw_cap = priv->hw->dma->get_hw_feature(priv->ioaddr);
-
-                priv->dma_cap.mbps_10_100 = (hw_cap & DMA_HW_FEAT_MIISEL);
-                priv->dma_cap.mbps_1000 = (hw_cap & DMA_HW_FEAT_GMIISEL) >> 1;
-                priv->dma_cap.half_duplex = (hw_cap & DMA_HW_FEAT_HDSEL) >> 2;
-                priv->dma_cap.hash_filter = (hw_cap & DMA_HW_FEAT_HASHSEL) >> 4;
-                priv->dma_cap.multi_addr = (hw_cap & DMA_HW_FEAT_ADDMAC) >> 5;
-                priv->dma_cap.pcs = (hw_cap & DMA_HW_FEAT_PCSSEL) >> 6;
-                priv->dma_cap.sma_mdio = (hw_cap & DMA_HW_FEAT_SMASEL) >> 8;
-                priv->dma_cap.pmt_remote_wake_up =
-                    (hw_cap & DMA_HW_FEAT_RWKSEL) >> 9;
-                priv->dma_cap.pmt_magic_frame =
-                    (hw_cap & DMA_HW_FEAT_MGKSEL) >> 10;
-                /* MMC */
-                priv->dma_cap.rmon = (hw_cap & DMA_HW_FEAT_MMCSEL) >> 11;
-                /* IEEE 1588-2002 */
-                priv->dma_cap.time_stamp =
-                    (hw_cap & DMA_HW_FEAT_TSVER1SEL) >> 12;
-                /* IEEE 1588-2008 */
-                priv->dma_cap.atime_stamp =
-                    (hw_cap & DMA_HW_FEAT_TSVER2SEL) >> 13;
-                /* 802.3az - Energy-Efficient Ethernet (EEE) */
-                priv->dma_cap.eee = (hw_cap & DMA_HW_FEAT_EEESEL) >> 14;
-                priv->dma_cap.av = (hw_cap & DMA_HW_FEAT_AVSEL) >> 15;
-                /* TX and RX csum */
-                priv->dma_cap.tx_coe = (hw_cap & DMA_HW_FEAT_TXCOESEL) >> 16;
-                priv->dma_cap.rx_coe_type1 =
-                    (hw_cap & DMA_HW_FEAT_RXTYP1COE) >> 17;
-                priv->dma_cap.rx_coe_type2 =
-                    (hw_cap & DMA_HW_FEAT_RXTYP2COE) >> 18;
-                priv->dma_cap.rxfifo_over_2048 =
-                    (hw_cap & DMA_HW_FEAT_RXFIFOSIZE) >> 19;
-                /* TX and RX number of channels */
-                priv->dma_cap.number_rx_channel =
-                    (hw_cap & DMA_HW_FEAT_RXCHCNT) >> 20;
-                priv->dma_cap.number_tx_channel =
-                    (hw_cap & DMA_HW_FEAT_TXCHCNT) >> 22;
-                /* Alternate (enhanced) DESC mode */
-                priv->dma_cap.enh_desc = (hw_cap & DMA_HW_FEAT_ENHDESSEL) >> 24;
-        }
-
-        return hw_cap;
+                priv->hw->dma->get_hw_feature(priv->ioaddr,
+                                              &priv->dma_cap);
+                ret = 1;
+        }
+
+        return ret;
 }
 
 /**
@@ -1658,8 +1584,19 @@ static int stmmac_init_dma_engine(struct stmmac_priv *priv)
         priv->hw->dma->init(priv->ioaddr, pbl, fixed_burst, mixed_burst,
                             aal, priv->dma_tx_phy, priv->dma_rx_phy, atds);
 
-        if ((priv->synopsys_id >= DWMAC_CORE_3_50) &&
-            (priv->plat->axi && priv->hw->dma->axi))
+        if (priv->synopsys_id >= DWMAC_CORE_4_00) {
+                priv->rx_tail_addr = priv->dma_rx_phy +
+                            (DMA_RX_SIZE * sizeof(struct dma_desc));
+                priv->hw->dma->set_rx_tail_ptr(priv->ioaddr, priv->rx_tail_addr,
+                                               STMMAC_CHAN0);
+
+                priv->tx_tail_addr = priv->dma_tx_phy +
+                            (DMA_TX_SIZE * sizeof(struct dma_desc));
+                priv->hw->dma->set_tx_tail_ptr(priv->ioaddr, priv->tx_tail_addr,
+                                               STMMAC_CHAN0);
+        }
+
+        if (priv->plat->axi && priv->hw->dma->axi)
                 priv->hw->dma->axi(priv->ioaddr, priv->plat->axi);
 
         return ret;
@@ -1739,7 +1676,10 @@ static int stmmac_hw_setup(struct net_device *dev, bool init_ptp)
         }
 
         /* Enable the MAC Rx/Tx */
-        stmmac_set_mac(priv->ioaddr, true);
+        if (priv->synopsys_id >= DWMAC_CORE_4_00)
+                stmmac_dwmac4_set_mac(priv->ioaddr, true);
+        else
+                stmmac_set_mac(priv->ioaddr, true);
 
         /* Set the HW DMA mode and the COE */
         stmmac_dma_operation_mode(priv);
@@ -1777,6 +1717,18 @@ static int stmmac_hw_setup(struct net_device *dev, bool init_ptp)
         if (priv->pcs && priv->hw->mac->ctrl_ane)
                 priv->hw->mac->ctrl_ane(priv->hw, 0);
 
+        /*  set TX ring length */
+        if (priv->hw->dma->set_tx_ring_len)
+                priv->hw->dma->set_tx_ring_len(priv->ioaddr,
+                                               (DMA_TX_SIZE - 1));
+        /*  set RX ring length */
+        if (priv->hw->dma->set_rx_ring_len)
+                priv->hw->dma->set_rx_ring_len(priv->ioaddr,
+                                               (DMA_RX_SIZE - 1));
+        /* Enable TSO */
+        if (priv->tso)
+                priv->hw->dma->enable_tso(priv->ioaddr, 1, STMMAC_CHAN0);
+
         return 0;
 }
 
@@ -1942,6 +1894,239 @@ static int stmmac_release(struct net_device *dev)
 }
 
 /**
+ *  stmmac_tso_allocator - close entry point of the driver
+ *  @priv: driver private structure
+ *  @des: buffer start address
+ *  @total_len: total length to fill in descriptors
+ *  @last_segmant: condition for the last descriptor
+ *  Description:
+ *  This function fills descriptor and request new descriptors according to
+ *  buffer length to fill
+ */
+static void stmmac_tso_allocator(struct stmmac_priv *priv, unsigned int des,
+                                 int total_len, bool last_segment)
+{
+        struct dma_desc *desc;
+        int tmp_len;
+        u32 buff_size;
+
+        tmp_len = total_len;
+
+        while (tmp_len > 0) {
+                priv->cur_tx = STMMAC_GET_ENTRY(priv->cur_tx, DMA_TX_SIZE);
+                desc = priv->dma_tx + priv->cur_tx;
+
+                desc->des0 = des + (total_len - tmp_len);
+                buff_size = tmp_len >= TSO_MAX_BUFF_SIZE ?
+                            TSO_MAX_BUFF_SIZE : tmp_len;
+
+                priv->hw->desc->prepare_tso_tx_desc(desc, 0, buff_size,
+                        0, 1,
+                        (last_segment) && (buff_size < TSO_MAX_BUFF_SIZE),
+                        0, 0);
+
+                tmp_len -= TSO_MAX_BUFF_SIZE;
+        }
+}
+
+/**
+ *  stmmac_tso_xmit - Tx entry point of the driver for oversized frames (TSO)
+ *  @skb : the socket buffer
+ *  @dev : device pointer
+ *  Description: this is the transmit function that is called on TSO frames
+ *  (support available on GMAC4 and newer chips).
+ *  Diagram below show the ring programming in case of TSO frames:
+ *
+ *  First Descriptor
+ *   --------
+ *   | DES0 |---> buffer1 = L2/L3/L4 header
+ *   | DES1 |---> TCP Payload (can continue on next descr...)
+ *   | DES2 |---> buffer 1 and 2 len
+ *   | DES3 |---> must set TSE, TCP hdr len-> [22:19]. TCP payload len [17:0]
+ *   --------
+ *      |
+ *     ...
+ *      |
+ *   --------
+ *   | DES0 | --| Split TCP Payload on Buffers 1 and 2
+ *   | DES1 | --|
+ *   | DES2 | --> buffer 1 and 2 len
+ *   | DES3 |
+ *   --------
+ *
+ * mss is fixed when enable tso, so w/o programming the TDES3 ctx field.
+ */
+static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        u32 pay_len, mss;
+        int tmp_pay_len = 0;
+        struct stmmac_priv *priv = netdev_priv(dev);
+        int nfrags = skb_shinfo(skb)->nr_frags;
+        unsigned int first_entry, des;
+        struct dma_desc *desc, *first, *mss_desc = NULL;
+        u8 proto_hdr_len;
+        int i;
+
+        spin_lock(&priv->tx_lock);
+
+        /* Compute header lengths */
+        proto_hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
+
+        /* Desc availability based on threshold should be enough safe */
+        if (unlikely(stmmac_tx_avail(priv) <
+                (((skb->len - proto_hdr_len) / TSO_MAX_BUFF_SIZE + 1)))) {
+                if (!netif_queue_stopped(dev)) {
+                        netif_stop_queue(dev);
+                        /* This is a hard error, log it. */
+                        pr_err("%s: Tx Ring full when queue awake\n", __func__);
+                }
+                spin_unlock(&priv->tx_lock);
+                return NETDEV_TX_BUSY;
+        }
+
+        pay_len = skb_headlen(skb) - proto_hdr_len; /* no frags */
+
+        mss = skb_shinfo(skb)->gso_size;
+
+        /* set new MSS value if needed */
+        if (mss != priv->mss) {
+                mss_desc = priv->dma_tx + priv->cur_tx;
+                priv->hw->desc->set_mss(mss_desc, mss);
+                priv->mss = mss;
+                priv->cur_tx = STMMAC_GET_ENTRY(priv->cur_tx, DMA_TX_SIZE);
+        }
+
+        if (netif_msg_tx_queued(priv)) {
+                pr_info("%s: tcphdrlen %d, hdr_len %d, pay_len %d, mss %d\n",
+                        __func__, tcp_hdrlen(skb), proto_hdr_len, pay_len, mss);
+                pr_info("\tskb->len %d, skb->data_len %d\n", skb->len,
+                        skb->data_len);
+        }
+
+        first_entry = priv->cur_tx;
+
+        desc = priv->dma_tx + first_entry;
+        first = desc;
+
+        /* first descriptor: fill Headers on Buf1 */
+        des = dma_map_single(priv->device, skb->data, skb_headlen(skb),
+                             DMA_TO_DEVICE);
+        if (dma_mapping_error(priv->device, des))
+                goto dma_map_err;
+
+        priv->tx_skbuff_dma[first_entry].buf = des;
+        priv->tx_skbuff_dma[first_entry].len = skb_headlen(skb);
+        priv->tx_skbuff[first_entry] = skb;
+
+        first->des0 = des;
+
+        /* Fill start of payload in buff2 of first descriptor */
+        if (pay_len)
+                first->des1 =  des + proto_hdr_len;
+
+        /* If needed take extra descriptors to fill the remaining payload */
+        tmp_pay_len = pay_len - TSO_MAX_BUFF_SIZE;
+
+        stmmac_tso_allocator(priv, des, tmp_pay_len, (nfrags == 0));
+
+        /* Prepare fragments */
+        for (i = 0; i < nfrags; i++) {
+                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+
+                des = skb_frag_dma_map(priv->device, frag, 0,
+                                       skb_frag_size(frag),
+                                       DMA_TO_DEVICE);
+
+                stmmac_tso_allocator(priv, des, skb_frag_size(frag),
+                                     (i == nfrags - 1));
+
+                priv->tx_skbuff_dma[priv->cur_tx].buf = des;
+                priv->tx_skbuff_dma[priv->cur_tx].len = skb_frag_size(frag);
+                priv->tx_skbuff[priv->cur_tx] = NULL;
+                priv->tx_skbuff_dma[priv->cur_tx].map_as_page = true;
+        }
+
+        priv->tx_skbuff_dma[priv->cur_tx].last_segment = true;
+
+        priv->cur_tx = STMMAC_GET_ENTRY(priv->cur_tx, DMA_TX_SIZE);
+
+        if (unlikely(stmmac_tx_avail(priv) <= (MAX_SKB_FRAGS + 1))) {
+                if (netif_msg_hw(priv))
+                        pr_debug("%s: stop transmitted packets\n", __func__);
+                netif_stop_queue(dev);
+        }
+
+        dev->stats.tx_bytes += skb->len;
+        priv->xstats.tx_tso_frames++;
+        priv->xstats.tx_tso_nfrags += nfrags;
+
+        /* Manage tx mitigation */
+        priv->tx_count_frames += nfrags + 1;
+        if (likely(priv->tx_coal_frames > priv->tx_count_frames)) {
+                mod_timer(&priv->txtimer,
+                          STMMAC_COAL_TIMER(priv->tx_coal_timer));
+        } else {
+                priv->tx_count_frames = 0;
+                priv->hw->desc->set_tx_ic(desc);
+                priv->xstats.tx_set_ic_bit++;
+        }
+
+        if (!priv->hwts_tx_en)
+                skb_tx_timestamp(skb);
+
+        if (unlikely((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+                     priv->hwts_tx_en)) {
+                /* declare that device is doing timestamping */
+                skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+                priv->hw->desc->enable_tx_timestamp(first);
+        }
+
+        /* Complete the first descriptor before granting the DMA */
+        priv->hw->desc->prepare_tso_tx_desc(first, 1,
+                        proto_hdr_len,
+                        pay_len,
+                        1, priv->tx_skbuff_dma[first_entry].last_segment,
+                        tcp_hdrlen(skb) / 4, (skb->len - proto_hdr_len));
+
+        /* If context desc is used to change MSS */
+        if (mss_desc)
+                priv->hw->desc->set_tx_owner(mss_desc);
+
+        /* The own bit must be the latest setting done when prepare the
+         * descriptor and then barrier is needed to make sure that
+         * all is coherent before granting the DMA engine.
+         */
+        smp_wmb();
+
+        if (netif_msg_pktdata(priv)) {
+                pr_info("%s: curr=%d dirty=%d f=%d, e=%d, f_p=%p, nfrags %d\n",
+                        __func__, priv->cur_tx, priv->dirty_tx, first_entry,
+                        priv->cur_tx, first, nfrags);
+
+                priv->hw->desc->display_ring((void *)priv->dma_tx, DMA_TX_SIZE,
+                                             0);
+
+                pr_info(">>> frame to be transmitted: ");
+                print_pkt(skb->data, skb_headlen(skb));
+        }
+
+        netdev_sent_queue(dev, skb->len);
+
+        priv->hw->dma->set_tx_tail_ptr(priv->ioaddr, priv->tx_tail_addr,
+                                       STMMAC_CHAN0);
+
+        spin_unlock(&priv->tx_lock);
+        return NETDEV_TX_OK;
+
+dma_map_err:
+        spin_unlock(&priv->tx_lock);
+        dev_err(priv->device, "Tx dma map failed\n");
+        dev_kfree_skb(skb);
+        priv->dev->stats.tx_dropped++;
+        return NETDEV_TX_OK;
+}
+
+/**
  *  stmmac_xmit - Tx entry point of the driver
  *  @skb : the socket buffer
  *  @dev : device pointer
@@ -1958,6 +2143,13 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         unsigned int entry, first_entry;
         struct dma_desc *desc, *first;
         unsigned int enh_desc;
+        unsigned int des;
+
+        /* Manage oversized TCP frames for GMAC4 device */
+        if (skb_is_gso(skb) && priv->tso) {
+                if (ip_hdr(skb)->protocol == IPPROTO_TCP)
+                        return stmmac_tso_xmit(skb, dev);
+        }
 
         spin_lock(&priv->tx_lock);
 
@@ -1993,7 +2185,8 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         if (enh_desc)
                 is_jumbo = priv->hw->mode->is_jumbo_frm(skb->len, enh_desc);
 
-        if (unlikely(is_jumbo)) {
+        if (unlikely(is_jumbo) && likely(priv->synopsys_id <
+                                         DWMAC_CORE_4_00)) {
                 entry = priv->hw->mode->jumbo_frm(priv, skb, csum_insertion);
                 if (unlikely(entry < 0))
                         goto dma_map_err;
@@ -2011,13 +2204,21 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
                 else
                         desc = priv->dma_tx + entry;
 
-                desc->des2 = skb_frag_dma_map(priv->device, frag, 0, len,
-                                              DMA_TO_DEVICE);
-                if (dma_mapping_error(priv->device, desc->des2))
+                des = skb_frag_dma_map(priv->device, frag, 0, len,
+                                       DMA_TO_DEVICE);
+                if (dma_mapping_error(priv->device, des))
                         goto dma_map_err; /* should reuse desc w/o issues */
 
                 priv->tx_skbuff[entry] = NULL;
-                priv->tx_skbuff_dma[entry].buf = desc->des2;
+
+                if (unlikely(priv->synopsys_id >= DWMAC_CORE_4_00)) {
+                        desc->des0 = des;
+                        priv->tx_skbuff_dma[entry].buf = desc->des0;
+                } else {
+                        desc->des2 = des;
+                        priv->tx_skbuff_dma[entry].buf = desc->des2;
+                }
+
                 priv->tx_skbuff_dma[entry].map_as_page = true;
                 priv->tx_skbuff_dma[entry].len = len;
                 priv->tx_skbuff_dma[entry].last_segment = last_segment;
@@ -2032,16 +2233,18 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         priv->cur_tx = entry;
 
         if (netif_msg_pktdata(priv)) {
+                void *tx_head;
+
                 pr_debug("%s: curr=%d dirty=%d f=%d, e=%d, first=%p, nfrags=%d",
                          __func__, priv->cur_tx, priv->dirty_tx, first_entry,
                          entry, first, nfrags);
 
                 if (priv->extend_desc)
-                        stmmac_display_ring((void *)priv->dma_etx,
-                                            DMA_TX_SIZE, 1);
+                        tx_head = (void *)priv->dma_etx;
                 else
-                        stmmac_display_ring((void *)priv->dma_tx,
-                                            DMA_TX_SIZE, 0);
+                        tx_head = (void *)priv->dma_tx;
+
+                priv->hw->desc->display_ring(tx_head, DMA_TX_SIZE, false);
 
                 pr_debug(">>> frame to be transmitted: ");
                 print_pkt(skb->data, skb->len);
@@ -2080,12 +2283,19 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         if (likely(!is_jumbo)) {
                 bool last_segment = (nfrags == 0);
 
-                first->des2 = dma_map_single(priv->device, skb->data,
-                                             nopaged_len, DMA_TO_DEVICE);
-                if (dma_mapping_error(priv->device, first->des2))
+                des = dma_map_single(priv->device, skb->data,
+                                     nopaged_len, DMA_TO_DEVICE);
+                if (dma_mapping_error(priv->device, des))
                         goto dma_map_err;
 
-                priv->tx_skbuff_dma[first_entry].buf = first->des2;
+                if (unlikely(priv->synopsys_id >= DWMAC_CORE_4_00)) {
+                        first->des0 = des;
+                        priv->tx_skbuff_dma[first_entry].buf = first->des0;
+                } else {
+                        first->des2 = des;
+                        priv->tx_skbuff_dma[first_entry].buf = first->des2;
+                }
+
                 priv->tx_skbuff_dma[first_entry].len = nopaged_len;
                 priv->tx_skbuff_dma[first_entry].last_segment = last_segment;
 
@@ -2109,7 +2319,12 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         netdev_sent_queue(dev, skb->len);
-        priv->hw->dma->enable_dma_transmission(priv->ioaddr);
+
+        if (priv->synopsys_id < DWMAC_CORE_4_00)
+                priv->hw->dma->enable_dma_transmission(priv->ioaddr);
+        else
+                priv->hw->dma->set_tx_tail_ptr(priv->ioaddr, priv->tx_tail_addr,
+                                               STMMAC_CHAN0);
 
         spin_unlock(&priv->tx_lock);
         return NETDEV_TX_OK;
@@ -2191,9 +2406,15 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv)
                                 dev_kfree_skb(skb);
                                 break;
                         }
-                        p->des2 = priv->rx_skbuff_dma[entry];
 
-                        priv->hw->mode->refill_desc3(priv, p);
+                        if (unlikely(priv->synopsys_id >= DWMAC_CORE_4_00)) {
+                                p->des0 = priv->rx_skbuff_dma[entry];
+                                p->des1 = 0;
+                        } else {
+                                p->des2 = priv->rx_skbuff_dma[entry];
+                        }
+                        if (priv->hw->mode->refill_desc3)
+                                priv->hw->mode->refill_desc3(priv, p);
 
                         if (priv->rx_zeroc_thresh > 0)
                                 priv->rx_zeroc_thresh--;
@@ -2201,9 +2422,13 @@ static inline void stmmac_rx_refill(struct stmmac_priv *priv)
                         if (netif_msg_rx_status(priv))
                                 pr_debug("\trefill entry #%d\n", entry);
                 }
-
                 wmb();
-                priv->hw->desc->set_rx_owner(p);
+
+                if (unlikely(priv->synopsys_id >= DWMAC_CORE_4_00))
+                        priv->hw->desc->init_rx_desc(p, priv->use_riwt, 0, 0);
+                else
+                        priv->hw->desc->set_rx_owner(p);
+
                 wmb();
 
                 entry = STMMAC_GET_ENTRY(entry, DMA_RX_SIZE);
@@ -2226,13 +2451,15 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit)
         int coe = priv->hw->rx_csum;
 
         if (netif_msg_rx_status(priv)) {
+                void *rx_head;
+
                 pr_debug("%s: descriptor ring:\n", __func__);
                 if (priv->extend_desc)
-                        stmmac_display_ring((void *)priv->dma_erx,
-                                            DMA_RX_SIZE, 1);
+                        rx_head = (void *)priv->dma_erx;
                 else
-                        stmmac_display_ring((void *)priv->dma_rx,
-                                            DMA_RX_SIZE, 0);
+                        rx_head = (void *)priv->dma_rx;
+
+                priv->hw->desc->display_ring(rx_head, DMA_RX_SIZE, true);
         }
         while (count < limit) {
                 int status;
@@ -2282,11 +2509,23 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit)
                 } else {
                         struct sk_buff *skb;
                         int frame_len;
+                        unsigned int des;
+
+                        if (unlikely(priv->synopsys_id >= DWMAC_CORE_4_00))
+                                des = p->des0;
+                        else
+                                des = p->des2;
 
                         frame_len = priv->hw->desc->get_rx_frame_len(p, coe);
 
-                        /*  check if frame_len fits the preallocated memory */
+                        /*  If frame length is greather than skb buffer size
+                         *  (preallocated during init) then the packet is
+                         *  ignored
+                         */
                         if (frame_len > priv->dma_buf_sz) {
+                                pr_err("%s: len %d larger than size (%d)\n",
+                                       priv->dev->name, frame_len,
+                                       priv->dma_buf_sz);
                                 priv->dev->stats.rx_length_errors++;
                                 break;
                         }
@@ -2299,14 +2538,19 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit)
 
                         if (netif_msg_rx_status(priv)) {
                                 pr_debug("\tdesc: %p [entry %d] buff=0x%x\n",
-                                         p, entry, p->des2);
+                                        p, entry, des);
                                 if (frame_len > ETH_FRAME_LEN)
                                         pr_debug("\tframe size %d, COE: %d\n",
                                                  frame_len, status);
                         }
 
-                        if (unlikely((frame_len < priv->rx_copybreak) ||
-                                     stmmac_rx_threshold_count(priv))) {
+                        /* The zero-copy is always used for all the sizes
+                         * in case of GMAC4 because it needs
+                         * to refill the used descriptors, always.
+                         */
+                        if (unlikely(!priv->plat->has_gmac4 &&
+                                     ((frame_len < priv->rx_copybreak) ||
+                                     stmmac_rx_threshold_count(priv)))) {
                                 skb = netdev_alloc_skb_ip_align(priv->dev,
                                                                 frame_len);
                                 if (unlikely(!skb)) {
@@ -2458,7 +2702,7 @@ static int stmmac_change_mtu(struct net_device *dev, int new_mtu)
                 return -EBUSY;
         }
 
-        if (priv->plat->enh_desc)
+        if ((priv->plat->enh_desc) || (priv->synopsys_id >= DWMAC_CORE_4_00))
                 max_mtu = JUMBO_LEN;
         else
                 max_mtu = SKB_MAX_HEAD(NET_SKB_PAD + NET_IP_ALIGN);
@@ -2472,6 +2716,7 @@ static int stmmac_change_mtu(struct net_device *dev, int new_mtu)
         }
 
         dev->mtu = new_mtu;
+
         netdev_update_features(dev);
 
         return 0;
@@ -2496,6 +2741,14 @@ static netdev_features_t stmmac_fix_features(struct net_device *dev,
         if (priv->plat->bugged_jumbo && (dev->mtu > ETH_DATA_LEN))
                 features &= ~NETIF_F_CSUM_MASK;
 
+        /* Disable tso if asked by ethtool */
+        if ((priv->plat->tso_en) && (priv->dma_cap.tsoen)) {
+                if (features & NETIF_F_TSO)
+                        priv->tso = true;
+                else
+                        priv->tso = false;
+        }
+
         return features;
 }
 
@@ -2542,7 +2795,7 @@ static irqreturn_t stmmac_interrupt(int irq, void *dev_id)
         }
 
         /* To handle GMAC own interrupts */
-        if (priv->plat->has_gmac) {
+        if ((priv->plat->has_gmac) || (priv->plat->has_gmac4)) {
                 int status = priv->hw->mac->host_irq_status(priv->hw,
                                                             &priv->xstats);
                 if (unlikely(status)) {
@@ -2551,6 +2804,10 @@ static irqreturn_t stmmac_interrupt(int irq, void *dev_id)
                                 priv->tx_path_in_lpi_mode = true;
                         if (status & CORE_IRQ_TX_PATH_EXIT_LPI_MODE)
                                 priv->tx_path_in_lpi_mode = false;
+                        if (status & CORE_IRQ_MTL_RX_OVERFLOW)
+                                priv->hw->dma->set_rx_tail_ptr(priv->ioaddr,
+                                                        priv->rx_tail_addr,
+                                                        STMMAC_CHAN0);
                 }
         }
 
@@ -2623,15 +2880,14 @@ static void sysfs_display_ring(void *head, int size, int extend_desc,
                         x = *(u64 *) ep;
                         seq_printf(seq, "%d [0x%x]: 0x%x 0x%x 0x%x 0x%x\n",
                                    i, (unsigned int)virt_to_phys(ep),
-                                   (unsigned int)x, (unsigned int)(x >> 32),
+                                   ep->basic.des0, ep->basic.des1,
                                    ep->basic.des2, ep->basic.des3);
                         ep++;
                 } else {
                         x = *(u64 *) p;
                         seq_printf(seq, "%d [0x%x]: 0x%x 0x%x 0x%x 0x%x\n",
                                    i, (unsigned int)virt_to_phys(ep),
-                                   (unsigned int)x, (unsigned int)(x >> 32),
-                                   p->des2, p->des3);
+                                   p->des0, p->des1, p->des2, p->des3);
                         p++;
                 }
                 seq_printf(seq, "\n");
@@ -2714,10 +2970,15 @@ static int stmmac_sysfs_dma_cap_read(struct seq_file *seq, void *v)
         seq_printf(seq, "\tAV features: %s\n", (priv->dma_cap.av) ? "Y" : "N");
         seq_printf(seq, "\tChecksum Offload in TX: %s\n",
                    (priv->dma_cap.tx_coe) ? "Y" : "N");
-        seq_printf(seq, "\tIP Checksum Offload (type1) in RX: %s\n",
-                   (priv->dma_cap.rx_coe_type1) ? "Y" : "N");
-        seq_printf(seq, "\tIP Checksum Offload (type2) in RX: %s\n",
-                   (priv->dma_cap.rx_coe_type2) ? "Y" : "N");
+        if (priv->synopsys_id >= DWMAC_CORE_4_00) {
+                seq_printf(seq, "\tIP Checksum Offload in RX: %s\n",
+                           (priv->dma_cap.rx_coe) ? "Y" : "N");
+        } else {
+                seq_printf(seq, "\tIP Checksum Offload (type1) in RX: %s\n",
+                           (priv->dma_cap.rx_coe_type1) ? "Y" : "N");
+                seq_printf(seq, "\tIP Checksum Offload (type2) in RX: %s\n",
+                           (priv->dma_cap.rx_coe_type2) ? "Y" : "N");
+        }
         seq_printf(seq, "\tRXFIFO > 2048bytes: %s\n",
                    (priv->dma_cap.rxfifo_over_2048) ? "Y" : "N");
         seq_printf(seq, "\tNumber of Additional RX channel: %d\n",
@@ -2826,27 +3087,35 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
                 priv->dev->priv_flags |= IFF_UNICAST_FLT;
                 mac = dwmac1000_setup(priv->ioaddr,
                                       priv->plat->multicast_filter_bins,
-                                      priv->plat->unicast_filter_entries);
+                                      priv->plat->unicast_filter_entries,
+                                      &priv->synopsys_id);
+        } else if (priv->plat->has_gmac4) {
+                priv->dev->priv_flags |= IFF_UNICAST_FLT;
+                mac = dwmac4_setup(priv->ioaddr,
+                                   priv->plat->multicast_filter_bins,
+                                   priv->plat->unicast_filter_entries,
+                                   &priv->synopsys_id);
         } else {
-                mac = dwmac100_setup(priv->ioaddr);
+                mac = dwmac100_setup(priv->ioaddr, &priv->synopsys_id);
         }
         if (!mac)
                 return -ENOMEM;
 
         priv->hw = mac;
 
-        /* Get and dump the chip ID */
-        priv->synopsys_id = stmmac_get_synopsys_id(priv);
-
         /* To use the chained or ring mode */
-        if (chain_mode) {
-                priv->hw->mode = &chain_mode_ops;
-                pr_info(" Chain mode enabled\n");
-                priv->mode = STMMAC_CHAIN_MODE;
+        if (priv->synopsys_id >= DWMAC_CORE_4_00) {
+                priv->hw->mode = &dwmac4_ring_mode_ops;
         } else {
-                priv->hw->mode = &ring_mode_ops;
-                pr_info(" Ring mode enabled\n");
-                priv->mode = STMMAC_RING_MODE;
+                if (chain_mode) {
+                        priv->hw->mode = &chain_mode_ops;
+                        pr_info(" Chain mode enabled\n");
+                        priv->mode = STMMAC_CHAIN_MODE;
+                } else {
+                        priv->hw->mode = &ring_mode_ops;
+                        pr_info(" Ring mode enabled\n");
+                        priv->mode = STMMAC_RING_MODE;
+                }
         }
 
         /* Get the HW capability (new GMAC newer than 3.50a) */
@@ -2862,11 +3131,9 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
                 priv->plat->enh_desc = priv->dma_cap.enh_desc;
                 priv->plat->pmt = priv->dma_cap.pmt_remote_wake_up;
 
-                /* TXCOE doesn't work in thresh DMA mode */
-                if (priv->plat->force_thresh_dma_mode)
-                        priv->plat->tx_coe = 0;
-                else
-                        priv->plat->tx_coe = priv->dma_cap.tx_coe;
+                priv->plat->tx_coe = priv->dma_cap.tx_coe;
+                /* In case of GMAC4 rx_coe is from HW cap register. */
+                priv->plat->rx_coe = priv->dma_cap.rx_coe;
 
                 if (priv->dma_cap.rx_coe_type2)
                         priv->plat->rx_coe = STMMAC_RX_COE_TYPE2;
@@ -2876,13 +3143,17 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
         } else
                 pr_info(" No HW DMA feature register supported");
 
-        /* To use alternate (extended) or normal descriptor structures */
-        stmmac_selec_desc_mode(priv);
+        /* To use alternate (extended), normal or GMAC4 descriptor structures */
+        if (priv->synopsys_id >= DWMAC_CORE_4_00)
+                priv->hw->desc = &dwmac4_desc_ops;
+        else
+                stmmac_selec_desc_mode(priv);
 
         if (priv->plat->rx_coe) {
                 priv->hw->rx_csum = priv->plat->rx_coe;
-                pr_info(" RX Checksum Offload Engine supported (type %d)\n",
-                        priv->plat->rx_coe);
+                pr_info(" RX Checksum Offload Engine supported\n");
+                if (priv->synopsys_id < DWMAC_CORE_4_00)
+                        pr_info("\tCOE Type %d\n", priv->hw->rx_csum);
         }
         if (priv->plat->tx_coe)
                 pr_info(" TX Checksum insertion supported\n");
@@ -2892,6 +3163,9 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
                 device_set_wakeup_capable(priv->device, 1);
         }
 
+        if (priv->dma_cap.tsoen)
+                pr_info(" TSO supported\n");
+
         return 0;
 }
 
@@ -2995,6 +3269,12 @@ int stmmac_dvr_probe(struct device *device,
 
         ndev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
                             NETIF_F_RXCSUM;
+
+        if ((priv->plat->tso_en) && (priv->dma_cap.tsoen)) {
+                ndev->hw_features |= NETIF_F_TSO;
+                priv->tso = true;
+                pr_info(" TSO feature enabled\n");
+        }
         ndev->features |= ndev->hw_features | NETIF_F_HIGHDMA;
         ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
 #ifdef STMMAC_VLAN_TAG_USED
@@ -3189,6 +3469,11 @@ int stmmac_resume(struct net_device *ndev)
         priv->dirty_rx = 0;
         priv->dirty_tx = 0;
         priv->cur_tx = 0;
+        /* reset private mss value to force mss context settings at
+         * next tso xmit (only used for gmac4).
+         */
+        priv->mss = 0;
+
         stmmac_clear_descriptors(priv);
 
         stmmac_hw_setup(ndev, false);
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
index ea76129dafc2..06704ca6f9ca 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
@@ -198,20 +198,12 @@ int stmmac_mdio_register(struct net_device *ndev)
         struct mii_bus *new_bus;
         struct stmmac_priv *priv = netdev_priv(ndev);
         struct stmmac_mdio_bus_data *mdio_bus_data = priv->plat->mdio_bus_data;
-        int addr, found;
         struct device_node *mdio_node = priv->plat->mdio_node;
+        int addr, found;
 
         if (!mdio_bus_data)
                 return 0;
 
-        if (IS_ENABLED(CONFIG_OF)) {
-                if (mdio_node) {
-                        netdev_dbg(ndev, "FOUND MDIO subnode\n");
-                } else {
-                        netdev_warn(ndev, "No MDIO subnode found\n");
-                }
-        }
-
         new_bus = mdiobus_alloc();
         if (new_bus == NULL)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index dcbd2a1601e8..effaa4ff5ab7 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -132,6 +132,69 @@ static struct stmmac_axi *stmmac_axi_setup(struct platform_device *pdev)
 }
 
 /**
+ * stmmac_dt_phy - parse device-tree driver parameters to allocate PHY resources
+ * @plat: driver data platform structure
+ * @np: device tree node
+ * @dev: device pointer
+ * Description:
+ * The mdio bus will be allocated in case of a phy transceiver is on board;
+ * it will be NULL if the fixed-link is configured.
+ * If there is the "snps,dwmac-mdio" sub-node the mdio will be allocated
+ * in any case (for DSA, mdio must be registered even if fixed-link).
+ * The table below sums the supported configurations:
+ *      -------------------------------
+ *      snps,phy-addr   |     Y
+ *      -------------------------------
+ *      phy-handle      |     Y
+ *      -------------------------------
+ *      fixed-link      |     N
+ *      -------------------------------
+ *      snps,dwmac-mdio |
+ *        even if       |     Y
+ *      fixed-link      |
+ *      -------------------------------
+ *
+ * It returns 0 in case of success otherwise -ENODEV.
+ */
+static int stmmac_dt_phy(struct plat_stmmacenet_data *plat,
+                         struct device_node *np, struct device *dev)
+{
+        bool mdio = true;
+
+        /* If phy-handle property is passed from DT, use it as the PHY */
+        plat->phy_node = of_parse_phandle(np, "phy-handle", 0);
+        if (plat->phy_node)
+                dev_dbg(dev, "Found phy-handle subnode\n");
+
+        /* If phy-handle is not specified, check if we have a fixed-phy */
+        if (!plat->phy_node && of_phy_is_fixed_link(np)) {
+                if ((of_phy_register_fixed_link(np) < 0))
+                        return -ENODEV;
+
+                dev_dbg(dev, "Found fixed-link subnode\n");
+                plat->phy_node = of_node_get(np);
+                mdio = false;
+        }
+
+        /* If snps,dwmac-mdio is passed from DT, always register the MDIO */
+        for_each_child_of_node(np, plat->mdio_node) {
+                if (of_device_is_compatible(plat->mdio_node, "snps,dwmac-mdio"))
+                        break;
+        }
+
+        if (plat->mdio_node) {
+                dev_dbg(dev, "Found MDIO subnode\n");
+                mdio = true;
+        }
+
+        if (mdio)
+                plat->mdio_bus_data =
+                        devm_kzalloc(dev, sizeof(struct stmmac_mdio_bus_data),
+                                     GFP_KERNEL);
+        return 0;
+}
+
+/**
  * stmmac_probe_config_dt - parse device-tree driver parameters
  * @pdev: platform_device structure
  * @plat: driver data platform structure
@@ -146,7 +209,6 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
         struct device_node *np = pdev->dev.of_node;
         struct plat_stmmacenet_data *plat;
         struct stmmac_dma_cfg *dma_cfg;
-        struct device_node *child_node = NULL;
 
         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
         if (!plat)
@@ -166,36 +228,15 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
         /* Default to phy auto-detection */
         plat->phy_addr = -1;
 
-        /* If we find a phy-handle property, use it as the PHY */
-        plat->phy_node = of_parse_phandle(np, "phy-handle", 0);
-
-        /* If phy-handle is not specified, check if we have a fixed-phy */
-        if (!plat->phy_node && of_phy_is_fixed_link(np)) {
-                if ((of_phy_register_fixed_link(np) < 0))
-                        return ERR_PTR(-ENODEV);
-
-                plat->phy_node = of_node_get(np);
-        }
-
-        for_each_child_of_node(np, child_node)
-                if (of_device_is_compatible(child_node, "snps,dwmac-mdio")) {
-                        plat->mdio_node = child_node;
-                        break;
-                }
-
         /* "snps,phy-addr" is not a standard property. Mark it as deprecated
          * and warn of its use. Remove this when phy node support is added.
          */
         if (of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr) == 0)
                 dev_warn(&pdev->dev, "snps,phy-addr property is deprecated\n");
 
-        if ((plat->phy_node && !of_phy_is_fixed_link(np)) || !plat->mdio_node)
-                plat->mdio_bus_data = NULL;
-        else
-                plat->mdio_bus_data =
-                        devm_kzalloc(&pdev->dev,
-                                     sizeof(struct stmmac_mdio_bus_data),
-                                     GFP_KERNEL);
+        /* To Configure PHY by using all device-tree supported properties */
+        if (stmmac_dt_phy(plat, np, &pdev->dev))
+                return ERR_PTR(-ENODEV);
 
         of_property_read_u32(np, "tx-fifo-depth", &plat->tx_fifo_size);
 
@@ -243,6 +284,13 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
                 plat->pmt = 1;
         }
 
+        if (of_device_is_compatible(np, "snps,dwmac-4.00") ||
+            of_device_is_compatible(np, "snps,dwmac-4.10a")) {
+                plat->has_gmac4 = 1;
+                plat->pmt = 1;
+                plat->tso_en = of_property_read_bool(np, "snps,tso");
+        }
+
         if (of_device_is_compatible(np, "snps,dwmac-3.610") ||
                 of_device_is_compatible(np, "snps,dwmac-3.710")) {
                 plat->enh_desc = 1;
diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c
index 192631a345df..a9fbf17eb256 100644
--- a/drivers/net/geneve.c
+++ b/drivers/net/geneve.c
@@ -87,7 +87,6 @@ struct geneve_sock {
         struct socket           *sock;
         struct rcu_head         rcu;
         int                     refcnt;
-        struct udp_offload      udp_offloads;
         struct hlist_head       vni_list[VNI_HASH_SIZE];
         u32                     flags;
 };
@@ -409,14 +408,6 @@ static void geneve_notify_add_rx_port(struct geneve_sock *gs)
         struct net *net = sock_net(sk);
         sa_family_t sa_family = geneve_get_sk_family(gs);
         __be16 port = inet_sk(sk)->inet_sport;
-        int err;
-
-        if (sa_family == AF_INET) {
-                err = udp_add_offload(sock_net(sk), &gs->udp_offloads);
-                if (err)
-                        pr_warn("geneve: udp_add_offload failed with status %d\n",
-                                err);
-        }
 
         rcu_read_lock();
         for_each_netdev_rcu(net, dev) {
@@ -432,9 +423,9 @@ static int geneve_hlen(struct genevehdr *gh)
         return sizeof(*gh) + gh->opt_len * 4;
 }
 
-static struct sk_buff **geneve_gro_receive(struct sk_buff **head,
-                                           struct sk_buff *skb,
-                                           struct udp_offload *uoff)
+static struct sk_buff **geneve_gro_receive(struct sock *sk,
+                                           struct sk_buff **head,
+                                           struct sk_buff *skb)
 {
         struct sk_buff *p, **pp = NULL;
         struct genevehdr *gh, *gh2;
@@ -495,8 +486,8 @@ out:
         return pp;
 }
 
-static int geneve_gro_complete(struct sk_buff *skb, int nhoff,
-                               struct udp_offload *uoff)
+static int geneve_gro_complete(struct sock *sk, struct sk_buff *skb,
+                               int nhoff)
 {
         struct genevehdr *gh;
         struct packet_offload *ptype;
@@ -545,14 +536,14 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,
                 INIT_HLIST_HEAD(&gs->vni_list[h]);
 
         /* Initialize the geneve udp offloads structure */
-        gs->udp_offloads.port = port;
-        gs->udp_offloads.callbacks.gro_receive  = geneve_gro_receive;
-        gs->udp_offloads.callbacks.gro_complete = geneve_gro_complete;
         geneve_notify_add_rx_port(gs);
 
         /* Mark socket as an encapsulation socket */
+        memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
         tunnel_cfg.sk_user_data = gs;
         tunnel_cfg.encap_type = 1;
+        tunnel_cfg.gro_receive = geneve_gro_receive;
+        tunnel_cfg.gro_complete = geneve_gro_complete;
         tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
         tunnel_cfg.encap_destroy = NULL;
         setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
@@ -576,9 +567,6 @@ static void geneve_notify_del_rx_port(struct geneve_sock *gs)
         }
 
         rcu_read_unlock();
-
-        if (sa_family == AF_INET)
-                udp_del_offload(&gs->udp_offloads);
 }
 
 static void __geneve_sock_release(struct geneve_sock *gs)
@@ -843,8 +831,8 @@ static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
         if (info) {
                 fl6->daddr = info->key.u.ipv6.dst;
                 fl6->saddr = info->key.u.ipv6.src;
-                fl6->flowi6_tos = RT_TOS(info->key.tos);
-                fl6->flowlabel = info->key.label;
+                fl6->flowlabel = ip6_make_flowinfo(RT_TOS(info->key.tos),
+                                                   info->key.label);
                 dst_cache = &info->dst_cache;
         } else {
                 prio = geneve->tos;
@@ -855,8 +843,8 @@ static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
                         use_cache = false;
                 }
 
-                fl6->flowi6_tos = RT_TOS(prio);
-                fl6->flowlabel = geneve->label;
+                fl6->flowlabel = ip6_make_flowinfo(RT_TOS(prio),
+                                                   geneve->label);
                 fl6->daddr = geneve->remote.sin6.sin6_addr;
                 dst_cache = &geneve->dst_cache;
         }
@@ -1049,7 +1037,8 @@ static netdev_tx_t geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
                 if (unlikely(err))
                         goto err;
 
-                prio = ip_tunnel_ecn_encap(fl6.flowi6_tos, iip, skb);
+                prio = ip_tunnel_ecn_encap(ip6_tclass(fl6.flowlabel),
+                                           iip, skb);
                 ttl = geneve->ttl;
                 if (!ttl && ipv6_addr_is_multicast(&fl6.daddr))
                         ttl = 1;
diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
index b4c68783dfc3..8b3bd8ecd1c4 100644
--- a/drivers/net/hyperv/hyperv_net.h
+++ b/drivers/net/hyperv/hyperv_net.h
@@ -619,6 +619,7 @@ struct nvsp_message {
 #define NETVSC_PACKET_SIZE                      4096
 
 #define VRSS_SEND_TAB_SIZE 16
+#define VRSS_CHANNEL_MAX 64
 
 #define RNDIS_MAX_PKT_DEFAULT 8
 #define RNDIS_PKT_ALIGN_DEFAULT 8
@@ -700,13 +701,13 @@ struct netvsc_device {
 
         struct net_device *ndev;
 
-        struct vmbus_channel *chn_table[NR_CPUS];
+        struct vmbus_channel *chn_table[VRSS_CHANNEL_MAX];
         u32 send_table[VRSS_SEND_TAB_SIZE];
         u32 max_chn;
         u32 num_chn;
         spinlock_t sc_lock; /* Protects num_sc_offered variable */
         u32 num_sc_offered;
-        atomic_t queue_sends[NR_CPUS];
+        atomic_t queue_sends[VRSS_CHANNEL_MAX];
 
         /* Holds rndis device info */
         void *extension;
@@ -718,7 +719,7 @@ struct netvsc_device {
         /* The sub channel callback buffer */
         unsigned char *sub_cb_buf;
 
-        struct multi_send_data msd[NR_CPUS];
+        struct multi_send_data msd[VRSS_CHANNEL_MAX];
         u32 max_pkt; /* max number of pkt in one send, e.g. 8 */
         u32 pkt_align; /* alignment bytes, e.g. 8 */
 
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 08608499fa17..b8121eba33ff 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -858,6 +858,7 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
         struct netvsc_device *nvdev = hv_get_drvdata(hdev);
         struct netvsc_device_info device_info;
         int limit = ETH_DATA_LEN;
+        u32 num_chn;
         int ret = 0;
 
         if (nvdev == NULL || nvdev->destroy)
@@ -873,6 +874,8 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
         if (ret)
                 goto out;
 
+        num_chn = nvdev->num_chn;
+
         nvdev->start_remove = true;
         rndis_filter_device_remove(hdev);
 
@@ -883,7 +886,7 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
 
         memset(&device_info, 0, sizeof(device_info));
         device_info.ring_size = ring_size;
-        device_info.num_chn = nvdev->num_chn;
+        device_info.num_chn = num_chn;
         device_info.max_num_vrss_chns = max_num_vrss_chns;
         rndis_filter_device_add(hdev, &device_info);
 
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index 47d07c576a34..c4e1e0408433 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -986,12 +986,6 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
 
         nvscdev = hv_get_drvdata(new_sc->primary_channel->device_obj);
 
-        spin_lock_irqsave(&nvscdev->sc_lock, flags);
-        nvscdev->num_sc_offered--;
-        spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
-        if (nvscdev->num_sc_offered == 0)
-                complete(&nvscdev->channel_init_wait);
-
         if (chn_index >= nvscdev->num_chn)
                 return;
 
@@ -1004,6 +998,12 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
 
         if (ret == 0)
                 nvscdev->chn_table[chn_index] = new_sc;
+
+        spin_lock_irqsave(&nvscdev->sc_lock, flags);
+        nvscdev->num_sc_offered--;
+        spin_unlock_irqrestore(&nvscdev->sc_lock, flags);
+        if (nvscdev->num_sc_offered == 0)
+                complete(&nvscdev->channel_init_wait);
 }
 
 int rndis_filter_device_add(struct hv_device *dev,
@@ -1113,9 +1113,9 @@ int rndis_filter_device_add(struct hv_device *dev,
         if (ret || rsscap.num_recv_que < 2)
                 goto out;
 
-        num_rss_qs = min(device_info->max_num_vrss_chns, rsscap.num_recv_que);
+        net_device->max_chn = min_t(u32, VRSS_CHANNEL_MAX, rsscap.num_recv_que);
 
-        net_device->max_chn = rsscap.num_recv_que;
+        num_rss_qs = min(device_info->max_num_vrss_chns, net_device->max_chn);
 
         /*
          * We will limit the VRSS channels to the number CPUs in the NUMA node
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index a2c227bfb687..e070e1222733 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -394,12 +394,5 @@ config MCS_FIR
           To compile it as a module, choose M here: the module will be called
           mcs7780.
 
-config SH_IRDA
-        tristate "SuperH IrDA driver"
-        depends on IRDA
-        depends on (ARCH_SHMOBILE || COMPILE_TEST) && HAS_IOMEM
-        help
-          Say Y here if your want to enable SuperH IrDA devices.
-
 endmenu
 
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
index be8ab5b9a4a2..4c344433dae5 100644
--- a/drivers/net/irda/Makefile
+++ b/drivers/net/irda/Makefile
@@ -19,7 +19,6 @@ obj-$(CONFIG_VIA_FIR)		+= via-ircc.o
 obj-$(CONFIG_PXA_FICP)          += pxaficp_ir.o
 obj-$(CONFIG_MCS_FIR)           += mcs7780.o
 obj-$(CONFIG_AU1000_FIR)        += au1k_ir.o
-obj-$(CONFIG_SH_IRDA)           += sh_irda.o
 # SIR drivers
 obj-$(CONFIG_IRTTY_SIR)         += irtty-sir.o  sir-dev.o
 obj-$(CONFIG_BFIN_SIR)          += bfin_sir.o
diff --git a/drivers/net/irda/sh_irda.c b/drivers/net/irda/sh_irda.c
deleted file mode 100644
index c96b46b2c3a8..000000000000
--- a/drivers/net/irda/sh_irda.c
+++ /dev/null
@@ -1,875 +0,0 @@
-/*
- * SuperH IrDA Driver
- *
- * Copyright (C) 2010 Renesas Solutions Corp.
- * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
- *
- * Based on sh_sir.c
- * Copyright (C) 2009 Renesas Solutions Corp.
- * Copyright 2006-2009 Analog Devices Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/*
- * CAUTION
- *
- * This driver is very simple.
- * So, it doesn't have below support now
- *  - MIR/FIR support
- *  - DMA transfer support
- *  - FIFO mode support
- */
-#include <linux/io.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/clk.h>
-#include <net/irda/wrapper.h>
-#include <net/irda/irda_device.h>
-
-#define DRIVER_NAME "sh_irda"
-
-#define __IRDARAM_LEN   0x1039
-
-#define IRTMR           0x1F00 /* Transfer mode */
-#define IRCFR           0x1F02 /* Configuration */
-#define IRCTR           0x1F04 /* IR control */
-#define IRTFLR          0x1F20 /* Transmit frame length */
-#define IRTCTR          0x1F22 /* Transmit control */
-#define IRRFLR          0x1F40 /* Receive frame length */
-#define IRRCTR          0x1F42 /* Receive control */
-#define SIRISR          0x1F60 /* SIR-UART mode interrupt source */
-#define SIRIMR          0x1F62 /* SIR-UART mode interrupt mask */
-#define SIRICR          0x1F64 /* SIR-UART mode interrupt clear */
-#define SIRBCR          0x1F68 /* SIR-UART mode baud rate count */
-#define MFIRISR         0x1F70 /* MIR/FIR mode interrupt source */
-#define MFIRIMR         0x1F72 /* MIR/FIR mode interrupt mask */
-#define MFIRICR         0x1F74 /* MIR/FIR mode interrupt clear */
-#define CRCCTR          0x1F80 /* CRC engine control */
-#define CRCIR           0x1F86 /* CRC engine input data */
-#define CRCCR           0x1F8A /* CRC engine calculation */
-#define CRCOR           0x1F8E /* CRC engine output data */
-#define FIFOCP          0x1FC0 /* FIFO current pointer */
-#define FIFOFP          0x1FC2 /* FIFO follow pointer */
-#define FIFORSMSK       0x1FC4 /* FIFO receive status mask */
-#define FIFORSOR        0x1FC6 /* FIFO receive status OR */
-#define FIFOSEL         0x1FC8 /* FIFO select */
-#define FIFORS          0x1FCA /* FIFO receive status */
-#define FIFORFL         0x1FCC /* FIFO receive frame length */
-#define FIFORAMCP       0x1FCE /* FIFO RAM current pointer */
-#define FIFORAMFP       0x1FD0 /* FIFO RAM follow pointer */
-#define BIFCTL          0x1FD2 /* BUS interface control */
-#define IRDARAM         0x0000 /* IrDA buffer RAM */
-#define IRDARAM_LEN     __IRDARAM_LEN /* - 8/16/32 (read-only for 32) */
-
-/* IRTMR */
-#define TMD_MASK        (0x3 << 14) /* Transfer Mode */
-#define TMD_SIR         (0x0 << 14)
-#define TMD_MIR         (0x3 << 14)
-#define TMD_FIR         (0x2 << 14)
-
-#define FIFORIM         (1 << 8) /* FIFO receive interrupt mask */
-#define MIM             (1 << 4) /* MIR/FIR Interrupt Mask */
-#define SIM             (1 << 0) /* SIR Interrupt Mask */
-#define xIM_MASK        (FIFORIM | MIM | SIM)
-
-/* IRCFR */
-#define RTO_SHIFT       8 /* shift for Receive Timeout */
-#define RTO             (0x3 << RTO_SHIFT)
-
-/* IRTCTR */
-#define ARMOD           (1 << 15) /* Auto-Receive Mode */
-#define TE              (1 <<  0) /* Transmit Enable */
-
-/* IRRFLR */
-#define RFL_MASK        (0x1FFF) /* mask for Receive Frame Length */
-
-/* IRRCTR */
-#define RE              (1 <<  0) /* Receive Enable */
-
-/*
- * SIRISR,  SIRIMR,  SIRICR,
- * MFIRISR, MFIRIMR, MFIRICR
- */
-#define FRE             (1 << 15) /* Frame Receive End */
-#define TROV            (1 << 11) /* Transfer Area Overflow */
-#define xIR_9           (1 << 9)
-#define TOT             xIR_9     /* for SIR     Timeout */
-#define ABTD            xIR_9     /* for MIR/FIR Abort Detection */
-#define xIR_8           (1 << 8)
-#define FER             xIR_8     /* for SIR     Framing Error */
-#define CRCER           xIR_8     /* for MIR/FIR CRC error */
-#define FTE             (1 << 7)  /* Frame Transmit End */
-#define xIR_MASK        (FRE | TROV | xIR_9 | xIR_8 | FTE)
-
-/* SIRBCR */
-#define BRC_MASK        (0x3F) /* mask for Baud Rate Count */
-
-/* CRCCTR */
-#define CRC_RST         (1 << 15) /* CRC Engine Reset */
-#define CRC_CT_MASK     0x0FFF    /* mask for CRC Engine Input Data Count */
-
-/* CRCIR */
-#define CRC_IN_MASK     0x0FFF    /* mask for CRC Engine Input Data */
-
-/************************************************************************
-
-
-                        enum / structure
-
-
-************************************************************************/
-enum sh_irda_mode {
-        SH_IRDA_NONE = 0,
-        SH_IRDA_SIR,
-        SH_IRDA_MIR,
-        SH_IRDA_FIR,
-};
-
-struct sh_irda_self;
-struct sh_irda_xir_func {
-        int (*xir_fre)  (struct sh_irda_self *self);
-        int (*xir_trov) (struct sh_irda_self *self);
-        int (*xir_9)    (struct sh_irda_self *self);
-        int (*xir_8)    (struct sh_irda_self *self);
-        int (*xir_fte)  (struct sh_irda_self *self);
-};
-
-struct sh_irda_self {
-        void __iomem            *membase;
-        unsigned int            irq;
-        struct platform_device  *pdev;
-
-        struct net_device       *ndev;
-
-        struct irlap_cb         *irlap;
-        struct qos_info         qos;
-
-        iobuff_t                tx_buff;
-        iobuff_t                rx_buff;
-
-        enum sh_irda_mode       mode;
-        spinlock_t              lock;
-
-        struct sh_irda_xir_func *xir_func;
-};
-
-/************************************************************************
-
-
-                        common function
-
-
-************************************************************************/
-static void sh_irda_write(struct sh_irda_self *self, u32 offset, u16 data)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&self->lock, flags);
-        iowrite16(data, self->membase + offset);
-        spin_unlock_irqrestore(&self->lock, flags);
-}
-
-static u16 sh_irda_read(struct sh_irda_self *self, u32 offset)
-{
-        unsigned long flags;
-        u16 ret;
-
-        spin_lock_irqsave(&self->lock, flags);
-        ret = ioread16(self->membase + offset);
-        spin_unlock_irqrestore(&self->lock, flags);
-
-        return ret;
-}
-
-static void sh_irda_update_bits(struct sh_irda_self *self, u32 offset,
-                               u16 mask, u16 data)
-{
-        unsigned long flags;
-        u16 old, new;
-
-        spin_lock_irqsave(&self->lock, flags);
-        old = ioread16(self->membase + offset);
-        new = (old & ~mask) | data;
-        if (old != new)
-                iowrite16(data, self->membase + offset);
-        spin_unlock_irqrestore(&self->lock, flags);
-}
-
-/************************************************************************
-
-
-                        mode function
-
-
-************************************************************************/
-/*=====================================
- *
- *              common
- *
- *=====================================*/
-static void sh_irda_rcv_ctrl(struct sh_irda_self *self, int enable)
-{
-        struct device *dev = &self->ndev->dev;
-
-        sh_irda_update_bits(self, IRRCTR, RE, enable ? RE : 0);
-        dev_dbg(dev, "recv %s\n", enable ? "enable" : "disable");
-}
-
-static int sh_irda_set_timeout(struct sh_irda_self *self, int interval)
-{
-        struct device *dev = &self->ndev->dev;
-
-        if (SH_IRDA_SIR != self->mode)
-                interval = 0;
-
-        if (interval < 0 || interval > 2) {
-                dev_err(dev, "unsupported timeout interval\n");
-                return -EINVAL;
-        }
-
-        sh_irda_update_bits(self, IRCFR, RTO, interval << RTO_SHIFT);
-        return 0;
-}
-
-static int sh_irda_set_baudrate(struct sh_irda_self *self, int baudrate)
-{
-        struct device *dev = &self->ndev->dev;
-        u16 val;
-
-        if (baudrate < 0)
-                return 0;
-
-        if (SH_IRDA_SIR != self->mode) {
-                dev_err(dev, "it is not SIR mode\n");
-                return -EINVAL;
-        }
-
-        /*
-         * Baud rate (bits/s) =
-         *   (48 MHz / 26) / (baud rate counter value + 1) x 16
-         */
-        val = (48000000 / 26 / 16 / baudrate) - 1;
-        dev_dbg(dev, "baudrate = %d,  val = 0x%02x\n", baudrate, val);
-
-        sh_irda_update_bits(self, SIRBCR, BRC_MASK, val);
-
-        return 0;
-}
-
-static int sh_irda_get_rcv_length(struct sh_irda_self *self)
-{
-        return RFL_MASK & sh_irda_read(self, IRRFLR);
-}
-
-/*=====================================
- *
- *              NONE MODE
- *
- *=====================================*/
-static int sh_irda_xir_fre(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        dev_err(dev, "none mode: frame recv\n");
-        return 0;
-}
-
-static int sh_irda_xir_trov(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        dev_err(dev, "none mode: buffer ram over\n");
-        return 0;
-}
-
-static int sh_irda_xir_9(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        dev_err(dev, "none mode: time over\n");
-        return 0;
-}
-
-static int sh_irda_xir_8(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        dev_err(dev, "none mode: framing error\n");
-        return 0;
-}
-
-static int sh_irda_xir_fte(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        dev_err(dev, "none mode: frame transmit end\n");
-        return 0;
-}
-
-static struct sh_irda_xir_func sh_irda_xir_func = {
-        .xir_fre        = sh_irda_xir_fre,
-        .xir_trov       = sh_irda_xir_trov,
-        .xir_9          = sh_irda_xir_9,
-        .xir_8          = sh_irda_xir_8,
-        .xir_fte        = sh_irda_xir_fte,
-};
-
-/*=====================================
- *
- *              MIR/FIR MODE
- *
- * MIR/FIR are not supported now
- *=====================================*/
-static struct sh_irda_xir_func sh_irda_mfir_func = {
-        .xir_fre        = sh_irda_xir_fre,
-        .xir_trov       = sh_irda_xir_trov,
-        .xir_9          = sh_irda_xir_9,
-        .xir_8          = sh_irda_xir_8,
-        .xir_fte        = sh_irda_xir_fte,
-};
-
-/*=====================================
- *
- *              SIR MODE
- *
- *=====================================*/
-static int sh_irda_sir_fre(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        u16 data16;
-        u8  *data = (u8 *)&data16;
-        int len = sh_irda_get_rcv_length(self);
-        int i, j;
-
-        if (len > IRDARAM_LEN)
-                len = IRDARAM_LEN;
-
-        dev_dbg(dev, "frame recv length = %d\n", len);
-
-        for (i = 0; i < len; i++) {
-                j = i % 2;
-                if (!j)
-                        data16 = sh_irda_read(self, IRDARAM + i);
-
-                async_unwrap_char(self->ndev, &self->ndev->stats,
-                                  &self->rx_buff, data[j]);
-        }
-        self->ndev->last_rx = jiffies;
-
-        sh_irda_rcv_ctrl(self, 1);
-
-        return 0;
-}
-
-static int sh_irda_sir_trov(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-
-        dev_err(dev, "buffer ram over\n");
-        sh_irda_rcv_ctrl(self, 1);
-        return 0;
-}
-
-static int sh_irda_sir_tot(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-
-        dev_err(dev, "time over\n");
-        sh_irda_set_baudrate(self, 9600);
-        sh_irda_rcv_ctrl(self, 1);
-        return 0;
-}
-
-static int sh_irda_sir_fer(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-
-        dev_err(dev, "framing error\n");
-        sh_irda_rcv_ctrl(self, 1);
-        return 0;
-}
-
-static int sh_irda_sir_fte(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-
-        dev_dbg(dev, "frame transmit end\n");
-        netif_wake_queue(self->ndev);
-
-        return 0;
-}
-
-static struct sh_irda_xir_func sh_irda_sir_func = {
-        .xir_fre        = sh_irda_sir_fre,
-        .xir_trov       = sh_irda_sir_trov,
-        .xir_9          = sh_irda_sir_tot,
-        .xir_8          = sh_irda_sir_fer,
-        .xir_fte        = sh_irda_sir_fte,
-};
-
-static void sh_irda_set_mode(struct sh_irda_self *self, enum sh_irda_mode mode)
-{
-        struct device *dev = &self->ndev->dev;
-        struct sh_irda_xir_func *func;
-        const char *name;
-        u16 data;
-
-        switch (mode) {
-        case SH_IRDA_SIR:
-                name    = "SIR";
-                data    = TMD_SIR;
-                func    = &sh_irda_sir_func;
-                break;
-        case SH_IRDA_MIR:
-                name    = "MIR";
-                data    = TMD_MIR;
-                func    = &sh_irda_mfir_func;
-                break;
-        case SH_IRDA_FIR:
-                name    = "FIR";
-                data    = TMD_FIR;
-                func    = &sh_irda_mfir_func;
-                break;
-        default:
-                name    = "NONE";
-                data    = 0;
-                func    = &sh_irda_xir_func;
-                break;
-        }
-
-        self->mode = mode;
-        self->xir_func = func;
-        sh_irda_update_bits(self, IRTMR, TMD_MASK, data);
-
-        dev_dbg(dev, "switch to %s mode", name);
-}
-
-/************************************************************************
-
-
-                        irq function
-
-
-************************************************************************/
-static void sh_irda_set_irq_mask(struct sh_irda_self *self)
-{
-        u16 tmr_hole;
-        u16 xir_reg;
-
-        /* set all mask */
-        sh_irda_update_bits(self, IRTMR,   xIM_MASK, xIM_MASK);
-        sh_irda_update_bits(self, SIRIMR,  xIR_MASK, xIR_MASK);
-        sh_irda_update_bits(self, MFIRIMR, xIR_MASK, xIR_MASK);
-
-        /* clear irq */
-        sh_irda_update_bits(self, SIRICR,  xIR_MASK, xIR_MASK);
-        sh_irda_update_bits(self, MFIRICR, xIR_MASK, xIR_MASK);
-
-        switch (self->mode) {
-        case SH_IRDA_SIR:
-                tmr_hole        = SIM;
-                xir_reg         = SIRIMR;
-                break;
-        case SH_IRDA_MIR:
-        case SH_IRDA_FIR:
-                tmr_hole        = MIM;
-                xir_reg         = MFIRIMR;
-                break;
-        default:
-                tmr_hole        = 0;
-                xir_reg         = 0;
-                break;
-        }
-
-        /* open mask */
-        if (xir_reg) {
-                sh_irda_update_bits(self, IRTMR, tmr_hole, 0);
-                sh_irda_update_bits(self, xir_reg, xIR_MASK, 0);
-        }
-}
-
-static irqreturn_t sh_irda_irq(int irq, void *dev_id)
-{
-        struct sh_irda_self *self = dev_id;
-        struct sh_irda_xir_func *func = self->xir_func;
-        u16 isr = sh_irda_read(self, SIRISR);
-
-        /* clear irq */
-        sh_irda_write(self, SIRICR, isr);
-
-        if (isr & FRE)
-                func->xir_fre(self);
-        if (isr & TROV)
-                func->xir_trov(self);
-        if (isr & xIR_9)
-                func->xir_9(self);
-        if (isr & xIR_8)
-                func->xir_8(self);
-        if (isr & FTE)
-                func->xir_fte(self);
-
-        return IRQ_HANDLED;
-}
-
-/************************************************************************
-
-
-                        CRC function
-
-
-************************************************************************/
-static void sh_irda_crc_reset(struct sh_irda_self *self)
-{
-        sh_irda_write(self, CRCCTR, CRC_RST);
-}
-
-static void sh_irda_crc_add(struct sh_irda_self *self, u16 data)
-{
-        sh_irda_write(self, CRCIR, data & CRC_IN_MASK);
-}
-
-static u16 sh_irda_crc_cnt(struct sh_irda_self *self)
-{
-        return CRC_CT_MASK & sh_irda_read(self, CRCCTR);
-}
-
-static u16 sh_irda_crc_out(struct sh_irda_self *self)
-{
-        return sh_irda_read(self, CRCOR);
-}
-
-static int sh_irda_crc_init(struct sh_irda_self *self)
-{
-        struct device *dev = &self->ndev->dev;
-        int ret = -EIO;
-        u16 val;
-
-        sh_irda_crc_reset(self);
-
-        sh_irda_crc_add(self, 0xCC);
-        sh_irda_crc_add(self, 0xF5);
-        sh_irda_crc_add(self, 0xF1);
-        sh_irda_crc_add(self, 0xA7);
-
-        val = sh_irda_crc_cnt(self);
-        if (4 != val) {
-                dev_err(dev, "CRC count error %x\n", val);
-                goto crc_init_out;
-        }
-
-        val = sh_irda_crc_out(self);
-        if (0x51DF != val) {
-                dev_err(dev, "CRC result error%x\n", val);
-                goto crc_init_out;
-        }
-
-        ret = 0;
-
-crc_init_out:
-
-        sh_irda_crc_reset(self);
-        return ret;
-}
-
-/************************************************************************
-
-
-                        iobuf function
-
-
-************************************************************************/
-static void sh_irda_remove_iobuf(struct sh_irda_self *self)
-{
-        kfree(self->rx_buff.head);
-
-        self->tx_buff.head = NULL;
-        self->tx_buff.data = NULL;
-        self->rx_buff.head = NULL;
-        self->rx_buff.data = NULL;
-}
-
-static int sh_irda_init_iobuf(struct sh_irda_self *self, int rxsize, int txsize)
-{
-        if (self->rx_buff.head ||
-            self->tx_buff.head) {
-                dev_err(&self->ndev->dev, "iobuff has already existed.");
-                return -EINVAL;
-        }
-
-        /* rx_buff */
-        self->rx_buff.head = kmalloc(rxsize, GFP_KERNEL);
-        if (!self->rx_buff.head)
-                return -ENOMEM;
-
-        self->rx_buff.truesize  = rxsize;
-        self->rx_buff.in_frame  = FALSE;
-        self->rx_buff.state     = OUTSIDE_FRAME;
-        self->rx_buff.data      = self->rx_buff.head;
-
-        /* tx_buff */
-        self->tx_buff.head      = self->membase + IRDARAM;
-        self->tx_buff.truesize  = IRDARAM_LEN;
-
-        return 0;
-}
-
-/************************************************************************
-
-
-                        net_device_ops function
-
-
-************************************************************************/
-static int sh_irda_hard_xmit(struct sk_buff *skb, struct net_device *ndev)
-{
-        struct sh_irda_self *self = netdev_priv(ndev);
-        struct device *dev = &self->ndev->dev;
-        int speed = irda_get_next_speed(skb);
-        int ret;
-
-        dev_dbg(dev, "hard xmit\n");
-
-        netif_stop_queue(ndev);
-        sh_irda_rcv_ctrl(self, 0);
-
-        ret = sh_irda_set_baudrate(self, speed);
-        if (ret < 0)
-                goto sh_irda_hard_xmit_end;
-
-        self->tx_buff.len = 0;
-        if (skb->len) {
-                unsigned long flags;
-
-                spin_lock_irqsave(&self->lock, flags);
-                self->tx_buff.len = async_wrap_skb(skb,
-                                                   self->tx_buff.head,
-                                                   self->tx_buff.truesize);
-                spin_unlock_irqrestore(&self->lock, flags);
-
-                if (self->tx_buff.len > self->tx_buff.truesize)
-                        self->tx_buff.len = self->tx_buff.truesize;
-
-                sh_irda_write(self, IRTFLR, self->tx_buff.len);
-                sh_irda_write(self, IRTCTR, ARMOD | TE);
-        } else
-                goto sh_irda_hard_xmit_end;
-
-        dev_kfree_skb(skb);
-
-        return 0;
-
-sh_irda_hard_xmit_end:
-        sh_irda_set_baudrate(self, 9600);
-        netif_wake_queue(self->ndev);
-        sh_irda_rcv_ctrl(self, 1);
-        dev_kfree_skb(skb);
-
-        return ret;
-
-}
-
-static int sh_irda_ioctl(struct net_device *ndev, struct ifreq *ifreq, int cmd)
-{
-        /*
-         * FIXME
-         *
-         * This function is needed for irda framework.
-         * But nothing to do now
-         */
-        return 0;
-}
-
-static struct net_device_stats *sh_irda_stats(struct net_device *ndev)
-{
-        struct sh_irda_self *self = netdev_priv(ndev);
-
-        return &self->ndev->stats;
-}
-
-static int sh_irda_open(struct net_device *ndev)
-{
-        struct sh_irda_self *self = netdev_priv(ndev);
-        int err;
-
-        pm_runtime_get_sync(&self->pdev->dev);
-        err = sh_irda_crc_init(self);
-        if (err)
-                goto open_err;
-
-        sh_irda_set_mode(self, SH_IRDA_SIR);
-        sh_irda_set_timeout(self, 2);
-        sh_irda_set_baudrate(self, 9600);
-
-        self->irlap = irlap_open(ndev, &self->qos, DRIVER_NAME);
-        if (!self->irlap) {
-                err = -ENODEV;
-                goto open_err;
-        }
-
-        netif_start_queue(ndev);
-        sh_irda_rcv_ctrl(self, 1);
-        sh_irda_set_irq_mask(self);
-
-        dev_info(&ndev->dev, "opened\n");
-
-        return 0;
-
-open_err:
-        pm_runtime_put_sync(&self->pdev->dev);
-
-        return err;
-}
-
-static int sh_irda_stop(struct net_device *ndev)
-{
-        struct sh_irda_self *self = netdev_priv(ndev);
-
-        /* Stop IrLAP */
-        if (self->irlap) {
-                irlap_close(self->irlap);
-                self->irlap = NULL;
-        }
-
-        netif_stop_queue(ndev);
-        pm_runtime_put_sync(&self->pdev->dev);
-
-        dev_info(&ndev->dev, "stopped\n");
-
-        return 0;
-}
-
-static const struct net_device_ops sh_irda_ndo = {
-        .ndo_open               = sh_irda_open,
-        .ndo_stop               = sh_irda_stop,
-        .ndo_start_xmit         = sh_irda_hard_xmit,
-        .ndo_do_ioctl           = sh_irda_ioctl,
-        .ndo_get_stats          = sh_irda_stats,
-};
-
-/************************************************************************
-
-
-                        platform_driver function
-
-
-************************************************************************/
-static int sh_irda_probe(struct platform_device *pdev)
-{
-        struct net_device *ndev;
-        struct sh_irda_self *self;
-        struct resource *res;
-        int irq;
-        int err = -ENOMEM;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        irq = platform_get_irq(pdev, 0);
-        if (!res || irq < 0) {
-                dev_err(&pdev->dev, "Not enough platform resources.\n");
-                goto exit;
-        }
-
-        ndev = alloc_irdadev(sizeof(*self));
-        if (!ndev)
-                goto exit;
-
-        self = netdev_priv(ndev);
-        self->membase = ioremap_nocache(res->start, resource_size(res));
-        if (!self->membase) {
-                err = -ENXIO;
-                dev_err(&pdev->dev, "Unable to ioremap.\n");
-                goto err_mem_1;
-        }
-
-        err = sh_irda_init_iobuf(self, IRDA_SKB_MAX_MTU, IRDA_SIR_MAX_FRAME);
-        if (err)
-                goto err_mem_2;
-
-        self->pdev = pdev;
-        pm_runtime_enable(&pdev->dev);
-
-        irda_init_max_qos_capabilies(&self->qos);
-
-        ndev->netdev_ops        = &sh_irda_ndo;
-        ndev->irq               = irq;
-
-        self->ndev                      = ndev;
-        self->qos.baud_rate.bits        &= IR_9600; /* FIXME */
-        self->qos.min_turn_time.bits    = 1; /* 10 ms or more */
-        spin_lock_init(&self->lock);
-
-        irda_qos_bits_to_value(&self->qos);
-
-        err = register_netdev(ndev);
-        if (err)
-                goto err_mem_4;
-
-        platform_set_drvdata(pdev, ndev);
-        err = devm_request_irq(&pdev->dev, irq, sh_irda_irq, 0, "sh_irda", self);
-        if (err) {
-                dev_warn(&pdev->dev, "Unable to attach sh_irda interrupt\n");
-                goto err_mem_4;
-        }
-
-        dev_info(&pdev->dev, "SuperH IrDA probed\n");
-
-        goto exit;
-
-err_mem_4:
-        pm_runtime_disable(&pdev->dev);
-        sh_irda_remove_iobuf(self);
-err_mem_2:
-        iounmap(self->membase);
-err_mem_1:
-        free_netdev(ndev);
-exit:
-        return err;
-}
-
-static int sh_irda_remove(struct platform_device *pdev)
-{
-        struct net_device *ndev = platform_get_drvdata(pdev);
-        struct sh_irda_self *self = netdev_priv(ndev);
-
-        if (!self)
-                return 0;
-
-        unregister_netdev(ndev);
-        pm_runtime_disable(&pdev->dev);
-        sh_irda_remove_iobuf(self);
-        iounmap(self->membase);
-        free_netdev(ndev);
-
-        return 0;
-}
-
-static int sh_irda_runtime_nop(struct device *dev)
-{
-        /* Runtime PM callback shared between ->runtime_suspend()
-         * and ->runtime_resume(). Simply returns success.
-         *
-         * This driver re-initializes all registers after
-         * pm_runtime_get_sync() anyway so there is no need
-         * to save and restore registers here.
-         */
-        return 0;
-}
-
-static const struct dev_pm_ops sh_irda_pm_ops = {
-        .runtime_suspend        = sh_irda_runtime_nop,
-        .runtime_resume         = sh_irda_runtime_nop,
-};
-
-static struct platform_driver sh_irda_driver = {
-        .probe  = sh_irda_probe,
-        .remove = sh_irda_remove,
-        .driver = {
-                .name   = DRIVER_NAME,
-                .pm     = &sh_irda_pm_ops,
-        },
-};
-
-module_platform_driver(sh_irda_driver);
-
-MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
-MODULE_DESCRIPTION("SuperH IrDA driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/net/phy/at803x.c b/drivers/net/phy/at803x.c
index 1e901c7cfaac..b3ffaee30858 100644
--- a/drivers/net/phy/at803x.c
+++ b/drivers/net/phy/at803x.c
@@ -277,12 +277,16 @@ static int at803x_probe(struct phy_device *phydev)
         if (!priv)
                 return -ENOMEM;
 
-        gpiod_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+        if (phydev->drv->phy_id != ATH8030_PHY_ID)
+                goto does_not_require_reset_workaround;
+
+        gpiod_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
         if (IS_ERR(gpiod_reset))
                 return PTR_ERR(gpiod_reset);
 
         priv->gpiod_reset = gpiod_reset;
 
+does_not_require_reset_workaround:
         phydev->priv = priv;
 
         return 0;
@@ -362,10 +366,10 @@ static void at803x_link_change_notify(struct phy_device *phydev)
 
                                 at803x_context_save(phydev, &context);
 
-                                gpiod_set_value(priv->gpiod_reset, 0);
-                                msleep(1);
                                 gpiod_set_value(priv->gpiod_reset, 1);
                                 msleep(1);
+                                gpiod_set_value(priv->gpiod_reset, 0);
+                                msleep(1);
 
                                 at803x_context_restore(phydev, &context);
 
diff --git a/drivers/net/phy/bcm7xxx.c b/drivers/net/phy/bcm7xxx.c
index b881a7b1e4f6..9636da0b6efc 100644
--- a/drivers/net/phy/bcm7xxx.c
+++ b/drivers/net/phy/bcm7xxx.c
@@ -339,6 +339,8 @@ static struct phy_driver bcm7xxx_driver[] = {
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7439, "Broadcom BCM7439"),
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7439_2, "Broadcom BCM7439 (2)"),
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7445, "Broadcom BCM7445"),
+        BCM7XXX_40NM_EPHY(PHY_ID_BCM7346, "Broadcom BCM7346"),
+        BCM7XXX_40NM_EPHY(PHY_ID_BCM7362, "Broadcom BCM7362"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7425, "Broadcom BCM7425"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7429, "Broadcom BCM7429"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7435, "Broadcom BCM7435"),
@@ -348,6 +350,8 @@ static struct mdio_device_id __maybe_unused bcm7xxx_tbl[] = {
         { PHY_ID_BCM7250, 0xfffffff0, },
         { PHY_ID_BCM7364, 0xfffffff0, },
         { PHY_ID_BCM7366, 0xfffffff0, },
+        { PHY_ID_BCM7346, 0xfffffff0, },
+        { PHY_ID_BCM7362, 0xfffffff0, },
         { PHY_ID_BCM7425, 0xfffffff0, },
         { PHY_ID_BCM7429, 0xfffffff0, },
         { PHY_ID_BCM7439, 0xfffffff0, },
diff --git a/drivers/net/phy/mdio-sun4i.c b/drivers/net/phy/mdio-sun4i.c
index f70522c35163..135296508a7e 100644
--- a/drivers/net/phy/mdio-sun4i.c
+++ b/drivers/net/phy/mdio-sun4i.c
@@ -122,6 +122,7 @@ static int sun4i_mdio_probe(struct platform_device *pdev)
                         return -EPROBE_DEFER;
 
                 dev_info(&pdev->dev, "no regulator found\n");
+                data->regulator = NULL;
         } else {
                 ret = regulator_enable(data->regulator);
                 if (ret)
@@ -137,7 +138,8 @@ static int sun4i_mdio_probe(struct platform_device *pdev)
         return 0;
 
 err_out_disable_regulator:
-        regulator_disable(data->regulator);
+        if (data->regulator)
+                regulator_disable(data->regulator);
 err_out_free_mdiobus:
         mdiobus_free(bus);
         return ret;
diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c
index 4fd861063ed4..f572b31a2b20 100644
--- a/drivers/net/ppp/ppp_generic.c
+++ b/drivers/net/ppp/ppp_generic.c
@@ -2307,7 +2307,7 @@ int ppp_register_net_channel(struct net *net, struct ppp_channel *chan)
 
         pch->ppp = NULL;
         pch->chan = chan;
-        pch->chan_net = net;
+        pch->chan_net = get_net(net);
         chan->ppp = pch;
         init_ppp_file(&pch->file, CHANNEL);
         pch->file.hdrlen = chan->hdrlen;
@@ -2404,6 +2404,8 @@ ppp_unregister_channel(struct ppp_channel *chan)
         spin_lock_bh(&pn->all_channels_lock);
         list_del(&pch->list);
         spin_unlock_bh(&pn->all_channels_lock);
+        put_net(pch->chan_net);
+        pch->chan_net = NULL;
 
         pch->file.dead = 1;
         wake_up_interruptible(&pch->file.rwait);
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index 01f08a7751f7..9cfe6aeac84e 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -24,6 +24,7 @@
 #include <linux/skbuff.h>
 #include <linux/crc32.h>
 #include <linux/ethtool.h>
+#include <linux/reboot.h>
 
 #define DRV_NAME        "rionet"
 #define DRV_VERSION     "0.3"
@@ -48,6 +49,8 @@ MODULE_LICENSE("GPL");
 #define RIONET_TX_RING_SIZE     CONFIG_RIONET_TX_SIZE
 #define RIONET_RX_RING_SIZE     CONFIG_RIONET_RX_SIZE
 #define RIONET_MAX_NETS         8
+#define RIONET_MSG_SIZE         RIO_MAX_MSG_SIZE
+#define RIONET_MAX_MTU          (RIONET_MSG_SIZE - ETH_HLEN)
 
 struct rionet_private {
         struct rio_mport *mport;
@@ -60,6 +63,7 @@ struct rionet_private {
         spinlock_t lock;
         spinlock_t tx_lock;
         u32 msg_enable;
+        bool open;
 };
 
 struct rionet_peer {
@@ -71,6 +75,7 @@ struct rionet_peer {
 struct rionet_net {
         struct net_device *ndev;
         struct list_head peers;
+        spinlock_t lock;        /* net info access lock */
         struct rio_dev **active;
         int nact;       /* number of active peers */
 };
@@ -232,26 +237,32 @@ static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u
         struct net_device *ndev = dev_id;
         struct rionet_private *rnet = netdev_priv(ndev);
         struct rionet_peer *peer;
+        unsigned char netid = rnet->mport->id;
 
         if (netif_msg_intr(rnet))
                 printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x",
                        DRV_NAME, sid, tid, info);
         if (info == RIONET_DOORBELL_JOIN) {
-                if (!nets[rnet->mport->id].active[sid]) {
-                        list_for_each_entry(peer,
-                                           &nets[rnet->mport->id].peers, node) {
+                if (!nets[netid].active[sid]) {
+                        spin_lock(&nets[netid].lock);
+                        list_for_each_entry(peer, &nets[netid].peers, node) {
                                 if (peer->rdev->destid == sid) {
-                                        nets[rnet->mport->id].active[sid] =
-                                                                peer->rdev;
-                                        nets[rnet->mport->id].nact++;
+                                        nets[netid].active[sid] = peer->rdev;
+                                        nets[netid].nact++;
                                 }
                         }
+                        spin_unlock(&nets[netid].lock);
+
                         rio_mport_send_doorbell(mport, sid,
                                                 RIONET_DOORBELL_JOIN);
                 }
         } else if (info == RIONET_DOORBELL_LEAVE) {
-                nets[rnet->mport->id].active[sid] = NULL;
-                nets[rnet->mport->id].nact--;
+                spin_lock(&nets[netid].lock);
+                if (nets[netid].active[sid]) {
+                        nets[netid].active[sid] = NULL;
+                        nets[netid].nact--;
+                }
+                spin_unlock(&nets[netid].lock);
         } else {
                 if (netif_msg_intr(rnet))
                         printk(KERN_WARNING "%s: unhandled doorbell\n",
@@ -280,7 +291,7 @@ static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbo
         struct net_device *ndev = dev_id;
         struct rionet_private *rnet = netdev_priv(ndev);
 
-        spin_lock(&rnet->lock);
+        spin_lock(&rnet->tx_lock);
 
         if (netif_msg_intr(rnet))
                 printk(KERN_INFO
@@ -299,14 +310,16 @@ static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbo
         if (rnet->tx_cnt < RIONET_TX_RING_SIZE)
                 netif_wake_queue(ndev);
 
-        spin_unlock(&rnet->lock);
+        spin_unlock(&rnet->tx_lock);
 }
 
 static int rionet_open(struct net_device *ndev)
 {
         int i, rc = 0;
-        struct rionet_peer *peer, *tmp;
+        struct rionet_peer *peer;
         struct rionet_private *rnet = netdev_priv(ndev);
+        unsigned char netid = rnet->mport->id;
+        unsigned long flags;
 
         if (netif_msg_ifup(rnet))
                 printk(KERN_INFO "%s: open\n", DRV_NAME);
@@ -345,20 +358,13 @@ static int rionet_open(struct net_device *ndev)
         netif_carrier_on(ndev);
         netif_start_queue(ndev);
 
-        list_for_each_entry_safe(peer, tmp,
-                                 &nets[rnet->mport->id].peers, node) {
-                if (!(peer->res = rio_request_outb_dbell(peer->rdev,
-                                                         RIONET_DOORBELL_JOIN,
-                                                         RIONET_DOORBELL_LEAVE)))
-                {
-                        printk(KERN_ERR "%s: error requesting doorbells\n",
-                               DRV_NAME);
-                        continue;
-                }
-
+        spin_lock_irqsave(&nets[netid].lock, flags);
+        list_for_each_entry(peer, &nets[netid].peers, node) {
                 /* Send a join message */
                 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
         }
+        spin_unlock_irqrestore(&nets[netid].lock, flags);
+        rnet->open = true;
 
       out:
         return rc;
@@ -367,7 +373,9 @@ static int rionet_open(struct net_device *ndev)
 static int rionet_close(struct net_device *ndev)
 {
         struct rionet_private *rnet = netdev_priv(ndev);
-        struct rionet_peer *peer, *tmp;
+        struct rionet_peer *peer;
+        unsigned char netid = rnet->mport->id;
+        unsigned long flags;
         int i;
 
         if (netif_msg_ifup(rnet))
@@ -375,18 +383,21 @@ static int rionet_close(struct net_device *ndev)
 
         netif_stop_queue(ndev);
         netif_carrier_off(ndev);
+        rnet->open = false;
 
         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
                 kfree_skb(rnet->rx_skb[i]);
 
-        list_for_each_entry_safe(peer, tmp,
-                                 &nets[rnet->mport->id].peers, node) {
-                if (nets[rnet->mport->id].active[peer->rdev->destid]) {
+        spin_lock_irqsave(&nets[netid].lock, flags);
+        list_for_each_entry(peer, &nets[netid].peers, node) {
+                if (nets[netid].active[peer->rdev->destid]) {
                         rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE);
-                        nets[rnet->mport->id].active[peer->rdev->destid] = NULL;
+                        nets[netid].active[peer->rdev->destid] = NULL;
                 }
-                rio_release_outb_dbell(peer->rdev, peer->res);
+                if (peer->res)
+                        rio_release_outb_dbell(peer->rdev, peer->res);
         }
+        spin_unlock_irqrestore(&nets[netid].lock, flags);
 
         rio_release_inb_dbell(rnet->mport, RIONET_DOORBELL_JOIN,
                               RIONET_DOORBELL_LEAVE);
@@ -400,22 +411,38 @@ static void rionet_remove_dev(struct device *dev, struct subsys_interface *sif)
 {
         struct rio_dev *rdev = to_rio_dev(dev);
         unsigned char netid = rdev->net->hport->id;
-        struct rionet_peer *peer, *tmp;
+        struct rionet_peer *peer;
+        int state, found = 0;
+        unsigned long flags;
 
-        if (dev_rionet_capable(rdev)) {
-                list_for_each_entry_safe(peer, tmp, &nets[netid].peers, node) {
-                        if (peer->rdev == rdev) {
-                                if (nets[netid].active[rdev->destid]) {
-                                        nets[netid].active[rdev->destid] = NULL;
-                                        nets[netid].nact--;
+        if (!dev_rionet_capable(rdev))
+                return;
+
+        spin_lock_irqsave(&nets[netid].lock, flags);
+        list_for_each_entry(peer, &nets[netid].peers, node) {
+                if (peer->rdev == rdev) {
+                        list_del(&peer->node);
+                        if (nets[netid].active[rdev->destid]) {
+                                state = atomic_read(&rdev->state);
+                                if (state != RIO_DEVICE_GONE &&
+                                    state != RIO_DEVICE_INITIALIZING) {
+                                        rio_send_doorbell(rdev,
+                                                        RIONET_DOORBELL_LEAVE);
                                 }
-
-                                list_del(&peer->node);
-                                kfree(peer);
-                                break;
+                                nets[netid].active[rdev->destid] = NULL;
+                                nets[netid].nact--;
                         }
+                        found = 1;
+                        break;
                 }
         }
+        spin_unlock_irqrestore(&nets[netid].lock, flags);
+
+        if (found) {
+                if (peer->res)
+                        rio_release_outb_dbell(rdev, peer->res);
+                kfree(peer);
+        }
 }
 
 static void rionet_get_drvinfo(struct net_device *ndev,
@@ -443,6 +470,17 @@ static void rionet_set_msglevel(struct net_device *ndev, u32 value)
         rnet->msg_enable = value;
 }
 
+static int rionet_change_mtu(struct net_device *ndev, int new_mtu)
+{
+        if ((new_mtu < 68) || (new_mtu > RIONET_MAX_MTU)) {
+                printk(KERN_ERR "%s: Invalid MTU size %d\n",
+                       ndev->name, new_mtu);
+                return -EINVAL;
+        }
+        ndev->mtu = new_mtu;
+        return 0;
+}
+
 static const struct ethtool_ops rionet_ethtool_ops = {
         .get_drvinfo = rionet_get_drvinfo,
         .get_msglevel = rionet_get_msglevel,
@@ -454,7 +492,7 @@ static const struct net_device_ops rionet_netdev_ops = {
         .ndo_open               = rionet_open,
         .ndo_stop               = rionet_close,
         .ndo_start_xmit         = rionet_start_xmit,
-        .ndo_change_mtu         = eth_change_mtu,
+        .ndo_change_mtu         = rionet_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_mac_address    = eth_mac_addr,
 };
@@ -478,6 +516,7 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         /* Set up private area */
         rnet = netdev_priv(ndev);
         rnet->mport = mport;
+        rnet->open = false;
 
         /* Set the default MAC address */
         device_id = rio_local_get_device_id(mport);
@@ -489,7 +528,7 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         ndev->dev_addr[5] = device_id & 0xff;
 
         ndev->netdev_ops = &rionet_netdev_ops;
-        ndev->mtu = RIO_MAX_MSG_SIZE - 14;
+        ndev->mtu = RIONET_MAX_MTU;
         ndev->features = NETIF_F_LLTX;
         SET_NETDEV_DEV(ndev, &mport->dev);
         ndev->ethtool_ops = &rionet_ethtool_ops;
@@ -500,8 +539,11 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL;
 
         rc = register_netdev(ndev);
-        if (rc != 0)
+        if (rc != 0) {
+                free_pages((unsigned long)nets[mport->id].active,
+                           get_order(rionet_active_bytes));
                 goto out;
+        }
 
         printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n",
                ndev->name,
@@ -515,8 +557,6 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         return rc;
 }
 
-static unsigned long net_table[RIONET_MAX_NETS/sizeof(unsigned long) + 1];
-
 static int rionet_add_dev(struct device *dev, struct subsys_interface *sif)
 {
         int rc = -ENODEV;
@@ -525,19 +565,16 @@ static int rionet_add_dev(struct device *dev, struct subsys_interface *sif)
         struct net_device *ndev = NULL;
         struct rio_dev *rdev = to_rio_dev(dev);
         unsigned char netid = rdev->net->hport->id;
-        int oldnet;
 
         if (netid >= RIONET_MAX_NETS)
                 return rc;
 
-        oldnet = test_and_set_bit(netid, net_table);
-
         /*
          * If first time through this net, make sure local device is rionet
          * capable and setup netdev (this step will be skipped in later probes
          * on the same net).
          */
-        if (!oldnet) {
+        if (!nets[netid].ndev) {
                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
                                          &lsrc_ops);
                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
@@ -555,30 +592,56 @@ static int rionet_add_dev(struct device *dev, struct subsys_interface *sif)
                         rc = -ENOMEM;
                         goto out;
                 }
-                nets[netid].ndev = ndev;
+
                 rc = rionet_setup_netdev(rdev->net->hport, ndev);
                 if (rc) {
                         printk(KERN_ERR "%s: failed to setup netdev (rc=%d)\n",
                                DRV_NAME, rc);
+                        free_netdev(ndev);
                         goto out;
                 }
 
                 INIT_LIST_HEAD(&nets[netid].peers);
+                spin_lock_init(&nets[netid].lock);
                 nets[netid].nact = 0;
-        } else if (nets[netid].ndev == NULL)
-                goto out;
+                nets[netid].ndev = ndev;
+        }
 
         /*
          * If the remote device has mailbox/doorbell capabilities,
          * add it to the peer list.
          */
         if (dev_rionet_capable(rdev)) {
-                if (!(peer = kmalloc(sizeof(struct rionet_peer), GFP_KERNEL))) {
+                struct rionet_private *rnet;
+                unsigned long flags;
+
+                rnet = netdev_priv(nets[netid].ndev);
+
+                peer = kzalloc(sizeof(*peer), GFP_KERNEL);
+                if (!peer) {
                         rc = -ENOMEM;
                         goto out;
                 }
                 peer->rdev = rdev;
+                peer->res = rio_request_outb_dbell(peer->rdev,
+                                                RIONET_DOORBELL_JOIN,
+                                                RIONET_DOORBELL_LEAVE);
+                if (!peer->res) {
+                        pr_err("%s: error requesting doorbells\n", DRV_NAME);
+                        kfree(peer);
+                        rc = -ENOMEM;
+                        goto out;
+                }
+
+                spin_lock_irqsave(&nets[netid].lock, flags);
                 list_add_tail(&peer->node, &nets[netid].peers);
+                spin_unlock_irqrestore(&nets[netid].lock, flags);
+                pr_debug("%s: %s add peer %s\n",
+                         DRV_NAME, __func__, rio_name(rdev));
+
+                /* If netdev is already opened, send join request to new peer */
+                if (rnet->open)
+                        rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
         }
 
         return 0;
@@ -586,6 +649,61 @@ out:
         return rc;
 }
 
+static int rionet_shutdown(struct notifier_block *nb, unsigned long code,
+                           void *unused)
+{
+        struct rionet_peer *peer;
+        unsigned long flags;
+        int i;
+
+        pr_debug("%s: %s\n", DRV_NAME, __func__);
+
+        for (i = 0; i < RIONET_MAX_NETS; i++) {
+                if (!nets[i].ndev)
+                        continue;
+
+                spin_lock_irqsave(&nets[i].lock, flags);
+                list_for_each_entry(peer, &nets[i].peers, node) {
+                        if (nets[i].active[peer->rdev->destid]) {
+                                rio_send_doorbell(peer->rdev,
+                                                  RIONET_DOORBELL_LEAVE);
+                                nets[i].active[peer->rdev->destid] = NULL;
+                        }
+                }
+                spin_unlock_irqrestore(&nets[i].lock, flags);
+        }
+
+        return NOTIFY_DONE;
+}
+
+static void rionet_remove_mport(struct device *dev,
+                                struct class_interface *class_intf)
+{
+        struct rio_mport *mport = to_rio_mport(dev);
+        struct net_device *ndev;
+        int id = mport->id;
+
+        pr_debug("%s %s\n", __func__, mport->name);
+
+        WARN(nets[id].nact, "%s called when connected to %d peers\n",
+             __func__, nets[id].nact);
+        WARN(!nets[id].ndev, "%s called for mport without NDEV\n",
+             __func__);
+
+        if (nets[id].ndev) {
+                ndev = nets[id].ndev;
+                netif_stop_queue(ndev);
+                unregister_netdev(ndev);
+
+                free_pages((unsigned long)nets[id].active,
+                           get_order(sizeof(void *) *
+                           RIO_MAX_ROUTE_ENTRIES(mport->sys_size)));
+                nets[id].active = NULL;
+                free_netdev(ndev);
+                nets[id].ndev = NULL;
+        }
+}
+
 #ifdef MODULE
 static struct rio_device_id rionet_id_table[] = {
         {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)},
@@ -602,40 +720,43 @@ static struct subsys_interface rionet_interface = {
         .remove_dev     = rionet_remove_dev,
 };
 
+static struct notifier_block rionet_notifier = {
+        .notifier_call = rionet_shutdown,
+};
+
+/* the rio_mport_interface is used to handle local mport devices */
+static struct class_interface rio_mport_interface __refdata = {
+        .class = &rio_mport_class,
+        .add_dev = NULL,
+        .remove_dev = rionet_remove_mport,
+};
+
 static int __init rionet_init(void)
 {
+        int ret;
+
+        ret = register_reboot_notifier(&rionet_notifier);
+        if (ret) {
+                pr_err("%s: failed to register reboot notifier (err=%d)\n",
+                       DRV_NAME, ret);
+                return ret;
+        }
+
+        ret = class_interface_register(&rio_mport_interface);
+        if (ret) {
+                pr_err("%s: class_interface_register error: %d\n",
+                       DRV_NAME, ret);
+                return ret;
+        }
+
         return subsys_interface_register(&rionet_interface);
 }
 
 static void __exit rionet_exit(void)
 {
-        struct rionet_private *rnet;
-        struct net_device *ndev;
-        struct rionet_peer *peer, *tmp;
-        int i;
-
-        for (i = 0; i < RIONET_MAX_NETS; i++) {
-                if (nets[i].ndev != NULL) {
-                        ndev = nets[i].ndev;
-                        rnet = netdev_priv(ndev);
-                        unregister_netdev(ndev);
-
-                        list_for_each_entry_safe(peer,
-                                                 tmp, &nets[i].peers, node) {
-                                list_del(&peer->node);
-                                kfree(peer);
-                        }
-
-                        free_pages((unsigned long)nets[i].active,
-                                 get_order(sizeof(void *) *
-                                 RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size)));
-                        nets[i].active = NULL;
-
-                        free_netdev(ndev);
-                }
-        }
-
+        unregister_reboot_notifier(&rionet_notifier);
         subsys_interface_unregister(&rionet_interface);
+        class_interface_unregister(&rio_mport_interface);
 }
 
 late_initcall(rionet_init);
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 26c64d2782fa..a0f64cba86ba 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -1198,6 +1198,9 @@ static int team_port_add(struct team *team, struct net_device *port_dev)
                 goto err_dev_open;
         }
 
+        dev_uc_sync_multiple(port_dev, dev);
+        dev_mc_sync_multiple(port_dev, dev);
+
         err = vlan_vids_add_by_dev(port_dev, dev);
         if (err) {
                 netdev_err(dev, "Failed to add vlan ids to device %s\n",
@@ -1261,6 +1264,8 @@ err_enable_netpoll:
         vlan_vids_del_by_dev(port_dev, dev);
 
 err_vids_add:
+        dev_uc_unsync(port_dev, dev);
+        dev_mc_unsync(port_dev, dev);
         dev_close(port_dev);
 
 err_dev_open:
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index afdf950617c3..a74661690a11 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -622,7 +622,9 @@ static int tun_attach(struct tun_struct *tun, struct file *file, bool skip_filte
 
         /* Re-attach the filter to persist device */
         if (!skip_filter && (tun->filter_attached == true)) {
+                lock_sock(tfile->socket.sk);
                 err = sk_attach_filter(&tun->fprog, tfile->socket.sk);
+                release_sock(tfile->socket.sk);
                 if (!err)
                         goto out;
         }
@@ -860,7 +862,8 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto drop;
 
         if (skb->sk && sk_fullsock(skb->sk)) {
-                sock_tx_timestamp(skb->sk, &skb_shinfo(skb)->tx_flags);
+                sock_tx_timestamp(skb->sk, skb->sk->sk_tsflags,
+                                  &skb_shinfo(skb)->tx_flags);
                 sw_tx_timestamp(skb);
         }
 
@@ -1014,7 +1017,6 @@ static void tun_net_init(struct net_device *dev)
                 /* Zero header length */
                 dev->type = ARPHRD_NONE;
                 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
-                dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                 break;
 
         case IFF_TAP:
@@ -1026,7 +1028,6 @@ static void tun_net_init(struct net_device *dev)
 
                 eth_hw_addr_random(dev);
 
-                dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                 break;
         }
 }
@@ -1480,6 +1481,8 @@ static void tun_setup(struct net_device *dev)
 
         dev->ethtool_ops = &tun_ethtool_ops;
         dev->destructor = tun_free_netdev;
+        /* We prefer our own queue length */
+        dev->tx_queue_len = TUN_READQ_SIZE;
 }
 
 /* Trivial set of netlink ops to allow deleting tun or tap
@@ -1822,7 +1825,9 @@ static void tun_detach_filter(struct tun_struct *tun, int n)
 
         for (i = 0; i < n; i++) {
                 tfile = rtnl_dereference(tun->tfiles[i]);
+                lock_sock(tfile->socket.sk);
                 sk_detach_filter(tfile->socket.sk);
+                release_sock(tfile->socket.sk);
         }
 
         tun->filter_attached = false;
@@ -1835,7 +1840,9 @@ static int tun_attach_filter(struct tun_struct *tun)
 
         for (i = 0; i < tun->numqueues; i++) {
                 tfile = rtnl_dereference(tun->tfiles[i]);
+                lock_sock(tfile->socket.sk);
                 ret = sk_attach_filter(&tun->fprog, tfile->socket.sk);
+                release_sock(tfile->socket.sk);
                 if (ret) {
                         tun_detach_filter(tun, i);
                         return ret;
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 86ba30ba35e8..2fb31edab125 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -1626,6 +1626,13 @@ static const struct usb_device_id cdc_devs[] = {
           .driver_info = (unsigned long) &wwan_info,
         },
 
+        /* Telit LE910 V2 */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x1bc7, 0x0036,
+                USB_CLASS_COMM,
+                USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
+          .driver_info = (unsigned long)&wwan_noarp_info,
+        },
+
         /* DW5812 LTE Verizon Mobile Broadband Card
          * Unlike DW5550 this device requires FLAG_NOARP
          */
diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c
index d36d5ebf37f3..f20890ee03f3 100644
--- a/drivers/net/usb/lan78xx.c
+++ b/drivers/net/usb/lan78xx.c
@@ -3261,54 +3261,6 @@ void lan78xx_tx_timeout(struct net_device *net)
         tasklet_schedule(&dev->bh);
 }
 
-struct rtnl_link_stats64 *lan78xx_get_stats64(struct net_device *netdev,
-                                              struct rtnl_link_stats64 *storage)
-{
-        struct lan78xx_net *dev = netdev_priv(netdev);
-        struct lan78xx_statstage64 stats;
-
-        /* curr_stat is updated by timer.
-         * periodic reading from HW will prevent from entering USB auto suspend.
-         * if autosuspend is disabled, read from HW.
-         */
-        if (!dev->udev->dev.power.runtime_auto)
-                lan78xx_update_stats(dev);
-
-        mutex_lock(&dev->stats.access_lock);
-        memcpy(&stats, &dev->stats.curr_stat, sizeof(stats));
-        mutex_unlock(&dev->stats.access_lock);
-
-        /* calc by driver */
-        storage->rx_packets = (__u64)netdev->stats.rx_packets;
-        storage->tx_packets = (__u64)netdev->stats.tx_packets;
-        storage->rx_bytes = (__u64)netdev->stats.rx_bytes;
-        storage->tx_bytes = (__u64)netdev->stats.tx_bytes;
-
-        /* use counter */
-        storage->rx_length_errors = stats.rx_undersize_frame_errors +
-                                    stats.rx_oversize_frame_errors;
-        storage->rx_crc_errors = stats.rx_fcs_errors;
-        storage->rx_frame_errors = stats.rx_alignment_errors;
-        storage->rx_fifo_errors = stats.rx_dropped_frames;
-        storage->rx_over_errors = stats.rx_oversize_frame_errors;
-        storage->rx_errors = stats.rx_fcs_errors +
-                             stats.rx_alignment_errors +
-                             stats.rx_fragment_errors +
-                             stats.rx_jabber_errors +
-                             stats.rx_undersize_frame_errors +
-                             stats.rx_oversize_frame_errors +
-                             stats.rx_dropped_frames;
-
-        storage->tx_carrier_errors = stats.tx_carrier_errors;
-        storage->tx_errors = stats.tx_fcs_errors +
-                             stats.tx_excess_deferral_errors +
-                             stats.tx_carrier_errors;
-
-        storage->multicast = stats.rx_multicast_frames;
-
-        return storage;
-}
-
 static const struct net_device_ops lan78xx_netdev_ops = {
         .ndo_open               = lan78xx_open,
         .ndo_stop               = lan78xx_stop,
@@ -3322,7 +3274,6 @@ static const struct net_device_ops lan78xx_netdev_ops = {
         .ndo_set_features       = lan78xx_set_features,
         .ndo_vlan_rx_add_vid    = lan78xx_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = lan78xx_vlan_rx_kill_vid,
-        .ndo_get_stats64        = lan78xx_get_stats64,
 };
 
 static void lan78xx_stat_monitor(unsigned long param)
diff --git a/drivers/net/usb/plusb.c b/drivers/net/usb/plusb.c
index 1bfe0fcaccf5..22e1a9a99a7d 100644
--- a/drivers/net/usb/plusb.c
+++ b/drivers/net/usb/plusb.c
@@ -38,7 +38,7 @@
  * HEADS UP:  this handshaking isn't all that robust.  This driver
  * gets confused easily if you unplug one end of the cable then
  * try to connect it again; you'll need to restart both ends. The
- * "naplink" software (used by some PlayStation/2 deveopers) does
+ * "naplink" software (used by some PlayStation/2 developers) does
  * the handshaking much better!   Also, sometimes this hardware
  * seems to get wedged under load.  Prolific docs are weak, and
  * don't identify differences between PL2301 and PL2302, much less
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 7d717c66bcb0..9d1fce8a6e84 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -844,6 +844,7 @@ static const struct usb_device_id products[] = {
         {QMI_FIXED_INTF(0x19d2, 0x1426, 2)},    /* ZTE MF91 */
         {QMI_FIXED_INTF(0x19d2, 0x1428, 2)},    /* Telewell TW-LTE 4G v2 */
         {QMI_FIXED_INTF(0x19d2, 0x2002, 4)},    /* ZTE (Vodafone) K3765-Z */
+        {QMI_FIXED_INTF(0x2001, 0x7e19, 4)},    /* D-Link DWM-221 B1 */
         {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)},    /* Sierra Wireless MC7700 */
         {QMI_FIXED_INTF(0x114f, 0x68a2, 8)},    /* Sierra Wireless MC7750 */
         {QMI_FIXED_INTF(0x1199, 0x68a2, 8)},    /* Sierra Wireless MC7710 in QMI mode */
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index fb0eae42bf39..49d84e540343 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -260,7 +260,7 @@ static struct sk_buff *page_to_skb(struct virtnet_info *vi,
         p = page_address(page) + offset;
 
         /* copy small packet so we can reuse these pages for small data */
-        skb = netdev_alloc_skb_ip_align(vi->dev, GOOD_COPY_LEN);
+        skb = napi_alloc_skb(&rq->napi, GOOD_COPY_LEN);
         if (unlikely(!skb))
                 return NULL;
 
diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
index 800106a7246c..9f3634064c92 100644
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@ -551,16 +551,15 @@ static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,
         return vh;
 }
 
-static struct sk_buff **vxlan_gro_receive(struct sk_buff **head,
-                                          struct sk_buff *skb,
-                                          struct udp_offload *uoff)
+static struct sk_buff **vxlan_gro_receive(struct sock *sk,
+                                          struct sk_buff **head,
+                                          struct sk_buff *skb)
 {
         struct sk_buff *p, **pp = NULL;
         struct vxlanhdr *vh, *vh2;
         unsigned int hlen, off_vx;
         int flush = 1;
-        struct vxlan_sock *vs = container_of(uoff, struct vxlan_sock,
-                                             udp_offloads);
+        struct vxlan_sock *vs = rcu_dereference_sk_user_data(sk);
         __be32 flags;
         struct gro_remcsum grc;
 
@@ -613,8 +612,7 @@ out:
         return pp;
 }
 
-static int vxlan_gro_complete(struct sk_buff *skb, int nhoff,
-                              struct udp_offload *uoff)
+static int vxlan_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
 {
         udp_tunnel_gro_complete(skb, nhoff);
 
@@ -629,13 +627,6 @@ static void vxlan_notify_add_rx_port(struct vxlan_sock *vs)
         struct net *net = sock_net(sk);
         sa_family_t sa_family = vxlan_get_sk_family(vs);
         __be16 port = inet_sk(sk)->inet_sport;
-        int err;
-
-        if (sa_family == AF_INET) {
-                err = udp_add_offload(net, &vs->udp_offloads);
-                if (err)
-                        pr_warn("vxlan: udp_add_offload failed with status %d\n", err);
-        }
 
         rcu_read_lock();
         for_each_netdev_rcu(net, dev) {
@@ -662,9 +653,6 @@ static void vxlan_notify_del_rx_port(struct vxlan_sock *vs)
                                                             port);
         }
         rcu_read_unlock();
-
-        if (sa_family == AF_INET)
-                udp_del_offload(&vs->udp_offloads);
 }
 
 /* Add new entry to forwarding table -- assumes lock held */
@@ -1143,7 +1131,7 @@ static int vxlan_igmp_leave(struct vxlan_dev *vxlan)
 static bool vxlan_remcsum(struct vxlanhdr *unparsed,
                           struct sk_buff *skb, u32 vxflags)
 {
-        size_t start, offset, plen;
+        size_t start, offset;
 
         if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)
                 goto out;
@@ -1151,9 +1139,7 @@ static bool vxlan_remcsum(struct vxlanhdr *unparsed,
         start = vxlan_rco_start(unparsed->vx_vni);
         offset = start + vxlan_rco_offset(unparsed->vx_vni);
 
-        plen = sizeof(struct vxlanhdr) + offset + sizeof(u16);
-
-        if (!pskb_may_pull(skb, plen))
+        if (!pskb_may_pull(skb, offset + sizeof(u16)))
                 return false;
 
         skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,
@@ -1194,6 +1180,45 @@ out:
         unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;
 }
 
+static bool vxlan_parse_gpe_hdr(struct vxlanhdr *unparsed,
+                                __be32 *protocol,
+                                struct sk_buff *skb, u32 vxflags)
+{
+        struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)unparsed;
+
+        /* Need to have Next Protocol set for interfaces in GPE mode. */
+        if (!gpe->np_applied)
+                return false;
+        /* "The initial version is 0. If a receiver does not support the
+         * version indicated it MUST drop the packet.
+         */
+        if (gpe->version != 0)
+                return false;
+        /* "When the O bit is set to 1, the packet is an OAM packet and OAM
+         * processing MUST occur." However, we don't implement OAM
+         * processing, thus drop the packet.
+         */
+        if (gpe->oam_flag)
+                return false;
+
+        switch (gpe->next_protocol) {
+        case VXLAN_GPE_NP_IPV4:
+                *protocol = htons(ETH_P_IP);
+                break;
+        case VXLAN_GPE_NP_IPV6:
+                *protocol = htons(ETH_P_IPV6);
+                break;
+        case VXLAN_GPE_NP_ETHERNET:
+                *protocol = htons(ETH_P_TEB);
+                break;
+        default:
+                return false;
+        }
+
+        unparsed->vx_flags &= ~VXLAN_GPE_USED_BITS;
+        return true;
+}
+
 static bool vxlan_set_mac(struct vxlan_dev *vxlan,
                           struct vxlan_sock *vs,
                           struct sk_buff *skb)
@@ -1259,9 +1284,11 @@ static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
         struct vxlanhdr unparsed;
         struct vxlan_metadata _md;
         struct vxlan_metadata *md = &_md;
+        __be32 protocol = htons(ETH_P_TEB);
+        bool raw_proto = false;
         void *oiph;
 
-        /* Need Vxlan and inner Ethernet header to be present */
+        /* Need UDP and VXLAN header to be present */
         if (!pskb_may_pull(skb, VXLAN_HLEN))
                 return 1;
 
@@ -1285,9 +1312,18 @@ static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
         if (!vxlan)
                 goto drop;
 
-        if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB),
-                                 !net_eq(vxlan->net, dev_net(vxlan->dev))))
-                goto drop;
+        /* For backwards compatibility, only allow reserved fields to be
+         * used by VXLAN extensions if explicitly requested.
+         */
+        if (vs->flags & VXLAN_F_GPE) {
+                if (!vxlan_parse_gpe_hdr(&unparsed, &protocol, skb, vs->flags))
+                        goto drop;
+                raw_proto = true;
+        }
+
+        if (__iptunnel_pull_header(skb, VXLAN_HLEN, protocol, raw_proto,
+                                   !net_eq(vxlan->net, dev_net(vxlan->dev))))
+                        goto drop;
 
         if (vxlan_collect_metadata(vs)) {
                 __be32 vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);
@@ -1306,14 +1342,14 @@ static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
                 memset(md, 0, sizeof(*md));
         }
 
-        /* For backwards compatibility, only allow reserved fields to be
-         * used by VXLAN extensions if explicitly requested.
-         */
         if (vs->flags & VXLAN_F_REMCSUM_RX)
                 if (!vxlan_remcsum(&unparsed, skb, vs->flags))
                         goto drop;
         if (vs->flags & VXLAN_F_GBP)
                 vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);
+        /* Note that GBP and GPE can never be active together. This is
+         * ensured in vxlan_dev_configure.
+         */
 
         if (unparsed.vx_flags || unparsed.vx_vni) {
                 /* If there are any unprocessed flags remaining treat
@@ -1327,8 +1363,13 @@ static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
                 goto drop;
         }
 
-        if (!vxlan_set_mac(vxlan, vs, skb))
-                goto drop;
+        if (!raw_proto) {
+                if (!vxlan_set_mac(vxlan, vs, skb))
+                        goto drop;
+        } else {
+                skb->dev = vxlan->dev;
+                skb->pkt_type = PACKET_HOST;
+        }
 
         oiph = skb_network_header(skb);
         skb_reset_network_header(skb);
@@ -1687,6 +1728,27 @@ static void vxlan_build_gbp_hdr(struct vxlanhdr *vxh, u32 vxflags,
         gbp->policy_id = htons(md->gbp & VXLAN_GBP_ID_MASK);
 }
 
+static int vxlan_build_gpe_hdr(struct vxlanhdr *vxh, u32 vxflags,
+                               __be16 protocol)
+{
+        struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)vxh;
+
+        gpe->np_applied = 1;
+
+        switch (protocol) {
+        case htons(ETH_P_IP):
+                gpe->next_protocol = VXLAN_GPE_NP_IPV4;
+                return 0;
+        case htons(ETH_P_IPV6):
+                gpe->next_protocol = VXLAN_GPE_NP_IPV6;
+                return 0;
+        case htons(ETH_P_TEB):
+                gpe->next_protocol = VXLAN_GPE_NP_ETHERNET;
+                return 0;
+        }
+        return -EPFNOSUPPORT;
+}
+
 static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
                            int iphdr_len, __be32 vni,
                            struct vxlan_metadata *md, u32 vxflags,
@@ -1696,6 +1758,7 @@ static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
         int min_headroom;
         int err;
         int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
+        __be16 inner_protocol = htons(ETH_P_TEB);
 
         if ((vxflags & VXLAN_F_REMCSUM_TX) &&
             skb->ip_summed == CHECKSUM_PARTIAL) {
@@ -1714,10 +1777,8 @@ static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
 
         /* Need space for new headers (invalidates iph ptr) */
         err = skb_cow_head(skb, min_headroom);
-        if (unlikely(err)) {
-                kfree_skb(skb);
-                return err;
-        }
+        if (unlikely(err))
+                goto out_free;
 
         skb = vlan_hwaccel_push_inside(skb);
         if (WARN_ON(!skb))
@@ -1746,9 +1807,19 @@ static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
 
         if (vxflags & VXLAN_F_GBP)
                 vxlan_build_gbp_hdr(vxh, vxflags, md);
+        if (vxflags & VXLAN_F_GPE) {
+                err = vxlan_build_gpe_hdr(vxh, vxflags, skb->protocol);
+                if (err < 0)
+                        goto out_free;
+                inner_protocol = skb->protocol;
+        }
 
-        skb_set_inner_protocol(skb, htons(ETH_P_TEB));
+        skb_set_inner_protocol(skb, inner_protocol);
         return 0;
+
+out_free:
+        kfree_skb(skb);
+        return err;
 }
 
 static struct rtable *vxlan_get_route(struct vxlan_dev *vxlan,
@@ -1810,10 +1881,9 @@ static struct dst_entry *vxlan6_get_route(struct vxlan_dev *vxlan,
 
         memset(&fl6, 0, sizeof(fl6));
         fl6.flowi6_oif = oif;
-        fl6.flowi6_tos = RT_TOS(tos);
         fl6.daddr = *daddr;
         fl6.saddr = vxlan->cfg.saddr.sin6.sin6_addr;
-        fl6.flowlabel = label;
+        fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tos), label);
         fl6.flowi6_mark = skb->mark;
         fl6.flowi6_proto = IPPROTO_UDP;
 
@@ -2109,9 +2179,17 @@ static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
         info = skb_tunnel_info(skb);
 
         skb_reset_mac_header(skb);
-        eth = eth_hdr(skb);
 
-        if ((vxlan->flags & VXLAN_F_PROXY)) {
+        if (vxlan->flags & VXLAN_F_COLLECT_METADATA) {
+                if (info && info->mode & IP_TUNNEL_INFO_TX)
+                        vxlan_xmit_one(skb, dev, NULL, false);
+                else
+                        kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
+
+        if (vxlan->flags & VXLAN_F_PROXY) {
+                eth = eth_hdr(skb);
                 if (ntohs(eth->h_proto) == ETH_P_ARP)
                         return arp_reduce(dev, skb);
 #if IS_ENABLED(CONFIG_IPV6)
@@ -2126,18 +2204,10 @@ static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
                                     msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
                                         return neigh_reduce(dev, skb);
                 }
-                eth = eth_hdr(skb);
 #endif
         }
 
-        if (vxlan->flags & VXLAN_F_COLLECT_METADATA) {
-                if (info && info->mode & IP_TUNNEL_INFO_TX)
-                        vxlan_xmit_one(skb, dev, NULL, false);
-                else
-                        kfree_skb(skb);
-                return NETDEV_TX_OK;
-        }
-
+        eth = eth_hdr(skb);
         f = vxlan_find_mac(vxlan, eth->h_dest);
         did_rsc = false;
 
@@ -2407,7 +2477,7 @@ static int vxlan_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
         return 0;
 }
 
-static const struct net_device_ops vxlan_netdev_ops = {
+static const struct net_device_ops vxlan_netdev_ether_ops = {
         .ndo_init               = vxlan_init,
         .ndo_uninit             = vxlan_uninit,
         .ndo_open               = vxlan_open,
@@ -2424,6 +2494,17 @@ static const struct net_device_ops vxlan_netdev_ops = {
         .ndo_fill_metadata_dst  = vxlan_fill_metadata_dst,
 };
 
+static const struct net_device_ops vxlan_netdev_raw_ops = {
+        .ndo_init               = vxlan_init,
+        .ndo_uninit             = vxlan_uninit,
+        .ndo_open               = vxlan_open,
+        .ndo_stop               = vxlan_stop,
+        .ndo_start_xmit         = vxlan_xmit,
+        .ndo_get_stats64        = ip_tunnel_get_stats64,
+        .ndo_change_mtu         = vxlan_change_mtu,
+        .ndo_fill_metadata_dst  = vxlan_fill_metadata_dst,
+};
+
 /* Info for udev, that this is a virtual tunnel endpoint */
 static struct device_type vxlan_type = {
         .name = "vxlan",
@@ -2461,10 +2542,6 @@ static void vxlan_setup(struct net_device *dev)
         struct vxlan_dev *vxlan = netdev_priv(dev);
         unsigned int h;
 
-        eth_hw_addr_random(dev);
-        ether_setup(dev);
-
-        dev->netdev_ops = &vxlan_netdev_ops;
         dev->destructor = free_netdev;
         SET_NETDEV_DEVTYPE(dev, &vxlan_type);
 
@@ -2479,8 +2556,7 @@ static void vxlan_setup(struct net_device *dev)
         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
         dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
         netif_keep_dst(dev);
-        dev->priv_flags &= ~IFF_TX_SKB_SHARING;
-        dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
+        dev->priv_flags |= IFF_NO_QUEUE;
 
         INIT_LIST_HEAD(&vxlan->next);
         spin_lock_init(&vxlan->hash_lock);
@@ -2499,6 +2575,26 @@ static void vxlan_setup(struct net_device *dev)
                 INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
 }
 
+static void vxlan_ether_setup(struct net_device *dev)
+{
+        eth_hw_addr_random(dev);
+        ether_setup(dev);
+        dev->priv_flags &= ~IFF_TX_SKB_SHARING;
+        dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
+        dev->netdev_ops = &vxlan_netdev_ether_ops;
+}
+
+static void vxlan_raw_setup(struct net_device *dev)
+{
+        dev->type = ARPHRD_NONE;
+        dev->hard_header_len = 0;
+        dev->addr_len = 0;
+        dev->mtu = ETH_DATA_LEN;
+        dev->tx_queue_len = 1000;
+        dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
+        dev->netdev_ops = &vxlan_netdev_raw_ops;
+}
+
 static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
         [IFLA_VXLAN_ID]         = { .type = NLA_U32 },
         [IFLA_VXLAN_GROUP]      = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
@@ -2525,6 +2621,7 @@ static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
         [IFLA_VXLAN_REMCSUM_TX] = { .type = NLA_U8 },
         [IFLA_VXLAN_REMCSUM_RX] = { .type = NLA_U8 },
         [IFLA_VXLAN_GBP]        = { .type = NLA_FLAG, },
+        [IFLA_VXLAN_GPE]        = { .type = NLA_FLAG, },
         [IFLA_VXLAN_REMCSUM_NOPARTIAL]  = { .type = NLA_FLAG },
 };
 
@@ -2643,21 +2740,19 @@ static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,
         atomic_set(&vs->refcnt, 1);
         vs->flags = (flags & VXLAN_F_RCV_FLAGS);
 
-        /* Initialize the vxlan udp offloads structure */
-        vs->udp_offloads.port = port;
-        vs->udp_offloads.callbacks.gro_receive  = vxlan_gro_receive;
-        vs->udp_offloads.callbacks.gro_complete = vxlan_gro_complete;
-
         spin_lock(&vn->sock_lock);
         hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
         vxlan_notify_add_rx_port(vs);
         spin_unlock(&vn->sock_lock);
 
         /* Mark socket as an encapsulation socket. */
+        memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
         tunnel_cfg.sk_user_data = vs;
         tunnel_cfg.encap_type = 1;
         tunnel_cfg.encap_rcv = vxlan_rcv;
         tunnel_cfg.encap_destroy = NULL;
+        tunnel_cfg.gro_receive = vxlan_gro_receive;
+        tunnel_cfg.gro_complete = vxlan_gro_complete;
 
         setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
 
@@ -2725,6 +2820,21 @@ static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
         __be16 default_port = vxlan->cfg.dst_port;
         struct net_device *lowerdev = NULL;
 
+        if (conf->flags & VXLAN_F_GPE) {
+                if (conf->flags & ~VXLAN_F_ALLOWED_GPE)
+                        return -EINVAL;
+                /* For now, allow GPE only together with COLLECT_METADATA.
+                 * This can be relaxed later; in such case, the other side
+                 * of the PtP link will have to be provided.
+                 */
+                if (!(conf->flags & VXLAN_F_COLLECT_METADATA))
+                        return -EINVAL;
+
+                vxlan_raw_setup(dev);
+        } else {
+                vxlan_ether_setup(dev);
+        }
+
         vxlan->net = src_net;
 
         dst->remote_vni = conf->vni;
@@ -2786,8 +2896,12 @@ static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
         dev->needed_headroom = needed_headroom;
 
         memcpy(&vxlan->cfg, conf, sizeof(*conf));
-        if (!vxlan->cfg.dst_port)
-                vxlan->cfg.dst_port = default_port;
+        if (!vxlan->cfg.dst_port) {
+                if (conf->flags & VXLAN_F_GPE)
+                        vxlan->cfg.dst_port = 4790; /* IANA assigned VXLAN-GPE port */
+                else
+                        vxlan->cfg.dst_port = default_port;
+        }
         vxlan->flags |= conf->flags;
 
         if (!vxlan->cfg.age_interval)
@@ -2958,6 +3072,9 @@ static int vxlan_newlink(struct net *src_net, struct net_device *dev,
         if (data[IFLA_VXLAN_GBP])
                 conf.flags |= VXLAN_F_GBP;
 
+        if (data[IFLA_VXLAN_GPE])
+                conf.flags |= VXLAN_F_GPE;
+
         if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL])
                 conf.flags |= VXLAN_F_REMCSUM_NOPARTIAL;
 
@@ -2974,6 +3091,10 @@ static int vxlan_newlink(struct net *src_net, struct net_device *dev,
         case -EEXIST:
                 pr_info("duplicate VNI %u\n", be32_to_cpu(conf.vni));
                 break;
+
+        case -EINVAL:
+                pr_info("unsupported combination of extensions\n");
+                break;
         }
 
         return err;
@@ -3101,6 +3222,10 @@ static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
             nla_put_flag(skb, IFLA_VXLAN_GBP))
                 goto nla_put_failure;
 
+        if (vxlan->flags & VXLAN_F_GPE &&
+            nla_put_flag(skb, IFLA_VXLAN_GPE))
+                goto nla_put_failure;
+
         if (vxlan->flags & VXLAN_F_REMCSUM_NOPARTIAL &&
             nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))
                 goto nla_put_failure;
diff --git a/drivers/net/wireless/admtek/adm8211.c b/drivers/net/wireless/admtek/adm8211.c
index 15f057ed41ad..70ecd82d674d 100644
--- a/drivers/net/wireless/admtek/adm8211.c
+++ b/drivers/net/wireless/admtek/adm8211.c
@@ -440,7 +440,7 @@ static void adm8211_interrupt_rci(struct ieee80211_hw *dev)
                         rx_status.rate_idx = rate;
 
                         rx_status.freq = adm8211_channels[priv->channel - 1].center_freq;
-                        rx_status.band = IEEE80211_BAND_2GHZ;
+                        rx_status.band = NL80211_BAND_2GHZ;
 
                         memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
                         ieee80211_rx_irqsafe(dev, skb);
@@ -1894,7 +1894,7 @@ static int adm8211_probe(struct pci_dev *pdev,
 
         priv->channel = 1;
 
-        dev->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        dev->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
 
         err = ieee80211_register_hw(dev);
         if (err) {
diff --git a/drivers/net/wireless/ath/ar5523/ar5523.c b/drivers/net/wireless/ath/ar5523/ar5523.c
index 3b343c63aa52..8aded24bcdf4 100644
--- a/drivers/net/wireless/ath/ar5523/ar5523.c
+++ b/drivers/net/wireless/ath/ar5523/ar5523.c
@@ -1471,12 +1471,12 @@ static int ar5523_init_modes(struct ar5523 *ar)
         memcpy(ar->channels, ar5523_channels, sizeof(ar5523_channels));
         memcpy(ar->rates, ar5523_rates, sizeof(ar5523_rates));
 
-        ar->band.band = IEEE80211_BAND_2GHZ;
+        ar->band.band = NL80211_BAND_2GHZ;
         ar->band.channels = ar->channels;
         ar->band.n_channels = ARRAY_SIZE(ar5523_channels);
         ar->band.bitrates = ar->rates;
         ar->band.n_bitrates = ARRAY_SIZE(ar5523_rates);
-        ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &ar->band;
+        ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = &ar->band;
         return 0;
 }
 
diff --git a/drivers/net/wireless/ath/ath.h b/drivers/net/wireless/ath/ath.h
index 65ef483ebf50..da7a7c8dafb2 100644
--- a/drivers/net/wireless/ath/ath.h
+++ b/drivers/net/wireless/ath/ath.h
@@ -185,7 +185,7 @@ struct ath_common {
         bool bt_ant_diversity;
 
         int last_rssi;
-        struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
 };
 
 static inline const struct ath_ps_ops *ath_ps_ops(struct ath_common *common)
diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index edf3629288bc..7212802eb327 100644
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
@@ -411,7 +411,8 @@ int __ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
 
         lockdep_assert_held(&ar_pci->ce_lock);
 
-        if (CE_RING_DELTA(nentries_mask, write_index, sw_index - 1) == 0)
+        if ((pipe->id != 5) &&
+            CE_RING_DELTA(nentries_mask, write_index, sw_index - 1) == 0)
                 return -ENOSPC;
 
         desc->addr = __cpu_to_le32(paddr);
@@ -425,6 +426,19 @@ int __ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
         return 0;
 }
 
+void ath10k_ce_rx_update_write_idx(struct ath10k_ce_pipe *pipe, u32 nentries)
+{
+        struct ath10k *ar = pipe->ar;
+        struct ath10k_ce_ring *dest_ring = pipe->dest_ring;
+        unsigned int nentries_mask = dest_ring->nentries_mask;
+        unsigned int write_index = dest_ring->write_index;
+        u32 ctrl_addr = pipe->ctrl_addr;
+
+        write_index = CE_RING_IDX_ADD(nentries_mask, write_index, nentries);
+        ath10k_ce_dest_ring_write_index_set(ar, ctrl_addr, write_index);
+        dest_ring->write_index = write_index;
+}
+
 int ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
 {
         struct ath10k *ar = pipe->ar;
@@ -444,14 +458,10 @@ int ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
  */
 int ath10k_ce_completed_recv_next_nolock(struct ath10k_ce_pipe *ce_state,
                                          void **per_transfer_contextp,
-                                         u32 *bufferp,
-                                         unsigned int *nbytesp,
-                                         unsigned int *transfer_idp,
-                                         unsigned int *flagsp)
+                                         unsigned int *nbytesp)
 {
         struct ath10k_ce_ring *dest_ring = ce_state->dest_ring;
         unsigned int nentries_mask = dest_ring->nentries_mask;
-        struct ath10k *ar = ce_state->ar;
         unsigned int sw_index = dest_ring->sw_index;
 
         struct ce_desc *base = dest_ring->base_addr_owner_space;
@@ -476,21 +486,17 @@ int ath10k_ce_completed_recv_next_nolock(struct ath10k_ce_pipe *ce_state,
         desc->nbytes = 0;
 
         /* Return data from completed destination descriptor */
-        *bufferp = __le32_to_cpu(sdesc.addr);
         *nbytesp = nbytes;
-        *transfer_idp = MS(__le16_to_cpu(sdesc.flags), CE_DESC_FLAGS_META_DATA);
-
-        if (__le16_to_cpu(sdesc.flags) & CE_DESC_FLAGS_BYTE_SWAP)
-                *flagsp = CE_RECV_FLAG_SWAPPED;
-        else
-                *flagsp = 0;
 
         if (per_transfer_contextp)
                 *per_transfer_contextp =
                         dest_ring->per_transfer_context[sw_index];
 
-        /* sanity */
-        dest_ring->per_transfer_context[sw_index] = NULL;
+        /* Copy engine 5 (HTT Rx) will reuse the same transfer context.
+         * So update transfer context all CEs except CE5.
+         */
+        if (ce_state->id != 5)
+                dest_ring->per_transfer_context[sw_index] = NULL;
 
         /* Update sw_index */
         sw_index = CE_RING_IDX_INCR(nentries_mask, sw_index);
@@ -501,10 +507,7 @@ int ath10k_ce_completed_recv_next_nolock(struct ath10k_ce_pipe *ce_state,
 
 int ath10k_ce_completed_recv_next(struct ath10k_ce_pipe *ce_state,
                                   void **per_transfer_contextp,
-                                  u32 *bufferp,
-                                  unsigned int *nbytesp,
-                                  unsigned int *transfer_idp,
-                                  unsigned int *flagsp)
+                                  unsigned int *nbytesp)
 {
         struct ath10k *ar = ce_state->ar;
         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
@@ -513,8 +516,7 @@ int ath10k_ce_completed_recv_next(struct ath10k_ce_pipe *ce_state,
         spin_lock_bh(&ar_pci->ce_lock);
         ret = ath10k_ce_completed_recv_next_nolock(ce_state,
                                                    per_transfer_contextp,
-                                                   bufferp, nbytesp,
-                                                   transfer_idp, flagsp);
+                                                   nbytesp);
         spin_unlock_bh(&ar_pci->ce_lock);
 
         return ret;
diff --git a/drivers/net/wireless/ath/ath10k/ce.h b/drivers/net/wireless/ath/ath10k/ce.h
index 47b734ce7ecf..25cafcfd6b12 100644
--- a/drivers/net/wireless/ath/ath10k/ce.h
+++ b/drivers/net/wireless/ath/ath10k/ce.h
@@ -22,7 +22,7 @@
 
 /* Maximum number of Copy Engine's supported */
 #define CE_COUNT_MAX 12
-#define CE_HTT_H2T_MSG_SRC_NENTRIES 4096
+#define CE_HTT_H2T_MSG_SRC_NENTRIES 8192
 
 /* Descriptor rings must be aligned to this boundary */
 #define CE_DESC_RING_ALIGN      8
@@ -166,6 +166,7 @@ int ath10k_ce_num_free_src_entries(struct ath10k_ce_pipe *pipe);
 int __ath10k_ce_rx_num_free_bufs(struct ath10k_ce_pipe *pipe);
 int __ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr);
 int ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr);
+void ath10k_ce_rx_update_write_idx(struct ath10k_ce_pipe *pipe, u32 nentries);
 
 /* recv flags */
 /* Data is byte-swapped */
@@ -177,10 +178,7 @@ int ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr);
  */
 int ath10k_ce_completed_recv_next(struct ath10k_ce_pipe *ce_state,
                                   void **per_transfer_contextp,
-                                  u32 *bufferp,
-                                  unsigned int *nbytesp,
-                                  unsigned int *transfer_idp,
-                                  unsigned int *flagsp);
+                                  unsigned int *nbytesp);
 /*
  * Supply data for the next completed unprocessed send descriptor.
  * Pops 1 completed send buffer from Source ring.
@@ -212,10 +210,7 @@ int ath10k_ce_revoke_recv_next(struct ath10k_ce_pipe *ce_state,
 
 int ath10k_ce_completed_recv_next_nolock(struct ath10k_ce_pipe *ce_state,
                                          void **per_transfer_contextp,
-                                         u32 *bufferp,
-                                         unsigned int *nbytesp,
-                                         unsigned int *transfer_idp,
-                                         unsigned int *flagsp);
+                                         unsigned int *nbytesp);
 
 /*
  * Support clean shutdown by allowing the caller to cancel
@@ -416,6 +411,8 @@ static inline u32 ath10k_ce_base_address(struct ath10k *ar, unsigned int ce_id)
         (((int)(toidx)-(int)(fromidx)) & (nentries_mask))
 
 #define CE_RING_IDX_INCR(nentries_mask, idx) (((idx) + 1) & (nentries_mask))
+#define CE_RING_IDX_ADD(nentries_mask, idx, num) \
+                (((idx) + (num)) & (nentries_mask))
 
 #define CE_WRAPPER_INTERRUPT_SUMMARY_HOST_MSI_LSB \
                                 ar->regs->ce_wrap_intr_sum_host_msi_lsb
diff --git a/drivers/net/wireless/ath/ath10k/core.c b/drivers/net/wireless/ath/ath10k/core.c
index c84c2d30ef1f..b2c7fe3d30a4 100644
--- a/drivers/net/wireless/ath/ath10k/core.c
+++ b/drivers/net/wireless/ath/ath10k/core.c
@@ -60,6 +60,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_AFTER,
+                .cal_data_len = 2116,
                 .fw = {
                         .dir = QCA988X_HW_2_0_FW_DIR,
                         .fw = QCA988X_HW_2_0_FW_FILE,
@@ -78,6 +79,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .otp_exe_param = 0,
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
+                .cal_data_len = 8124,
                 .fw = {
                         .dir = QCA6174_HW_2_1_FW_DIR,
                         .fw = QCA6174_HW_2_1_FW_FILE,
@@ -97,6 +99,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_AFTER,
+                .cal_data_len = 8124,
                 .fw = {
                         .dir = QCA6174_HW_2_1_FW_DIR,
                         .fw = QCA6174_HW_2_1_FW_FILE,
@@ -116,6 +119,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_AFTER,
+                .cal_data_len = 8124,
                 .fw = {
                         .dir = QCA6174_HW_3_0_FW_DIR,
                         .fw = QCA6174_HW_3_0_FW_FILE,
@@ -135,6 +139,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_AFTER,
+                .cal_data_len = 8124,
                 .fw = {
                         /* uses same binaries as hw3.0 */
                         .dir = QCA6174_HW_3_0_FW_DIR,
@@ -156,11 +161,10 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 150000,
                 .max_probe_resp_desc_thres = 24,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_BEFORE,
-                .num_msdu_desc = 1424,
-                .qcache_active_peers = 50,
                 .tx_chain_mask = 0xf,
                 .rx_chain_mask = 0xf,
                 .max_spatial_stream = 4,
+                .cal_data_len = 12064,
                 .fw = {
                         .dir = QCA99X0_HW_2_0_FW_DIR,
                         .fw = QCA99X0_HW_2_0_FW_FILE,
@@ -179,6 +183,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .otp_exe_param = 0,
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
+                .cal_data_len = 8124,
                 .fw = {
                         .dir = QCA9377_HW_1_0_FW_DIR,
                         .fw = QCA9377_HW_1_0_FW_FILE,
@@ -197,6 +202,7 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .otp_exe_param = 0,
                 .channel_counters_freq_hz = 88000,
                 .max_probe_resp_desc_thres = 0,
+                .cal_data_len = 8124,
                 .fw = {
                         .dir = QCA9377_HW_1_0_FW_DIR,
                         .fw = QCA9377_HW_1_0_FW_FILE,
@@ -217,11 +223,10 @@ static const struct ath10k_hw_params ath10k_hw_params_list[] = {
                 .channel_counters_freq_hz = 125000,
                 .max_probe_resp_desc_thres = 24,
                 .hw_4addr_pad = ATH10K_HW_4ADDR_PAD_BEFORE,
-                .num_msdu_desc = 2500,
-                .qcache_active_peers = 35,
                 .tx_chain_mask = 0x3,
                 .rx_chain_mask = 0x3,
                 .max_spatial_stream = 2,
+                .cal_data_len = 12064,
                 .fw = {
                         .dir = QCA4019_HW_1_0_FW_DIR,
                         .fw = QCA4019_HW_1_0_FW_FILE,
@@ -466,18 +471,18 @@ exit:
         return ret;
 }
 
-static int ath10k_download_cal_file(struct ath10k *ar)
+static int ath10k_download_cal_file(struct ath10k *ar,
+                                    const struct firmware *file)
 {
         int ret;
 
-        if (!ar->cal_file)
+        if (!file)
                 return -ENOENT;
 
-        if (IS_ERR(ar->cal_file))
-                return PTR_ERR(ar->cal_file);
+        if (IS_ERR(file))
+                return PTR_ERR(file);
 
-        ret = ath10k_download_board_data(ar, ar->cal_file->data,
-                                         ar->cal_file->size);
+        ret = ath10k_download_board_data(ar, file->data, file->size);
         if (ret) {
                 ath10k_err(ar, "failed to download cal_file data: %d\n", ret);
                 return ret;
@@ -488,7 +493,7 @@ static int ath10k_download_cal_file(struct ath10k *ar)
         return 0;
 }
 
-static int ath10k_download_cal_dt(struct ath10k *ar)
+static int ath10k_download_cal_dt(struct ath10k *ar, const char *dt_name)
 {
         struct device_node *node;
         int data_len;
@@ -502,13 +507,12 @@ static int ath10k_download_cal_dt(struct ath10k *ar)
                  */
                 return -ENOENT;
 
-        if (!of_get_property(node, "qcom,ath10k-calibration-data",
-                             &data_len)) {
+        if (!of_get_property(node, dt_name, &data_len)) {
                 /* The calibration data node is optional */
                 return -ENOENT;
         }
 
-        if (data_len != QCA988X_CAL_DATA_LEN) {
+        if (data_len != ar->hw_params.cal_data_len) {
                 ath10k_warn(ar, "invalid calibration data length in DT: %d\n",
                             data_len);
                 ret = -EMSGSIZE;
@@ -521,8 +525,7 @@ static int ath10k_download_cal_dt(struct ath10k *ar)
                 goto out;
         }
 
-        ret = of_property_read_u8_array(node, "qcom,ath10k-calibration-data",
-                                        data, data_len);
+        ret = of_property_read_u8_array(node, dt_name, data, data_len);
         if (ret) {
                 ath10k_warn(ar, "failed to read calibration data from DT: %d\n",
                             ret);
@@ -726,6 +729,14 @@ static int ath10k_fetch_cal_file(struct ath10k *ar)
 {
         char filename[100];
 
+        /* pre-cal-<bus>-<id>.bin */
+        scnprintf(filename, sizeof(filename), "pre-cal-%s-%s.bin",
+                  ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));
+
+        ar->pre_cal_file = ath10k_fetch_fw_file(ar, ATH10K_FW_DIR, filename);
+        if (!IS_ERR(ar->pre_cal_file))
+                goto success;
+
         /* cal-<bus>-<id>.bin */
         scnprintf(filename, sizeof(filename), "cal-%s-%s.bin",
                   ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));
@@ -734,7 +745,7 @@ static int ath10k_fetch_cal_file(struct ath10k *ar)
         if (IS_ERR(ar->cal_file))
                 /* calibration file is optional, don't print any warnings */
                 return PTR_ERR(ar->cal_file);
-
+success:
         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found calibration file %s/%s\n",
                    ATH10K_FW_DIR, filename);
 
@@ -1258,11 +1269,77 @@ success:
         return 0;
 }
 
+static int ath10k_core_pre_cal_download(struct ath10k *ar)
+{
+        int ret;
+
+        ret = ath10k_download_cal_file(ar, ar->pre_cal_file);
+        if (ret == 0) {
+                ar->cal_mode = ATH10K_PRE_CAL_MODE_FILE;
+                goto success;
+        }
+
+        ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                   "boot did not find a pre calibration file, try DT next: %d\n",
+                   ret);
+
+        ret = ath10k_download_cal_dt(ar, "qcom,ath10k-pre-calibration-data");
+        if (ret) {
+                ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                           "unable to load pre cal data from DT: %d\n", ret);
+                return ret;
+        }
+        ar->cal_mode = ATH10K_PRE_CAL_MODE_DT;
+
+success:
+        ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using calibration mode %s\n",
+                   ath10k_cal_mode_str(ar->cal_mode));
+
+        return 0;
+}
+
+static int ath10k_core_pre_cal_config(struct ath10k *ar)
+{
+        int ret;
+
+        ret = ath10k_core_pre_cal_download(ar);
+        if (ret) {
+                ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                           "failed to load pre cal data: %d\n", ret);
+                return ret;
+        }
+
+        ret = ath10k_core_get_board_id_from_otp(ar);
+        if (ret) {
+                ath10k_err(ar, "failed to get board id: %d\n", ret);
+                return ret;
+        }
+
+        ret = ath10k_download_and_run_otp(ar);
+        if (ret) {
+                ath10k_err(ar, "failed to run otp: %d\n", ret);
+                return ret;
+        }
+
+        ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                   "pre cal configuration done successfully\n");
+
+        return 0;
+}
+
 static int ath10k_download_cal_data(struct ath10k *ar)
 {
         int ret;
 
-        ret = ath10k_download_cal_file(ar);
+        ret = ath10k_core_pre_cal_config(ar);
+        if (ret == 0)
+                return 0;
+
+        ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                   "pre cal download procedure failed, try cal file: %d\n",
+                   ret);
+
+        ret = ath10k_download_cal_file(ar, ar->cal_file);
         if (ret == 0) {
                 ar->cal_mode = ATH10K_CAL_MODE_FILE;
                 goto done;
@@ -1272,7 +1349,7 @@ static int ath10k_download_cal_data(struct ath10k *ar)
                    "boot did not find a calibration file, try DT next: %d\n",
                    ret);
 
-        ret = ath10k_download_cal_dt(ar);
+        ret = ath10k_download_cal_dt(ar, "qcom,ath10k-calibration-data");
         if (ret == 0) {
                 ar->cal_mode = ATH10K_CAL_MODE_DT;
                 goto done;
@@ -1509,7 +1586,7 @@ static int ath10k_core_init_firmware_features(struct ath10k *ar)
         case ATH10K_FW_WMI_OP_VERSION_10_1:
         case ATH10K_FW_WMI_OP_VERSION_10_2:
         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
-                if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
+                if (ath10k_peer_stats_enabled(ar)) {
                         ar->max_num_peers = TARGET_10X_TX_STATS_NUM_PEERS;
                         ar->max_num_stations = TARGET_10X_TX_STATS_NUM_STATIONS;
                 } else {
@@ -1538,9 +1615,15 @@ static int ath10k_core_init_firmware_features(struct ath10k *ar)
                 ar->num_active_peers = TARGET_10_4_ACTIVE_PEERS;
                 ar->max_num_vdevs = TARGET_10_4_NUM_VDEVS;
                 ar->num_tids = TARGET_10_4_TGT_NUM_TIDS;
-                ar->htt.max_num_pending_tx = ar->hw_params.num_msdu_desc;
-                ar->fw_stats_req_mask = WMI_STAT_PEER;
+                ar->fw_stats_req_mask = WMI_10_4_STAT_PEER |
+                                        WMI_10_4_STAT_PEER_EXTD;
                 ar->max_spatial_stream = ar->hw_params.max_spatial_stream;
+
+                if (test_bit(ATH10K_FW_FEATURE_PEER_FLOW_CONTROL,
+                             ar->fw_features))
+                        ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC_PFC;
+                else
+                        ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC;
                 break;
         case ATH10K_FW_WMI_OP_VERSION_UNSET:
         case ATH10K_FW_WMI_OP_VERSION_MAX:
@@ -1578,6 +1661,7 @@ static int ath10k_core_init_firmware_features(struct ath10k *ar)
 int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
 {
         int status;
+        u32 val;
 
         lockdep_assert_held(&ar->conf_mutex);
 
@@ -1698,6 +1782,21 @@ int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
         ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
                    ar->hw->wiphy->fw_version);
 
+        if (test_bit(WMI_SERVICE_EXT_RES_CFG_SUPPORT, ar->wmi.svc_map)) {
+                val = 0;
+                if (ath10k_peer_stats_enabled(ar))
+                        val = WMI_10_4_PEER_STATS;
+
+                status = ath10k_wmi_ext_resource_config(ar,
+                                                        WMI_HOST_PLATFORM_HIGH_PERF, val);
+                if (status) {
+                        ath10k_err(ar,
+                                   "failed to send ext resource cfg command : %d\n",
+                                   status);
+                        goto err_hif_stop;
+                }
+        }
+
         status = ath10k_wmi_cmd_init(ar);
         if (status) {
                 ath10k_err(ar, "could not send WMI init command (%d)\n",
@@ -1834,11 +1933,20 @@ static int ath10k_core_probe_fw(struct ath10k *ar)
 
         ath10k_debug_print_hwfw_info(ar);
 
+        ret = ath10k_core_pre_cal_download(ar);
+        if (ret) {
+                /* pre calibration data download is not necessary
+                 * for all the chipsets. Ignore failures and continue.
+                 */
+                ath10k_dbg(ar, ATH10K_DBG_BOOT,
+                           "could not load pre cal data: %d\n", ret);
+        }
+
         ret = ath10k_core_get_board_id_from_otp(ar);
         if (ret && ret != -EOPNOTSUPP) {
                 ath10k_err(ar, "failed to get board id from otp: %d\n",
                            ret);
-                return ret;
+                goto err_free_firmware_files;
         }
 
         ret = ath10k_core_fetch_board_file(ar);
@@ -2048,7 +2156,9 @@ struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
 
         mutex_init(&ar->conf_mutex);
         spin_lock_init(&ar->data_lock);
+        spin_lock_init(&ar->txqs_lock);
 
+        INIT_LIST_HEAD(&ar->txqs);
         INIT_LIST_HEAD(&ar->peers);
         init_waitqueue_head(&ar->peer_mapping_wq);
         init_waitqueue_head(&ar->htt.empty_tx_wq);
diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h
index a62b62a62266..362bbed8f0e9 100644
--- a/drivers/net/wireless/ath/ath10k/core.h
+++ b/drivers/net/wireless/ath/ath10k/core.h
@@ -98,6 +98,7 @@ struct ath10k_skb_cb {
         u8 eid;
         u16 msdu_id;
         struct ieee80211_vif *vif;
+        struct ieee80211_txq *txq;
 } __packed;
 
 struct ath10k_skb_rxcb {
@@ -297,6 +298,9 @@ struct ath10k_dfs_stats {
 
 struct ath10k_peer {
         struct list_head list;
+        struct ieee80211_vif *vif;
+        struct ieee80211_sta *sta;
+
         int vdev_id;
         u8 addr[ETH_ALEN];
         DECLARE_BITMAP(peer_ids, ATH10K_MAX_NUM_PEER_IDS);
@@ -305,6 +309,12 @@ struct ath10k_peer {
         struct ieee80211_key_conf *keys[WMI_MAX_KEY_INDEX + 1];
 };
 
+struct ath10k_txq {
+        struct list_head list;
+        unsigned long num_fw_queued;
+        unsigned long num_push_allowed;
+};
+
 struct ath10k_sta {
         struct ath10k_vif *arvif;
 
@@ -313,6 +323,7 @@ struct ath10k_sta {
         u32 bw;
         u32 nss;
         u32 smps;
+        u16 peer_id;
 
         struct work_struct update_wk;
 
@@ -335,6 +346,7 @@ struct ath10k_vif {
         struct list_head list;
 
         u32 vdev_id;
+        u16 peer_id;
         enum wmi_vdev_type vdev_type;
         enum wmi_vdev_subtype vdev_subtype;
         u32 beacon_interval;
@@ -549,12 +561,17 @@ enum ath10k_dev_flags {
 
         /* Bluetooth coexistance enabled */
         ATH10K_FLAG_BTCOEX,
+
+        /* Per Station statistics service */
+        ATH10K_FLAG_PEER_STATS,
 };
 
 enum ath10k_cal_mode {
         ATH10K_CAL_MODE_FILE,
         ATH10K_CAL_MODE_OTP,
         ATH10K_CAL_MODE_DT,
+        ATH10K_PRE_CAL_MODE_FILE,
+        ATH10K_PRE_CAL_MODE_DT,
 };
 
 enum ath10k_crypt_mode {
@@ -573,6 +590,10 @@ static inline const char *ath10k_cal_mode_str(enum ath10k_cal_mode mode)
                 return "otp";
         case ATH10K_CAL_MODE_DT:
                 return "dt";
+        case ATH10K_PRE_CAL_MODE_FILE:
+                return "pre-cal-file";
+        case ATH10K_PRE_CAL_MODE_DT:
+                return "pre-cal-dt";
         }
 
         return "unknown";
@@ -680,11 +701,10 @@ struct ath10k {
                 /* The padding bytes's location is different on various chips */
                 enum ath10k_hw_4addr_pad hw_4addr_pad;
 
-                u32 num_msdu_desc;
-                u32 qcache_active_peers;
                 u32 tx_chain_mask;
                 u32 rx_chain_mask;
                 u32 max_spatial_stream;
+                u32 cal_data_len;
 
                 struct ath10k_hw_params_fw {
                         const char *dir;
@@ -708,6 +728,7 @@ struct ath10k {
         const void *firmware_data;
         size_t firmware_len;
 
+        const struct firmware *pre_cal_file;
         const struct firmware *cal_file;
 
         struct {
@@ -744,7 +765,7 @@ struct ath10k {
         } scan;
 
         struct {
-                struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
+                struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
         } mac;
 
         /* should never be NULL; needed for regular htt rx */
@@ -756,6 +777,9 @@ struct ath10k {
         /* current operating channel definition */
         struct cfg80211_chan_def chandef;
 
+        /* currently configured operating channel in firmware */
+        struct ieee80211_channel *tgt_oper_chan;
+
         unsigned long long free_vdev_map;
         struct ath10k_vif *monitor_arvif;
         bool monitor;
@@ -786,9 +810,13 @@ struct ath10k {
 
         /* protects shared structure data */
         spinlock_t data_lock;
+        /* protects: ar->txqs, artxq->list */
+        spinlock_t txqs_lock;
 
+        struct list_head txqs;
         struct list_head arvifs;
         struct list_head peers;
+        struct ath10k_peer *peer_map[ATH10K_MAX_NUM_PEER_IDS];
         wait_queue_head_t peer_mapping_wq;
 
         /* protected by conf_mutex */
@@ -876,6 +904,15 @@ struct ath10k {
         u8 drv_priv[0] __aligned(sizeof(void *));
 };
 
+static inline bool ath10k_peer_stats_enabled(struct ath10k *ar)
+{
+        if (test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) &&
+            test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
+                return true;
+
+        return false;
+}
+
 struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
                                   enum ath10k_bus bus,
                                   enum ath10k_hw_rev hw_rev,
diff --git a/drivers/net/wireless/ath/ath10k/debug.c b/drivers/net/wireless/ath/ath10k/debug.c
index 076d29b53ddf..76bbe17b25b6 100644
--- a/drivers/net/wireless/ath/ath10k/debug.c
+++ b/drivers/net/wireless/ath/ath10k/debug.c
@@ -127,6 +127,7 @@ EXPORT_SYMBOL(ath10k_info);
 void ath10k_debug_print_hwfw_info(struct ath10k *ar)
 {
         char fw_features[128] = {};
+        u32 crc = 0;
 
         ath10k_core_get_fw_features_str(ar, fw_features, sizeof(fw_features));
 
@@ -143,11 +144,14 @@ void ath10k_debug_print_hwfw_info(struct ath10k *ar)
                     config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
                     config_enabled(CONFIG_NL80211_TESTMODE));
 
+        if (ar->firmware)
+                crc = crc32_le(0, ar->firmware->data, ar->firmware->size);
+
         ath10k_info(ar, "firmware ver %s api %d features %s crc32 %08x\n",
                     ar->hw->wiphy->fw_version,
                     ar->fw_api,
                     fw_features,
-                    crc32_le(0, ar->firmware->data, ar->firmware->size));
+                    crc);
 }
 
 void ath10k_debug_print_board_info(struct ath10k *ar)
@@ -319,7 +323,7 @@ static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
 void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
 {
         struct ath10k_fw_stats stats = {};
-        bool is_start, is_started, is_end, peer_stats_svc;
+        bool is_start, is_started, is_end;
         size_t num_peers;
         size_t num_vdevs;
         int ret;
@@ -346,13 +350,11 @@ void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
          *  b) consume stat update events until another one with pdev stats is
          *     delivered which is treated as end-of-data and is itself discarded
          */
-
-        peer_stats_svc = test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map);
-        if (peer_stats_svc)
+        if (ath10k_peer_stats_enabled(ar))
                 ath10k_sta_update_rx_duration(ar, &stats.peers);
 
         if (ar->debug.fw_stats_done) {
-                if (!peer_stats_svc)
+                if (!ath10k_peer_stats_enabled(ar))
                         ath10k_warn(ar, "received unsolicited stats update event\n");
 
                 goto free;
@@ -1447,7 +1449,7 @@ static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
                 goto err;
         }
 
-        buf = vmalloc(QCA988X_CAL_DATA_LEN);
+        buf = vmalloc(ar->hw_params.cal_data_len);
         if (!buf) {
                 ret = -ENOMEM;
                 goto err;
@@ -1462,7 +1464,7 @@ static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
         }
 
         ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), buf,
-                                   QCA988X_CAL_DATA_LEN);
+                                   ar->hw_params.cal_data_len);
         if (ret) {
                 ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
                 goto err_vfree;
@@ -1487,10 +1489,11 @@ static ssize_t ath10k_debug_cal_data_read(struct file *file,
                                           char __user *user_buf,
                                           size_t count, loff_t *ppos)
 {
+        struct ath10k *ar = file->private_data;
         void *buf = file->private_data;
 
         return simple_read_from_buffer(user_buf, count, ppos,
-                                       buf, QCA988X_CAL_DATA_LEN);
+                                       buf, ar->hw_params.cal_data_len);
 }
 
 static int ath10k_debug_cal_data_release(struct inode *inode,
@@ -2019,7 +2022,12 @@ static ssize_t ath10k_write_pktlog_filter(struct file *file,
                 goto out;
         }
 
-        if (filter && (filter != ar->debug.pktlog_filter)) {
+        if (filter == ar->debug.pktlog_filter) {
+                ret = count;
+                goto out;
+        }
+
+        if (filter) {
                 ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
                 if (ret) {
                         ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
@@ -2174,6 +2182,73 @@ static const struct file_operations fops_btcoex = {
         .open = simple_open
 };
 
+static ssize_t ath10k_write_peer_stats(struct file *file,
+                                       const char __user *ubuf,
+                                       size_t count, loff_t *ppos)
+{
+        struct ath10k *ar = file->private_data;
+        char buf[32];
+        size_t buf_size;
+        int ret = 0;
+        bool val;
+
+        buf_size = min(count, (sizeof(buf) - 1));
+        if (copy_from_user(buf, ubuf, buf_size))
+                return -EFAULT;
+
+        buf[buf_size] = '\0';
+
+        if (strtobool(buf, &val) != 0)
+                return -EINVAL;
+
+        mutex_lock(&ar->conf_mutex);
+
+        if (ar->state != ATH10K_STATE_ON &&
+            ar->state != ATH10K_STATE_RESTARTED) {
+                ret = -ENETDOWN;
+                goto exit;
+        }
+
+        if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val))
+                goto exit;
+
+        if (val)
+                set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
+        else
+                clear_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
+
+        ath10k_info(ar, "restarting firmware due to Peer stats change");
+
+        queue_work(ar->workqueue, &ar->restart_work);
+        ret = count;
+
+exit:
+        mutex_unlock(&ar->conf_mutex);
+        return ret;
+}
+
+static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
+                                      size_t count, loff_t *ppos)
+
+{
+        char buf[32];
+        struct ath10k *ar = file->private_data;
+        int len = 0;
+
+        mutex_lock(&ar->conf_mutex);
+        len = scnprintf(buf, sizeof(buf) - len, "%d\n",
+                        test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
+        mutex_unlock(&ar->conf_mutex);
+
+        return simple_read_from_buffer(ubuf, count, ppos, buf, len);
+}
+
+static const struct file_operations fops_peer_stats = {
+        .read = ath10k_read_peer_stats,
+        .write = ath10k_write_peer_stats,
+        .open = simple_open
+};
+
 static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
                                               char __user *user_buf,
                                               size_t count, loff_t *ppos)
@@ -2337,6 +2412,11 @@ int ath10k_debug_register(struct ath10k *ar)
                 debugfs_create_file("btcoex", S_IRUGO | S_IWUSR,
                                     ar->debug.debugfs_phy, ar, &fops_btcoex);
 
+        if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
+                debugfs_create_file("peer_stats", S_IRUGO | S_IWUSR,
+                                    ar->debug.debugfs_phy, ar,
+                                    &fops_peer_stats);
+
         debugfs_create_file("fw_checksums", S_IRUSR,
                             ar->debug.debugfs_phy, ar, &fops_fw_checksums);
 
diff --git a/drivers/net/wireless/ath/ath10k/htt.c b/drivers/net/wireless/ath/ath10k/htt.c
index 7561f22f10f9..17a3008d9ab1 100644
--- a/drivers/net/wireless/ath/ath10k/htt.c
+++ b/drivers/net/wireless/ath/ath10k/htt.c
@@ -149,7 +149,7 @@ int ath10k_htt_connect(struct ath10k_htt *htt)
         memset(&conn_resp, 0, sizeof(conn_resp));
 
         conn_req.ep_ops.ep_tx_complete = ath10k_htt_htc_tx_complete;
-        conn_req.ep_ops.ep_rx_complete = ath10k_htt_t2h_msg_handler;
+        conn_req.ep_ops.ep_rx_complete = ath10k_htt_htc_t2h_msg_handler;
 
         /* connect to control service */
         conn_req.service_id = ATH10K_HTC_SVC_ID_HTT_DATA_MSG;
diff --git a/drivers/net/wireless/ath/ath10k/htt.h b/drivers/net/wireless/ath/ath10k/htt.h
index 13391ea4422d..60bd9fe4b2d9 100644
--- a/drivers/net/wireless/ath/ath10k/htt.h
+++ b/drivers/net/wireless/ath/ath10k/htt.h
@@ -22,6 +22,7 @@
 #include <linux/interrupt.h>
 #include <linux/dmapool.h>
 #include <linux/hashtable.h>
+#include <linux/kfifo.h>
 #include <net/mac80211.h>
 
 #include "htc.h"
@@ -1461,6 +1462,14 @@ struct htt_tx_mode_switch_ind {
         struct htt_tx_mode_switch_record records[0];
 } __packed;
 
+struct htt_channel_change {
+        u8 pad[3];
+        __le32 freq;
+        __le32 center_freq1;
+        __le32 center_freq2;
+        __le32 phymode;
+} __packed;
+
 union htt_rx_pn_t {
         /* WEP: 24-bit PN */
         u32 pn24;
@@ -1511,16 +1520,22 @@ struct htt_resp {
                 struct htt_tx_fetch_ind tx_fetch_ind;
                 struct htt_tx_fetch_confirm tx_fetch_confirm;
                 struct htt_tx_mode_switch_ind tx_mode_switch_ind;
+                struct htt_channel_change chan_change;
         };
 } __packed;
 
 /*** host side structures follow ***/
 
 struct htt_tx_done {
-        u32 msdu_id;
-        bool discard;
-        bool no_ack;
-        bool success;
+        u16 msdu_id;
+        u16 status;
+};
+
+enum htt_tx_compl_state {
+        HTT_TX_COMPL_STATE_NONE,
+        HTT_TX_COMPL_STATE_ACK,
+        HTT_TX_COMPL_STATE_NOACK,
+        HTT_TX_COMPL_STATE_DISCARD,
 };
 
 struct htt_peer_map_event {
@@ -1641,17 +1656,20 @@ struct ath10k_htt {
         struct idr pending_tx;
         wait_queue_head_t empty_tx_wq;
 
+        /* FIFO for storing tx done status {ack, no-ack, discard} and msdu id */
+        DECLARE_KFIFO_PTR(txdone_fifo, struct htt_tx_done);
+
         /* set if host-fw communication goes haywire
          * used to avoid further failures */
         bool rx_confused;
-        struct tasklet_struct rx_replenish_task;
+        atomic_t num_mpdus_ready;
 
         /* This is used to group tx/rx completions separately and process them
          * in batches to reduce cache stalls */
         struct tasklet_struct txrx_compl_task;
-        struct sk_buff_head tx_compl_q;
         struct sk_buff_head rx_compl_q;
         struct sk_buff_head rx_in_ord_compl_q;
+        struct sk_buff_head tx_fetch_ind_q;
 
         /* rx_status template */
         struct ieee80211_rx_status rx_status;
@@ -1667,10 +1685,13 @@ struct ath10k_htt {
         } txbuf;
 
         struct {
+                bool enabled;
                 struct htt_q_state *vaddr;
                 dma_addr_t paddr;
+                u16 num_push_allowed;
                 u16 num_peers;
                 u16 num_tids;
+                enum htt_tx_mode_switch_mode mode;
                 enum htt_q_depth_type type;
         } tx_q_state;
 };
@@ -1715,7 +1736,7 @@ struct htt_rx_desc {
 
 /* Refill a bunch of RX buffers for each refill round so that FW/HW can handle
  * aggregated traffic more nicely. */
-#define ATH10K_HTT_MAX_NUM_REFILL 16
+#define ATH10K_HTT_MAX_NUM_REFILL 100
 
 /*
  * DMA_MAP expects the buffer to be an integral number of cache lines.
@@ -1743,7 +1764,8 @@ int ath10k_htt_rx_ring_refill(struct ath10k *ar);
 void ath10k_htt_rx_free(struct ath10k_htt *htt);
 
 void ath10k_htt_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb);
-void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb);
+void ath10k_htt_htc_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb);
+bool ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb);
 int ath10k_htt_h2t_ver_req_msg(struct ath10k_htt *htt);
 int ath10k_htt_h2t_stats_req(struct ath10k_htt *htt, u8 mask, u64 cookie);
 int ath10k_htt_send_frag_desc_bank_cfg(struct ath10k_htt *htt);
@@ -1752,8 +1774,23 @@ int ath10k_htt_h2t_aggr_cfg_msg(struct ath10k_htt *htt,
                                 u8 max_subfrms_ampdu,
                                 u8 max_subfrms_amsdu);
 void ath10k_htt_hif_tx_complete(struct ath10k *ar, struct sk_buff *skb);
+int ath10k_htt_tx_fetch_resp(struct ath10k *ar,
+                             __le32 token,
+                             __le16 fetch_seq_num,
+                             struct htt_tx_fetch_record *records,
+                             size_t num_records);
+
+void ath10k_htt_tx_txq_update(struct ieee80211_hw *hw,
+                              struct ieee80211_txq *txq);
+void ath10k_htt_tx_txq_recalc(struct ieee80211_hw *hw,
+                              struct ieee80211_txq *txq);
+void ath10k_htt_tx_txq_sync(struct ath10k *ar);
+void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt);
+int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt);
+void ath10k_htt_tx_mgmt_dec_pending(struct ath10k_htt *htt);
+int ath10k_htt_tx_mgmt_inc_pending(struct ath10k_htt *htt, bool is_mgmt,
+                                   bool is_presp);
 
-void __ath10k_htt_tx_dec_pending(struct ath10k_htt *htt, bool limit_mgmt_desc);
 int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt, struct sk_buff *skb);
 void ath10k_htt_tx_free_msdu_id(struct ath10k_htt *htt, u16 msdu_id);
 int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *);
diff --git a/drivers/net/wireless/ath/ath10k/htt_rx.c b/drivers/net/wireless/ath/ath10k/htt_rx.c
index ae9b686a4e91..079fef5b7ef2 100644
--- a/drivers/net/wireless/ath/ath10k/htt_rx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_rx.c
@@ -31,6 +31,8 @@
 /* when under memory pressure rx ring refill may fail and needs a retry */
 #define HTT_RX_RING_REFILL_RETRY_MS 50
 
+#define HTT_RX_RING_REFILL_RESCHED_MS 5
+
 static int ath10k_htt_rx_get_csum_state(struct sk_buff *skb);
 static void ath10k_htt_txrx_compl_task(unsigned long ptr);
 
@@ -192,7 +194,8 @@ static void ath10k_htt_rx_msdu_buff_replenish(struct ath10k_htt *htt)
                 mod_timer(&htt->rx_ring.refill_retry_timer, jiffies +
                           msecs_to_jiffies(HTT_RX_RING_REFILL_RETRY_MS));
         } else if (num_deficit > 0) {
-                tasklet_schedule(&htt->rx_replenish_task);
+                mod_timer(&htt->rx_ring.refill_retry_timer, jiffies +
+                          msecs_to_jiffies(HTT_RX_RING_REFILL_RESCHED_MS));
         }
         spin_unlock_bh(&htt->rx_ring.lock);
 }
@@ -223,12 +226,11 @@ int ath10k_htt_rx_ring_refill(struct ath10k *ar)
 void ath10k_htt_rx_free(struct ath10k_htt *htt)
 {
         del_timer_sync(&htt->rx_ring.refill_retry_timer);
-        tasklet_kill(&htt->rx_replenish_task);
         tasklet_kill(&htt->txrx_compl_task);
 
-        skb_queue_purge(&htt->tx_compl_q);
         skb_queue_purge(&htt->rx_compl_q);
         skb_queue_purge(&htt->rx_in_ord_compl_q);
+        skb_queue_purge(&htt->tx_fetch_ind_q);
 
         ath10k_htt_rx_ring_free(htt);
 
@@ -281,7 +283,6 @@ static inline struct sk_buff *ath10k_htt_rx_netbuf_pop(struct ath10k_htt *htt)
 
 /* return: < 0 fatal error, 0 - non chained msdu, 1 chained msdu */
 static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
-                                   u8 **fw_desc, int *fw_desc_len,
                                    struct sk_buff_head *amsdu)
 {
         struct ath10k *ar = htt->ar;
@@ -323,48 +324,6 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
                         return -EIO;
                 }
 
-                /*
-                 * Copy the FW rx descriptor for this MSDU from the rx
-                 * indication message into the MSDU's netbuf. HL uses the
-                 * same rx indication message definition as LL, and simply
-                 * appends new info (fields from the HW rx desc, and the
-                 * MSDU payload itself). So, the offset into the rx
-                 * indication message only has to account for the standard
-                 * offset of the per-MSDU FW rx desc info within the
-                 * message, and how many bytes of the per-MSDU FW rx desc
-                 * info have already been consumed. (And the endianness of
-                 * the host, since for a big-endian host, the rx ind
-                 * message contents, including the per-MSDU rx desc bytes,
-                 * were byteswapped during upload.)
-                 */
-                if (*fw_desc_len > 0) {
-                        rx_desc->fw_desc.info0 = **fw_desc;
-                        /*
-                         * The target is expected to only provide the basic
-                         * per-MSDU rx descriptors. Just to be sure, verify
-                         * that the target has not attached extension data
-                         * (e.g. LRO flow ID).
-                         */
-
-                        /* or more, if there's extension data */
-                        (*fw_desc)++;
-                        (*fw_desc_len)--;
-                } else {
-                        /*
-                         * When an oversized AMSDU happened, FW will lost
-                         * some of MSDU status - in this case, the FW
-                         * descriptors provided will be less than the
-                         * actual MSDUs inside this MPDU. Mark the FW
-                         * descriptors so that it will still deliver to
-                         * upper stack, if no CRC error for this MPDU.
-                         *
-                         * FIX THIS - the FW descriptors are actually for
-                         * MSDUs in the end of this A-MSDU instead of the
-                         * beginning.
-                         */
-                        rx_desc->fw_desc.info0 = 0;
-                }
-
                 msdu_len_invalid = !!(__le32_to_cpu(rx_desc->attention.flags)
                                         & (RX_ATTENTION_FLAGS_MPDU_LENGTH_ERR |
                                            RX_ATTENTION_FLAGS_MSDU_LENGTH_ERR));
@@ -423,13 +382,6 @@ static int ath10k_htt_rx_amsdu_pop(struct ath10k_htt *htt,
         return msdu_chaining;
 }
 
-static void ath10k_htt_rx_replenish_task(unsigned long ptr)
-{
-        struct ath10k_htt *htt = (struct ath10k_htt *)ptr;
-
-        ath10k_htt_rx_msdu_buff_replenish(htt);
-}
-
 static struct sk_buff *ath10k_htt_rx_pop_paddr(struct ath10k_htt *htt,
                                                u32 paddr)
 {
@@ -563,12 +515,10 @@ int ath10k_htt_rx_alloc(struct ath10k_htt *htt)
         htt->rx_ring.sw_rd_idx.msdu_payld = 0;
         hash_init(htt->rx_ring.skb_table);
 
-        tasklet_init(&htt->rx_replenish_task, ath10k_htt_rx_replenish_task,
-                     (unsigned long)htt);
-
-        skb_queue_head_init(&htt->tx_compl_q);
         skb_queue_head_init(&htt->rx_compl_q);
         skb_queue_head_init(&htt->rx_in_ord_compl_q);
+        skb_queue_head_init(&htt->tx_fetch_ind_q);
+        atomic_set(&htt->num_mpdus_ready, 0);
 
         tasklet_init(&htt->txrx_compl_task, ath10k_htt_txrx_compl_task,
                      (unsigned long)htt);
@@ -860,6 +810,8 @@ static bool ath10k_htt_rx_h_channel(struct ath10k *ar,
                 ch = ath10k_htt_rx_h_vdev_channel(ar, vdev_id);
         if (!ch)
                 ch = ath10k_htt_rx_h_any_channel(ar);
+        if (!ch)
+                ch = ar->tgt_oper_chan;
         spin_unlock_bh(&ar->data_lock);
 
         if (!ch)
@@ -979,7 +931,7 @@ static void ath10k_process_rx(struct ath10k *ar,
         *status = *rx_status;
 
         ath10k_dbg(ar, ATH10K_DBG_DATA,
-                   "rx skb %p len %u peer %pM %s %s sn %u %s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u flag 0x%x fcs-err %i mic-err %i amsdu-more %i\n",
+                   "rx skb %p len %u peer %pM %s %s sn %u %s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u flag 0x%llx fcs-err %i mic-err %i amsdu-more %i\n",
                    skb,
                    skb->len,
                    ieee80211_get_SA(hdr),
@@ -1076,20 +1028,25 @@ static void ath10k_htt_rx_h_undecap_raw(struct ath10k *ar,
         hdr = (void *)msdu->data;
 
         /* Tail */
-        skb_trim(msdu, msdu->len - ath10k_htt_rx_crypto_tail_len(ar, enctype));
+        if (status->flag & RX_FLAG_IV_STRIPPED)
+                skb_trim(msdu, msdu->len -
+                         ath10k_htt_rx_crypto_tail_len(ar, enctype));
 
         /* MMIC */
-        if (!ieee80211_has_morefrags(hdr->frame_control) &&
+        if ((status->flag & RX_FLAG_MMIC_STRIPPED) &&
+            !ieee80211_has_morefrags(hdr->frame_control) &&
             enctype == HTT_RX_MPDU_ENCRYPT_TKIP_WPA)
                 skb_trim(msdu, msdu->len - 8);
 
         /* Head */
-        hdr_len = ieee80211_hdrlen(hdr->frame_control);
-        crypto_len = ath10k_htt_rx_crypto_param_len(ar, enctype);
+        if (status->flag & RX_FLAG_IV_STRIPPED) {
+                hdr_len = ieee80211_hdrlen(hdr->frame_control);
+                crypto_len = ath10k_htt_rx_crypto_param_len(ar, enctype);
 
-        memmove((void *)msdu->data + crypto_len,
-                (void *)msdu->data, hdr_len);
-        skb_pull(msdu, crypto_len);
+                memmove((void *)msdu->data + crypto_len,
+                        (void *)msdu->data, hdr_len);
+                skb_pull(msdu, crypto_len);
+        }
 }
 
 static void ath10k_htt_rx_h_undecap_nwifi(struct ath10k *ar,
@@ -1343,6 +1300,7 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar,
         bool has_tkip_err;
         bool has_peer_idx_invalid;
         bool is_decrypted;
+        bool is_mgmt;
         u32 attention;
 
         if (skb_queue_empty(amsdu))
@@ -1351,6 +1309,9 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar,
         first = skb_peek(amsdu);
         rxd = (void *)first->data - sizeof(*rxd);
 
+        is_mgmt = !!(rxd->attention.flags &
+                     __cpu_to_le32(RX_ATTENTION_FLAGS_MGMT_TYPE));
+
         enctype = MS(__le32_to_cpu(rxd->mpdu_start.info0),
                      RX_MPDU_START_INFO0_ENCRYPT_TYPE);
 
@@ -1392,6 +1353,7 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar,
                           RX_FLAG_MMIC_ERROR |
                           RX_FLAG_DECRYPTED |
                           RX_FLAG_IV_STRIPPED |
+                          RX_FLAG_ONLY_MONITOR |
                           RX_FLAG_MMIC_STRIPPED);
 
         if (has_fcs_err)
@@ -1400,10 +1362,21 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar,
         if (has_tkip_err)
                 status->flag |= RX_FLAG_MMIC_ERROR;
 
-        if (is_decrypted)
-                status->flag |= RX_FLAG_DECRYPTED |
-                                RX_FLAG_IV_STRIPPED |
-                                RX_FLAG_MMIC_STRIPPED;
+        /* Firmware reports all necessary management frames via WMI already.
+         * They are not reported to monitor interfaces at all so pass the ones
+         * coming via HTT to monitor interfaces instead. This simplifies
+         * matters a lot.
+         */
+        if (is_mgmt)
+                status->flag |= RX_FLAG_ONLY_MONITOR;
+
+        if (is_decrypted) {
+                status->flag |= RX_FLAG_DECRYPTED;
+
+                if (likely(!is_mgmt))
+                        status->flag |= RX_FLAG_IV_STRIPPED |
+                                        RX_FLAG_MMIC_STRIPPED;
+}
 
         skb_queue_walk(amsdu, msdu) {
                 ath10k_htt_rx_h_csum_offload(msdu);
@@ -1416,6 +1389,8 @@ static void ath10k_htt_rx_h_mpdu(struct ath10k *ar,
                  */
                 if (!is_decrypted)
                         continue;
+                if (is_mgmt)
+                        continue;
 
                 hdr = (void *)msdu->data;
                 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_PROTECTED);
@@ -1516,14 +1491,6 @@ static bool ath10k_htt_rx_amsdu_allowed(struct ath10k *ar,
                                         struct sk_buff_head *amsdu,
                                         struct ieee80211_rx_status *rx_status)
 {
-        struct sk_buff *msdu;
-        struct htt_rx_desc *rxd;
-        bool is_mgmt;
-        bool has_fcs_err;
-
-        msdu = skb_peek(amsdu);
-        rxd = (void *)msdu->data - sizeof(*rxd);
-
         /* FIXME: It might be a good idea to do some fuzzy-testing to drop
          * invalid/dangerous frames.
          */
@@ -1533,23 +1500,6 @@ static bool ath10k_htt_rx_amsdu_allowed(struct ath10k *ar,
                 return false;
         }
 
-        is_mgmt = !!(rxd->attention.flags &
-                     __cpu_to_le32(RX_ATTENTION_FLAGS_MGMT_TYPE));
-        has_fcs_err = !!(rxd->attention.flags &
-                         __cpu_to_le32(RX_ATTENTION_FLAGS_FCS_ERR));
-
-        /* Management frames are handled via WMI events. The pros of such
-         * approach is that channel is explicitly provided in WMI events
-         * whereas HTT doesn't provide channel information for Rxed frames.
-         *
-         * However some firmware revisions don't report corrupted frames via
-         * WMI so don't drop them.
-         */
-        if (is_mgmt && !has_fcs_err) {
-                ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx mgmt ctrl\n");
-                return false;
-        }
-
         if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags)) {
                 ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx cac running\n");
                 return false;
@@ -1571,25 +1521,49 @@ static void ath10k_htt_rx_h_filter(struct ath10k *ar,
         __skb_queue_purge(amsdu);
 }
 
-static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
-                                  struct htt_rx_indication *rx)
+static int ath10k_htt_rx_handle_amsdu(struct ath10k_htt *htt)
 {
         struct ath10k *ar = htt->ar;
-        struct ieee80211_rx_status *rx_status = &htt->rx_status;
-        struct htt_rx_indication_mpdu_range *mpdu_ranges;
+        static struct ieee80211_rx_status rx_status;
         struct sk_buff_head amsdu;
-        int num_mpdu_ranges;
-        int fw_desc_len;
-        u8 *fw_desc;
-        int i, ret, mpdu_count = 0;
+        int ret;
 
-        lockdep_assert_held(&htt->rx_ring.lock);
+        __skb_queue_head_init(&amsdu);
 
-        if (htt->rx_confused)
-                return;
+        spin_lock_bh(&htt->rx_ring.lock);
+        if (htt->rx_confused) {
+                spin_unlock_bh(&htt->rx_ring.lock);
+                return -EIO;
+        }
+        ret = ath10k_htt_rx_amsdu_pop(htt, &amsdu);
+        spin_unlock_bh(&htt->rx_ring.lock);
 
-        fw_desc_len = __le16_to_cpu(rx->prefix.fw_rx_desc_bytes);
-        fw_desc = (u8 *)&rx->fw_desc;
+        if (ret < 0) {
+                ath10k_warn(ar, "rx ring became corrupted: %d\n", ret);
+                __skb_queue_purge(&amsdu);
+                /* FIXME: It's probably a good idea to reboot the
+                 * device instead of leaving it inoperable.
+                 */
+                htt->rx_confused = true;
+                return ret;
+        }
+
+        ath10k_htt_rx_h_ppdu(ar, &amsdu, &rx_status, 0xffff);
+        ath10k_htt_rx_h_unchain(ar, &amsdu, ret > 0);
+        ath10k_htt_rx_h_filter(ar, &amsdu, &rx_status);
+        ath10k_htt_rx_h_mpdu(ar, &amsdu, &rx_status);
+        ath10k_htt_rx_h_deliver(ar, &amsdu, &rx_status);
+
+        return 0;
+}
+
+static void ath10k_htt_rx_proc_rx_ind(struct ath10k_htt *htt,
+                                      struct htt_rx_indication *rx)
+{
+        struct ath10k *ar = htt->ar;
+        struct htt_rx_indication_mpdu_range *mpdu_ranges;
+        int num_mpdu_ranges;
+        int i, mpdu_count = 0;
 
         num_mpdu_ranges = MS(__le32_to_cpu(rx->hdr.info1),
                              HTT_RX_INDICATION_INFO1_NUM_MPDU_RANGES);
@@ -1603,80 +1577,19 @@ static void ath10k_htt_rx_handler(struct ath10k_htt *htt,
         for (i = 0; i < num_mpdu_ranges; i++)
                 mpdu_count += mpdu_ranges[i].mpdu_count;
 
-        while (mpdu_count--) {
-                __skb_queue_head_init(&amsdu);
-                ret = ath10k_htt_rx_amsdu_pop(htt, &fw_desc,
-                                              &fw_desc_len, &amsdu);
-                if (ret < 0) {
-                        ath10k_warn(ar, "rx ring became corrupted: %d\n", ret);
-                        __skb_queue_purge(&amsdu);
-                        /* FIXME: It's probably a good idea to reboot the
-                         * device instead of leaving it inoperable.
-                         */
-                        htt->rx_confused = true;
-                        break;
-                }
+        atomic_add(mpdu_count, &htt->num_mpdus_ready);
 
-                ath10k_htt_rx_h_ppdu(ar, &amsdu, rx_status, 0xffff);
-                ath10k_htt_rx_h_unchain(ar, &amsdu, ret > 0);
-                ath10k_htt_rx_h_filter(ar, &amsdu, rx_status);
-                ath10k_htt_rx_h_mpdu(ar, &amsdu, rx_status);
-                ath10k_htt_rx_h_deliver(ar, &amsdu, rx_status);
-        }
-
-        tasklet_schedule(&htt->rx_replenish_task);
+        tasklet_schedule(&htt->txrx_compl_task);
 }
 
-static void ath10k_htt_rx_frag_handler(struct ath10k_htt *htt,
-                                       struct htt_rx_fragment_indication *frag)
+static void ath10k_htt_rx_frag_handler(struct ath10k_htt *htt)
 {
-        struct ath10k *ar = htt->ar;
-        struct ieee80211_rx_status *rx_status = &htt->rx_status;
-        struct sk_buff_head amsdu;
-        int ret;
-        u8 *fw_desc;
-        int fw_desc_len;
-
-        fw_desc_len = __le16_to_cpu(frag->fw_rx_desc_bytes);
-        fw_desc = (u8 *)frag->fw_msdu_rx_desc;
-
-        __skb_queue_head_init(&amsdu);
+        atomic_inc(&htt->num_mpdus_ready);
 
-        spin_lock_bh(&htt->rx_ring.lock);
-        ret = ath10k_htt_rx_amsdu_pop(htt, &fw_desc, &fw_desc_len,
-                                      &amsdu);
-        spin_unlock_bh(&htt->rx_ring.lock);
-
-        tasklet_schedule(&htt->rx_replenish_task);
-
-        ath10k_dbg(ar, ATH10K_DBG_HTT_DUMP, "htt rx frag ahead\n");
-
-        if (ret) {
-                ath10k_warn(ar, "failed to pop amsdu from httr rx ring for fragmented rx %d\n",
-                            ret);
-                __skb_queue_purge(&amsdu);
-                return;
-        }
-
-        if (skb_queue_len(&amsdu) != 1) {
-                ath10k_warn(ar, "failed to pop frag amsdu: too many msdus\n");
-                __skb_queue_purge(&amsdu);
-                return;
-        }
-
-        ath10k_htt_rx_h_ppdu(ar, &amsdu, rx_status, 0xffff);
-        ath10k_htt_rx_h_filter(ar, &amsdu, rx_status);
-        ath10k_htt_rx_h_mpdu(ar, &amsdu, rx_status);
-        ath10k_htt_rx_h_deliver(ar, &amsdu, rx_status);
-
-        if (fw_desc_len > 0) {
-                ath10k_dbg(ar, ATH10K_DBG_HTT,
-                           "expecting more fragmented rx in one indication %d\n",
-                           fw_desc_len);
-        }
+        tasklet_schedule(&htt->txrx_compl_task);
 }
 
-static void ath10k_htt_rx_frm_tx_compl(struct ath10k *ar,
+static void ath10k_htt_rx_tx_compl_ind(struct ath10k *ar,
                                        struct sk_buff *skb)
 {
         struct ath10k_htt *htt = &ar->htt;
@@ -1688,19 +1601,19 @@ static void ath10k_htt_rx_frm_tx_compl(struct ath10k *ar,
 
         switch (status) {
         case HTT_DATA_TX_STATUS_NO_ACK:
-                tx_done.no_ack = true;
+                tx_done.status = HTT_TX_COMPL_STATE_NOACK;
                 break;
         case HTT_DATA_TX_STATUS_OK:
-                tx_done.success = true;
+                tx_done.status = HTT_TX_COMPL_STATE_ACK;
                 break;
         case HTT_DATA_TX_STATUS_DISCARD:
         case HTT_DATA_TX_STATUS_POSTPONE:
         case HTT_DATA_TX_STATUS_DOWNLOAD_FAIL:
-                tx_done.discard = true;
+                tx_done.status = HTT_TX_COMPL_STATE_DISCARD;
                 break;
         default:
                 ath10k_warn(ar, "unhandled tx completion status %d\n", status);
-                tx_done.discard = true;
+                tx_done.status = HTT_TX_COMPL_STATE_DISCARD;
                 break;
         }
 
@@ -1710,7 +1623,20 @@ static void ath10k_htt_rx_frm_tx_compl(struct ath10k *ar,
         for (i = 0; i < resp->data_tx_completion.num_msdus; i++) {
                 msdu_id = resp->data_tx_completion.msdus[i];
                 tx_done.msdu_id = __le16_to_cpu(msdu_id);
-                ath10k_txrx_tx_unref(htt, &tx_done);
+
+                /* kfifo_put: In practice firmware shouldn't fire off per-CE
+                 * interrupt and main interrupt (MSI/-X range case) for the same
+                 * HTC service so it should be safe to use kfifo_put w/o lock.
+                 *
+                 * From kfifo_put() documentation:
+                 *  Note that with only one concurrent reader and one concurrent
+                 *  writer, you don't need extra locking to use these macro.
+                 */
+                if (!kfifo_put(&htt->txdone_fifo, tx_done)) {
+                        ath10k_warn(ar, "txdone fifo overrun, msdu_id %d status %d\n",
+                                    tx_done.msdu_id, tx_done.status);
+                        ath10k_txrx_tx_unref(htt, &tx_done);
+                }
         }
 }
 
@@ -1978,11 +1904,324 @@ static void ath10k_htt_rx_in_ord_ind(struct ath10k *ar, struct sk_buff *skb)
                         return;
                 }
         }
+        ath10k_htt_rx_msdu_buff_replenish(htt);
+}
+
+static void ath10k_htt_rx_tx_fetch_resp_id_confirm(struct ath10k *ar,
+                                                   const __le32 *resp_ids,
+                                                   int num_resp_ids)
+{
+        int i;
+        u32 resp_id;
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch confirm num_resp_ids %d\n",
+                   num_resp_ids);
+
+        for (i = 0; i < num_resp_ids; i++) {
+                resp_id = le32_to_cpu(resp_ids[i]);
+
+                ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch confirm resp_id %u\n",
+                           resp_id);
+
+                /* TODO: free resp_id */
+        }
+}
+
+static void ath10k_htt_rx_tx_fetch_ind(struct ath10k *ar, struct sk_buff *skb)
+{
+        struct ieee80211_hw *hw = ar->hw;
+        struct ieee80211_txq *txq;
+        struct htt_resp *resp = (struct htt_resp *)skb->data;
+        struct htt_tx_fetch_record *record;
+        size_t len;
+        size_t max_num_bytes;
+        size_t max_num_msdus;
+        size_t num_bytes;
+        size_t num_msdus;
+        const __le32 *resp_ids;
+        u16 num_records;
+        u16 num_resp_ids;
+        u16 peer_id;
+        u8 tid;
+        int ret;
+        int i;
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch ind\n");
+
+        len = sizeof(resp->hdr) + sizeof(resp->tx_fetch_ind);
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_fetch_ind event: buffer too short\n");
+                return;
+        }
+
+        num_records = le16_to_cpu(resp->tx_fetch_ind.num_records);
+        num_resp_ids = le16_to_cpu(resp->tx_fetch_ind.num_resp_ids);
+
+        len += sizeof(resp->tx_fetch_ind.records[0]) * num_records;
+        len += sizeof(resp->tx_fetch_ind.resp_ids[0]) * num_resp_ids;
+
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_fetch_ind event: too many records/resp_ids\n");
+                return;
+        }
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch ind num records %hu num resps %hu seq %hu\n",
+                   num_records, num_resp_ids,
+                   le16_to_cpu(resp->tx_fetch_ind.fetch_seq_num));
+
+        if (!ar->htt.tx_q_state.enabled) {
+                ath10k_warn(ar, "received unexpected tx_fetch_ind event: not enabled\n");
+                return;
+        }
+
+        if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH) {
+                ath10k_warn(ar, "received unexpected tx_fetch_ind event: in push mode\n");
+                return;
+        }
+
+        rcu_read_lock();
+
+        for (i = 0; i < num_records; i++) {
+                record = &resp->tx_fetch_ind.records[i];
+                peer_id = MS(le16_to_cpu(record->info),
+                             HTT_TX_FETCH_RECORD_INFO_PEER_ID);
+                tid = MS(le16_to_cpu(record->info),
+                         HTT_TX_FETCH_RECORD_INFO_TID);
+                max_num_msdus = le16_to_cpu(record->num_msdus);
+                max_num_bytes = le32_to_cpu(record->num_bytes);
+
+                ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch record %i peer_id %hu tid %hhu msdus %zu bytes %zu\n",
+                           i, peer_id, tid, max_num_msdus, max_num_bytes);
+
+                if (unlikely(peer_id >= ar->htt.tx_q_state.num_peers) ||
+                    unlikely(tid >= ar->htt.tx_q_state.num_tids)) {
+                        ath10k_warn(ar, "received out of range peer_id %hu tid %hhu\n",
+                                    peer_id, tid);
+                        continue;
+                }
+
+                spin_lock_bh(&ar->data_lock);
+                txq = ath10k_mac_txq_lookup(ar, peer_id, tid);
+                spin_unlock_bh(&ar->data_lock);
+
+                /* It is okay to release the lock and use txq because RCU read
+                 * lock is held.
+                 */
+
+                if (unlikely(!txq)) {
+                        ath10k_warn(ar, "failed to lookup txq for peer_id %hu tid %hhu\n",
+                                    peer_id, tid);
+                        continue;
+                }
+
+                num_msdus = 0;
+                num_bytes = 0;
+
+                while (num_msdus < max_num_msdus &&
+                       num_bytes < max_num_bytes) {
+                        ret = ath10k_mac_tx_push_txq(hw, txq);
+                        if (ret < 0)
+                                break;
+
+                        num_msdus++;
+                        num_bytes += ret;
+                }
+
+                record->num_msdus = cpu_to_le16(num_msdus);
+                record->num_bytes = cpu_to_le32(num_bytes);
+
+                ath10k_htt_tx_txq_recalc(hw, txq);
+        }
+
+        rcu_read_unlock();
+
+        resp_ids = ath10k_htt_get_tx_fetch_ind_resp_ids(&resp->tx_fetch_ind);
+        ath10k_htt_rx_tx_fetch_resp_id_confirm(ar, resp_ids, num_resp_ids);
+
+        ret = ath10k_htt_tx_fetch_resp(ar,
+                                       resp->tx_fetch_ind.token,
+                                       resp->tx_fetch_ind.fetch_seq_num,
+                                       resp->tx_fetch_ind.records,
+                                       num_records);
+        if (unlikely(ret)) {
+                ath10k_warn(ar, "failed to submit tx fetch resp for token 0x%08x: %d\n",
+                            le32_to_cpu(resp->tx_fetch_ind.token), ret);
+                /* FIXME: request fw restart */
+        }
 
-        tasklet_schedule(&htt->rx_replenish_task);
+        ath10k_htt_tx_txq_sync(ar);
 }
 
-void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
+static void ath10k_htt_rx_tx_fetch_confirm(struct ath10k *ar,
+                                           struct sk_buff *skb)
+{
+        const struct htt_resp *resp = (void *)skb->data;
+        size_t len;
+        int num_resp_ids;
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx fetch confirm\n");
+
+        len = sizeof(resp->hdr) + sizeof(resp->tx_fetch_confirm);
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_fetch_confirm event: buffer too short\n");
+                return;
+        }
+
+        num_resp_ids = le16_to_cpu(resp->tx_fetch_confirm.num_resp_ids);
+        len += sizeof(resp->tx_fetch_confirm.resp_ids[0]) * num_resp_ids;
+
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_fetch_confirm event: resp_ids buffer overflow\n");
+                return;
+        }
+
+        ath10k_htt_rx_tx_fetch_resp_id_confirm(ar,
+                                               resp->tx_fetch_confirm.resp_ids,
+                                               num_resp_ids);
+}
+
+static void ath10k_htt_rx_tx_mode_switch_ind(struct ath10k *ar,
+                                             struct sk_buff *skb)
+{
+        const struct htt_resp *resp = (void *)skb->data;
+        const struct htt_tx_mode_switch_record *record;
+        struct ieee80211_txq *txq;
+        struct ath10k_txq *artxq;
+        size_t len;
+        size_t num_records;
+        enum htt_tx_mode_switch_mode mode;
+        bool enable;
+        u16 info0;
+        u16 info1;
+        u16 threshold;
+        u16 peer_id;
+        u8 tid;
+        int i;
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx tx mode switch ind\n");
+
+        len = sizeof(resp->hdr) + sizeof(resp->tx_mode_switch_ind);
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_mode_switch_ind event: buffer too short\n");
+                return;
+        }
+
+        info0 = le16_to_cpu(resp->tx_mode_switch_ind.info0);
+        info1 = le16_to_cpu(resp->tx_mode_switch_ind.info1);
+
+        enable = !!(info0 & HTT_TX_MODE_SWITCH_IND_INFO0_ENABLE);
+        num_records = MS(info0, HTT_TX_MODE_SWITCH_IND_INFO1_THRESHOLD);
+        mode = MS(info1, HTT_TX_MODE_SWITCH_IND_INFO1_MODE);
+        threshold = MS(info1, HTT_TX_MODE_SWITCH_IND_INFO1_THRESHOLD);
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT,
+                   "htt rx tx mode switch ind info0 0x%04hx info1 0x%04hx enable %d num records %zd mode %d threshold %hu\n",
+                   info0, info1, enable, num_records, mode, threshold);
+
+        len += sizeof(resp->tx_mode_switch_ind.records[0]) * num_records;
+
+        if (unlikely(skb->len < len)) {
+                ath10k_warn(ar, "received corrupted tx_mode_switch_mode_ind event: too many records\n");
+                return;
+        }
+
+        switch (mode) {
+        case HTT_TX_MODE_SWITCH_PUSH:
+        case HTT_TX_MODE_SWITCH_PUSH_PULL:
+                break;
+        default:
+                ath10k_warn(ar, "received invalid tx_mode_switch_mode_ind mode %d, ignoring\n",
+                            mode);
+                return;
+        }
+
+        if (!enable)
+                return;
+
+        ar->htt.tx_q_state.enabled = enable;
+        ar->htt.tx_q_state.mode = mode;
+        ar->htt.tx_q_state.num_push_allowed = threshold;
+
+        rcu_read_lock();
+
+        for (i = 0; i < num_records; i++) {
+                record = &resp->tx_mode_switch_ind.records[i];
+                info0 = le16_to_cpu(record->info0);
+                peer_id = MS(info0, HTT_TX_MODE_SWITCH_RECORD_INFO0_PEER_ID);
+                tid = MS(info0, HTT_TX_MODE_SWITCH_RECORD_INFO0_TID);
+
+                if (unlikely(peer_id >= ar->htt.tx_q_state.num_peers) ||
+                    unlikely(tid >= ar->htt.tx_q_state.num_tids)) {
+                        ath10k_warn(ar, "received out of range peer_id %hu tid %hhu\n",
+                                    peer_id, tid);
+                        continue;
+                }
+
+                spin_lock_bh(&ar->data_lock);
+                txq = ath10k_mac_txq_lookup(ar, peer_id, tid);
+                spin_unlock_bh(&ar->data_lock);
+
+                /* It is okay to release the lock and use txq because RCU read
+                 * lock is held.
+                 */
+
+                if (unlikely(!txq)) {
+                        ath10k_warn(ar, "failed to lookup txq for peer_id %hu tid %hhu\n",
+                                    peer_id, tid);
+                        continue;
+                }
+
+                spin_lock_bh(&ar->htt.tx_lock);
+                artxq = (void *)txq->drv_priv;
+                artxq->num_push_allowed = le16_to_cpu(record->num_max_msdus);
+                spin_unlock_bh(&ar->htt.tx_lock);
+        }
+
+        rcu_read_unlock();
+
+        ath10k_mac_tx_push_pending(ar);
+}
+
+static inline enum nl80211_band phy_mode_to_band(u32 phy_mode)
+{
+        enum nl80211_band band;
+
+        switch (phy_mode) {
+        case MODE_11A:
+        case MODE_11NA_HT20:
+        case MODE_11NA_HT40:
+        case MODE_11AC_VHT20:
+        case MODE_11AC_VHT40:
+        case MODE_11AC_VHT80:
+                band = NL80211_BAND_5GHZ;
+                break;
+        case MODE_11G:
+        case MODE_11B:
+        case MODE_11GONLY:
+        case MODE_11NG_HT20:
+        case MODE_11NG_HT40:
+        case MODE_11AC_VHT20_2G:
+        case MODE_11AC_VHT40_2G:
+        case MODE_11AC_VHT80_2G:
+        default:
+                band = NL80211_BAND_2GHZ;
+        }
+
+        return band;
+}
+
+void ath10k_htt_htc_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
+{
+        bool release;
+
+        release = ath10k_htt_t2h_msg_handler(ar, skb);
+
+        /* Free the indication buffer */
+        if (release)
+                dev_kfree_skb_any(skb);
+}
+
+bool ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
 {
         struct ath10k_htt *htt = &ar->htt;
         struct htt_resp *resp = (struct htt_resp *)skb->data;
@@ -1998,8 +2237,7 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
         if (resp->hdr.msg_type >= ar->htt.t2h_msg_types_max) {
                 ath10k_dbg(ar, ATH10K_DBG_HTT, "htt rx, unsupported msg_type: 0x%0X\n max: 0x%0X",
                            resp->hdr.msg_type, ar->htt.t2h_msg_types_max);
-                dev_kfree_skb_any(skb);
-                return;
+                return true;
         }
         type = ar->htt.t2h_msg_types[resp->hdr.msg_type];
 
@@ -2011,9 +2249,8 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
                 break;
         }
         case HTT_T2H_MSG_TYPE_RX_IND:
-                skb_queue_tail(&htt->rx_compl_q, skb);
-                tasklet_schedule(&htt->txrx_compl_task);
-                return;
+                ath10k_htt_rx_proc_rx_ind(htt, &resp->rx_ind);
+                break;
         case HTT_T2H_MSG_TYPE_PEER_MAP: {
                 struct htt_peer_map_event ev = {
                         .vdev_id = resp->peer_map.vdev_id,
@@ -2034,28 +2271,33 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
                 struct htt_tx_done tx_done = {};
                 int status = __le32_to_cpu(resp->mgmt_tx_completion.status);
 
-                tx_done.msdu_id =
-                        __le32_to_cpu(resp->mgmt_tx_completion.desc_id);
+                tx_done.msdu_id = __le32_to_cpu(resp->mgmt_tx_completion.desc_id);
 
                 switch (status) {
                 case HTT_MGMT_TX_STATUS_OK:
-                        tx_done.success = true;
+                        tx_done.status = HTT_TX_COMPL_STATE_ACK;
                         break;
                 case HTT_MGMT_TX_STATUS_RETRY:
-                        tx_done.no_ack = true;
+                        tx_done.status = HTT_TX_COMPL_STATE_NOACK;
                         break;
                 case HTT_MGMT_TX_STATUS_DROP:
-                        tx_done.discard = true;
+                        tx_done.status = HTT_TX_COMPL_STATE_DISCARD;
                         break;
                 }
 
-                ath10k_txrx_tx_unref(htt, &tx_done);
+                status = ath10k_txrx_tx_unref(htt, &tx_done);
+                if (!status) {
+                        spin_lock_bh(&htt->tx_lock);
+                        ath10k_htt_tx_mgmt_dec_pending(htt);
+                        spin_unlock_bh(&htt->tx_lock);
+                }
+                ath10k_mac_tx_push_pending(ar);
                 break;
         }
         case HTT_T2H_MSG_TYPE_TX_COMPL_IND:
-                skb_queue_tail(&htt->tx_compl_q, skb);
+                ath10k_htt_rx_tx_compl_ind(htt->ar, skb);
                 tasklet_schedule(&htt->txrx_compl_task);
-                return;
+                break;
         case HTT_T2H_MSG_TYPE_SEC_IND: {
                 struct ath10k *ar = htt->ar;
                 struct htt_security_indication *ev = &resp->security_indication;
@@ -2071,7 +2313,7 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
         case HTT_T2H_MSG_TYPE_RX_FRAG_IND: {
                 ath10k_dbg_dump(ar, ATH10K_DBG_HTT_DUMP, NULL, "htt event: ",
                                 skb->data, skb->len);
-                ath10k_htt_rx_frag_handler(htt, &resp->rx_frag_ind);
+                ath10k_htt_rx_frag_handler(htt);
                 break;
         }
         case HTT_T2H_MSG_TYPE_TEST:
@@ -2111,18 +2353,39 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
         case HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND: {
                 skb_queue_tail(&htt->rx_in_ord_compl_q, skb);
                 tasklet_schedule(&htt->txrx_compl_task);
-                return;
+                return false;
         }
         case HTT_T2H_MSG_TYPE_TX_CREDIT_UPDATE_IND:
                 break;
-        case HTT_T2H_MSG_TYPE_CHAN_CHANGE:
+        case HTT_T2H_MSG_TYPE_CHAN_CHANGE: {
+                u32 phymode = __le32_to_cpu(resp->chan_change.phymode);
+                u32 freq = __le32_to_cpu(resp->chan_change.freq);
+
+                ar->tgt_oper_chan =
+                        __ieee80211_get_channel(ar->hw->wiphy, freq);
+                ath10k_dbg(ar, ATH10K_DBG_HTT,
+                           "htt chan change freq %u phymode %s\n",
+                           freq, ath10k_wmi_phymode_str(phymode));
                 break;
+        }
         case HTT_T2H_MSG_TYPE_AGGR_CONF:
                 break;
-        case HTT_T2H_MSG_TYPE_TX_FETCH_IND:
+        case HTT_T2H_MSG_TYPE_TX_FETCH_IND: {
+                struct sk_buff *tx_fetch_ind = skb_copy(skb, GFP_ATOMIC);
+
+                if (!tx_fetch_ind) {
+                        ath10k_warn(ar, "failed to copy htt tx fetch ind\n");
+                        break;
+                }
+                skb_queue_tail(&htt->tx_fetch_ind_q, tx_fetch_ind);
+                tasklet_schedule(&htt->txrx_compl_task);
+                break;
+        }
         case HTT_T2H_MSG_TYPE_TX_FETCH_CONFIRM:
+                ath10k_htt_rx_tx_fetch_confirm(ar, skb);
+                break;
         case HTT_T2H_MSG_TYPE_TX_MODE_SWITCH_IND:
-                /* TODO: Implement pull-push logic */
+                ath10k_htt_rx_tx_mode_switch_ind(ar, skb);
                 break;
         case HTT_T2H_MSG_TYPE_EN_STATS:
         default:
@@ -2132,9 +2395,7 @@ void ath10k_htt_t2h_msg_handler(struct ath10k *ar, struct sk_buff *skb)
                                 skb->data, skb->len);
                 break;
         };
-
-        /* Free the indication buffer */
-        dev_kfree_skb_any(skb);
+        return true;
 }
 EXPORT_SYMBOL(ath10k_htt_t2h_msg_handler);
 
@@ -2150,40 +2411,47 @@ static void ath10k_htt_txrx_compl_task(unsigned long ptr)
 {
         struct ath10k_htt *htt = (struct ath10k_htt *)ptr;
         struct ath10k *ar = htt->ar;
-        struct sk_buff_head tx_q;
-        struct sk_buff_head rx_q;
+        struct htt_tx_done tx_done = {};
         struct sk_buff_head rx_ind_q;
-        struct htt_resp *resp;
+        struct sk_buff_head tx_ind_q;
         struct sk_buff *skb;
         unsigned long flags;
+        int num_mpdus;
 
-        __skb_queue_head_init(&tx_q);
-        __skb_queue_head_init(&rx_q);
         __skb_queue_head_init(&rx_ind_q);
-
-        spin_lock_irqsave(&htt->tx_compl_q.lock, flags);
-        skb_queue_splice_init(&htt->tx_compl_q, &tx_q);
-        spin_unlock_irqrestore(&htt->tx_compl_q.lock, flags);
-
-        spin_lock_irqsave(&htt->rx_compl_q.lock, flags);
-        skb_queue_splice_init(&htt->rx_compl_q, &rx_q);
-        spin_unlock_irqrestore(&htt->rx_compl_q.lock, flags);
+        __skb_queue_head_init(&tx_ind_q);
 
         spin_lock_irqsave(&htt->rx_in_ord_compl_q.lock, flags);
         skb_queue_splice_init(&htt->rx_in_ord_compl_q, &rx_ind_q);
         spin_unlock_irqrestore(&htt->rx_in_ord_compl_q.lock, flags);
 
-        while ((skb = __skb_dequeue(&tx_q))) {
-                ath10k_htt_rx_frm_tx_compl(htt->ar, skb);
+        spin_lock_irqsave(&htt->tx_fetch_ind_q.lock, flags);
+        skb_queue_splice_init(&htt->tx_fetch_ind_q, &tx_ind_q);
+        spin_unlock_irqrestore(&htt->tx_fetch_ind_q.lock, flags);
+
+        /* kfifo_get: called only within txrx_tasklet so it's neatly serialized.
+         * From kfifo_get() documentation:
+         *  Note that with only one concurrent reader and one concurrent writer,
+         *  you don't need extra locking to use these macro.
+         */
+        while (kfifo_get(&htt->txdone_fifo, &tx_done))
+                ath10k_txrx_tx_unref(htt, &tx_done);
+
+        while ((skb = __skb_dequeue(&tx_ind_q))) {
+                ath10k_htt_rx_tx_fetch_ind(ar, skb);
                 dev_kfree_skb_any(skb);
         }
 
-        while ((skb = __skb_dequeue(&rx_q))) {
-                resp = (struct htt_resp *)skb->data;
-                spin_lock_bh(&htt->rx_ring.lock);
-                ath10k_htt_rx_handler(htt, &resp->rx_ind);
-                spin_unlock_bh(&htt->rx_ring.lock);
-                dev_kfree_skb_any(skb);
+        ath10k_mac_tx_push_pending(ar);
+
+        num_mpdus = atomic_read(&htt->num_mpdus_ready);
+
+        while (num_mpdus) {
+                if (ath10k_htt_rx_handle_amsdu(htt))
+                        break;
+
+                num_mpdus--;
+                atomic_dec(&htt->num_mpdus_ready);
         }
 
         while ((skb = __skb_dequeue(&rx_ind_q))) {
@@ -2192,4 +2460,6 @@ static void ath10k_htt_txrx_compl_task(unsigned long ptr)
                 spin_unlock_bh(&htt->rx_ring.lock);
                 dev_kfree_skb_any(skb);
         }
+
+        ath10k_htt_rx_msdu_buff_replenish(htt);
 }
diff --git a/drivers/net/wireless/ath/ath10k/htt_tx.c b/drivers/net/wireless/ath/ath10k/htt_tx.c
index 95acb727c068..9baa2e677f8a 100644
--- a/drivers/net/wireless/ath/ath10k/htt_tx.c
+++ b/drivers/net/wireless/ath/ath10k/htt_tx.c
@@ -22,53 +22,183 @@
 #include "txrx.h"
 #include "debug.h"
 
-void __ath10k_htt_tx_dec_pending(struct ath10k_htt *htt, bool limit_mgmt_desc)
+static u8 ath10k_htt_tx_txq_calc_size(size_t count)
 {
-        if (limit_mgmt_desc)
-                htt->num_pending_mgmt_tx--;
+        int exp;
+        int factor;
+
+        exp = 0;
+        factor = count >> 7;
+
+        while (factor >= 64 && exp < 4) {
+                factor >>= 3;
+                exp++;
+        }
+
+        if (exp == 4)
+                return 0xff;
+
+        if (count > 0)
+                factor = max(1, factor);
+
+        return SM(exp, HTT_TX_Q_STATE_ENTRY_EXP) |
+               SM(factor, HTT_TX_Q_STATE_ENTRY_FACTOR);
+}
+
+static void __ath10k_htt_tx_txq_recalc(struct ieee80211_hw *hw,
+                                       struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+        struct ath10k_sta *arsta = (void *)txq->sta->drv_priv;
+        struct ath10k_vif *arvif = (void *)txq->vif->drv_priv;
+        unsigned long frame_cnt;
+        unsigned long byte_cnt;
+        int idx;
+        u32 bit;
+        u16 peer_id;
+        u8 tid;
+        u8 count;
+
+        lockdep_assert_held(&ar->htt.tx_lock);
+
+        if (!ar->htt.tx_q_state.enabled)
+                return;
+
+        if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH_PULL)
+                return;
+
+        if (txq->sta)
+                peer_id = arsta->peer_id;
+        else
+                peer_id = arvif->peer_id;
+
+        tid = txq->tid;
+        bit = BIT(peer_id % 32);
+        idx = peer_id / 32;
+
+        ieee80211_txq_get_depth(txq, &frame_cnt, &byte_cnt);
+        count = ath10k_htt_tx_txq_calc_size(byte_cnt);
+
+        if (unlikely(peer_id >= ar->htt.tx_q_state.num_peers) ||
+            unlikely(tid >= ar->htt.tx_q_state.num_tids)) {
+                ath10k_warn(ar, "refusing to update txq for peer_id %hu tid %hhu due to out of bounds\n",
+                            peer_id, tid);
+                return;
+        }
+
+        ar->htt.tx_q_state.vaddr->count[tid][peer_id] = count;
+        ar->htt.tx_q_state.vaddr->map[tid][idx] &= ~bit;
+        ar->htt.tx_q_state.vaddr->map[tid][idx] |= count ? bit : 0;
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx txq state update peer_id %hu tid %hhu count %hhu\n",
+                   peer_id, tid, count);
+}
+
+static void __ath10k_htt_tx_txq_sync(struct ath10k *ar)
+{
+        u32 seq;
+        size_t size;
+
+        lockdep_assert_held(&ar->htt.tx_lock);
+
+        if (!ar->htt.tx_q_state.enabled)
+                return;
+
+        if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH_PULL)
+                return;
+
+        seq = le32_to_cpu(ar->htt.tx_q_state.vaddr->seq);
+        seq++;
+        ar->htt.tx_q_state.vaddr->seq = cpu_to_le32(seq);
+
+        ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx txq state update commit seq %u\n",
+                   seq);
+
+        size = sizeof(*ar->htt.tx_q_state.vaddr);
+        dma_sync_single_for_device(ar->dev,
+                                   ar->htt.tx_q_state.paddr,
+                                   size,
+                                   DMA_TO_DEVICE);
+}
+
+void ath10k_htt_tx_txq_recalc(struct ieee80211_hw *hw,
+                              struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+
+        spin_lock_bh(&ar->htt.tx_lock);
+        __ath10k_htt_tx_txq_recalc(hw, txq);
+        spin_unlock_bh(&ar->htt.tx_lock);
+}
+
+void ath10k_htt_tx_txq_sync(struct ath10k *ar)
+{
+        spin_lock_bh(&ar->htt.tx_lock);
+        __ath10k_htt_tx_txq_sync(ar);
+        spin_unlock_bh(&ar->htt.tx_lock);
+}
+
+void ath10k_htt_tx_txq_update(struct ieee80211_hw *hw,
+                              struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+
+        spin_lock_bh(&ar->htt.tx_lock);
+        __ath10k_htt_tx_txq_recalc(hw, txq);
+        __ath10k_htt_tx_txq_sync(ar);
+        spin_unlock_bh(&ar->htt.tx_lock);
+}
+
+void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt)
+{
+        lockdep_assert_held(&htt->tx_lock);
 
         htt->num_pending_tx--;
         if (htt->num_pending_tx == htt->max_num_pending_tx - 1)
                 ath10k_mac_tx_unlock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
 }
 
-static void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt,
-                                      bool limit_mgmt_desc)
+int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt)
 {
-        spin_lock_bh(&htt->tx_lock);
-        __ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
-        spin_unlock_bh(&htt->tx_lock);
+        lockdep_assert_held(&htt->tx_lock);
+
+        if (htt->num_pending_tx >= htt->max_num_pending_tx)
+                return -EBUSY;
+
+        htt->num_pending_tx++;
+        if (htt->num_pending_tx == htt->max_num_pending_tx)
+                ath10k_mac_tx_lock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
+
+        return 0;
 }
 
-static int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt,
-                                     bool limit_mgmt_desc, bool is_probe_resp)
+int ath10k_htt_tx_mgmt_inc_pending(struct ath10k_htt *htt, bool is_mgmt,
+                                   bool is_presp)
 {
         struct ath10k *ar = htt->ar;
-        int ret = 0;
 
-        spin_lock_bh(&htt->tx_lock);
+        lockdep_assert_held(&htt->tx_lock);
 
-        if (htt->num_pending_tx >= htt->max_num_pending_tx) {
-                ret = -EBUSY;
-                goto exit;
-        }
+        if (!is_mgmt || !ar->hw_params.max_probe_resp_desc_thres)
+                return 0;
 
-        if (limit_mgmt_desc) {
-                if (is_probe_resp && (htt->num_pending_mgmt_tx >
-                    ar->hw_params.max_probe_resp_desc_thres)) {
-                        ret = -EBUSY;
-                        goto exit;
-                }
-                htt->num_pending_mgmt_tx++;
-        }
+        if (is_presp &&
+            ar->hw_params.max_probe_resp_desc_thres < htt->num_pending_mgmt_tx)
+                return -EBUSY;
 
-        htt->num_pending_tx++;
-        if (htt->num_pending_tx == htt->max_num_pending_tx)
-                ath10k_mac_tx_lock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
+        htt->num_pending_mgmt_tx++;
 
-exit:
-        spin_unlock_bh(&htt->tx_lock);
-        return ret;
+        return 0;
+}
+
+void ath10k_htt_tx_mgmt_dec_pending(struct ath10k_htt *htt)
+{
+        lockdep_assert_held(&htt->tx_lock);
+
+        if (!htt->ar->hw_params.max_probe_resp_desc_thres)
+                return;
+
+        htt->num_pending_mgmt_tx--;
 }
 
 int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt, struct sk_buff *skb)
@@ -209,8 +339,18 @@ int ath10k_htt_tx_alloc(struct ath10k_htt *htt)
                 goto free_frag_desc;
         }
 
+        size = roundup_pow_of_two(htt->max_num_pending_tx);
+        ret = kfifo_alloc(&htt->txdone_fifo, size, GFP_KERNEL);
+        if (ret) {
+                ath10k_err(ar, "failed to alloc txdone fifo: %d\n", ret);
+                goto free_txq;
+        }
+
         return 0;
 
+free_txq:
+        ath10k_htt_tx_free_txq(htt);
+
 free_frag_desc:
         ath10k_htt_tx_free_cont_frag_desc(htt);
 
@@ -234,8 +374,8 @@ static int ath10k_htt_tx_clean_up_pending(int msdu_id, void *skb, void *ctx)
 
         ath10k_dbg(ar, ATH10K_DBG_HTT, "force cleanup msdu_id %hu\n", msdu_id);
 
-        tx_done.discard = 1;
         tx_done.msdu_id = msdu_id;
+        tx_done.status = HTT_TX_COMPL_STATE_DISCARD;
 
         ath10k_txrx_tx_unref(htt, &tx_done);
 
@@ -258,6 +398,8 @@ void ath10k_htt_tx_free(struct ath10k_htt *htt)
 
         ath10k_htt_tx_free_txq(htt);
         ath10k_htt_tx_free_cont_frag_desc(htt);
+        WARN_ON(!kfifo_is_empty(&htt->txdone_fifo));
+        kfifo_free(&htt->txdone_fifo);
 }
 
 void ath10k_htt_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb)
@@ -535,6 +677,55 @@ int ath10k_htt_h2t_aggr_cfg_msg(struct ath10k_htt *htt,
         return 0;
 }
 
+int ath10k_htt_tx_fetch_resp(struct ath10k *ar,
+                             __le32 token,
+                             __le16 fetch_seq_num,
+                             struct htt_tx_fetch_record *records,
+                             size_t num_records)
+{
+        struct sk_buff *skb;
+        struct htt_cmd *cmd;
+        const u16 resp_id = 0;
+        int len = 0;
+        int ret;
+
+        /* Response IDs are echo-ed back only for host driver convienence
+         * purposes. They aren't used for anything in the driver yet so use 0.
+         */
+
+        len += sizeof(cmd->hdr);
+        len += sizeof(cmd->tx_fetch_resp);
+        len += sizeof(cmd->tx_fetch_resp.records[0]) * num_records;
+
+        skb = ath10k_htc_alloc_skb(ar, len);
+        if (!skb)
+                return -ENOMEM;
+
+        skb_put(skb, len);
+        cmd = (struct htt_cmd *)skb->data;
+        cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_TX_FETCH_RESP;
+        cmd->tx_fetch_resp.resp_id = cpu_to_le16(resp_id);
+        cmd->tx_fetch_resp.fetch_seq_num = fetch_seq_num;
+        cmd->tx_fetch_resp.num_records = cpu_to_le16(num_records);
+        cmd->tx_fetch_resp.token = token;
+
+        memcpy(cmd->tx_fetch_resp.records, records,
+               sizeof(records[0]) * num_records);
+
+        ret = ath10k_htc_send(&ar->htc, ar->htt.eid, skb);
+        if (ret) {
+                ath10k_warn(ar, "failed to submit htc command: %d\n", ret);
+                goto err_free_skb;
+        }
+
+        return 0;
+
+err_free_skb:
+        dev_kfree_skb_any(skb);
+
+        return ret;
+}
+
 static u8 ath10k_htt_tx_get_vdev_id(struct ath10k *ar, struct sk_buff *skb)
 {
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
@@ -576,20 +767,6 @@ int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
         int msdu_id = -1;
         int res;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data;
-        bool limit_mgmt_desc = false;
-        bool is_probe_resp = false;
-
-        if (ar->hw_params.max_probe_resp_desc_thres) {
-                limit_mgmt_desc = true;
-
-                if (ieee80211_is_probe_resp(hdr->frame_control))
-                        is_probe_resp = true;
-        }
-
-        res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp);
-
-        if (res)
-                goto err;
 
         len += sizeof(cmd->hdr);
         len += sizeof(cmd->mgmt_tx);
@@ -598,7 +775,7 @@ int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
         res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
         spin_unlock_bh(&htt->tx_lock);
         if (res < 0)
-                goto err_tx_dec;
+                goto err;
 
         msdu_id = res;
 
@@ -649,8 +826,6 @@ err_free_msdu_id:
         spin_lock_bh(&htt->tx_lock);
         ath10k_htt_tx_free_msdu_id(htt, msdu_id);
         spin_unlock_bh(&htt->tx_lock);
-err_tx_dec:
-        ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
 err:
         return res;
 }
@@ -677,26 +852,12 @@ int ath10k_htt_tx(struct ath10k_htt *htt, enum ath10k_hw_txrx_mode txmode,
         u32 frags_paddr = 0;
         u32 txbuf_paddr;
         struct htt_msdu_ext_desc *ext_desc = NULL;
-        bool limit_mgmt_desc = false;
-        bool is_probe_resp = false;
-
-        if (unlikely(ieee80211_is_mgmt(hdr->frame_control)) &&
-            ar->hw_params.max_probe_resp_desc_thres) {
-                limit_mgmt_desc = true;
-
-                if (ieee80211_is_probe_resp(hdr->frame_control))
-                        is_probe_resp = true;
-        }
-
-        res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp);
-        if (res)
-                goto err;
 
         spin_lock_bh(&htt->tx_lock);
         res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
         spin_unlock_bh(&htt->tx_lock);
         if (res < 0)
-                goto err_tx_dec;
+                goto err;
 
         msdu_id = res;
 
@@ -862,11 +1023,7 @@ int ath10k_htt_tx(struct ath10k_htt *htt, enum ath10k_hw_txrx_mode txmode,
 err_unmap_msdu:
         dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
 err_free_msdu_id:
-        spin_lock_bh(&htt->tx_lock);
         ath10k_htt_tx_free_msdu_id(htt, msdu_id);
-        spin_unlock_bh(&htt->tx_lock);
-err_tx_dec:
-        ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
 err:
         return res;
 }
diff --git a/drivers/net/wireless/ath/ath10k/hw.h b/drivers/net/wireless/ath/ath10k/hw.h
index f0cfbc745c97..c0179bc4af29 100644
--- a/drivers/net/wireless/ath/ath10k/hw.h
+++ b/drivers/net/wireless/ath/ath10k/hw.h
@@ -134,8 +134,6 @@ enum qca9377_chip_id_rev {
 
 #define REG_DUMP_COUNT_QCA988X 60
 
-#define QCA988X_CAL_DATA_LEN            2116
-
 struct ath10k_fw_ie {
         __le32 id;
         __le32 len;
@@ -431,10 +429,14 @@ enum ath10k_hw_4addr_pad {
 #define TARGET_10_4_ACTIVE_PEERS                0
 
 #define TARGET_10_4_NUM_QCACHE_PEERS_MAX        512
+#define TARGET_10_4_QCACHE_ACTIVE_PEERS         50
+#define TARGET_10_4_QCACHE_ACTIVE_PEERS_PFC     35
 #define TARGET_10_4_NUM_OFFLOAD_PEERS           0
 #define TARGET_10_4_NUM_OFFLOAD_REORDER_BUFFS   0
 #define TARGET_10_4_NUM_PEER_KEYS               2
 #define TARGET_10_4_TGT_NUM_TIDS                ((TARGET_10_4_NUM_PEERS) * 2)
+#define TARGET_10_4_NUM_MSDU_DESC               (1024 + 400)
+#define TARGET_10_4_NUM_MSDU_DESC_PFC           2500
 #define TARGET_10_4_AST_SKID_LIMIT              32
 
 /* 100 ms for video, best-effort, and background */
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index 78999c9de23b..6ace10bc96f5 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -482,7 +482,7 @@ chan_to_phymode(const struct cfg80211_chan_def *chandef)
         enum wmi_phy_mode phymode = MODE_UNKNOWN;
 
         switch (chandef->chan->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 switch (chandef->width) {
                 case NL80211_CHAN_WIDTH_20_NOHT:
                         if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
@@ -505,7 +505,7 @@ chan_to_phymode(const struct cfg80211_chan_def *chandef)
                         break;
                 }
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 switch (chandef->width) {
                 case NL80211_CHAN_WIDTH_20_NOHT:
                         phymode = MODE_11A;
@@ -618,10 +618,15 @@ ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
         *def = &conf->def;
 }
 
-static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
+static int ath10k_peer_create(struct ath10k *ar,
+                              struct ieee80211_vif *vif,
+                              struct ieee80211_sta *sta,
+                              u32 vdev_id,
+                              const u8 *addr,
                               enum wmi_peer_type peer_type)
 {
         struct ath10k_vif *arvif;
+        struct ath10k_peer *peer;
         int num_peers = 0;
         int ret;
 
@@ -650,6 +655,22 @@ static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
                 return ret;
         }
 
+        spin_lock_bh(&ar->data_lock);
+
+        peer = ath10k_peer_find(ar, vdev_id, addr);
+        if (!peer) {
+                ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n",
+                            addr, vdev_id);
+                ath10k_wmi_peer_delete(ar, vdev_id, addr);
+                spin_unlock_bh(&ar->data_lock);
+                return -ENOENT;
+        }
+
+        peer->vif = vif;
+        peer->sta = sta;
+
+        spin_unlock_bh(&ar->data_lock);
+
         ar->num_peers++;
 
         return 0;
@@ -731,6 +752,7 @@ static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
 {
         struct ath10k_peer *peer, *tmp;
+        int peer_id;
 
         lockdep_assert_held(&ar->conf_mutex);
 
@@ -742,6 +764,11 @@ static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
                 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
                             peer->addr, vdev_id);
 
+                for_each_set_bit(peer_id, peer->peer_ids,
+                                 ATH10K_MAX_NUM_PEER_IDS) {
+                        ar->peer_map[peer_id] = NULL;
+                }
+
                 list_del(&peer->list);
                 kfree(peer);
                 ar->num_peers--;
@@ -2028,7 +2055,7 @@ static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
         struct cfg80211_chan_def def;
         const struct ieee80211_supported_band *sband;
         const struct ieee80211_rate *rates;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u32 ratemask;
         u8 rate;
         int i;
@@ -2088,7 +2115,7 @@ static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
         const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
         struct cfg80211_chan_def def;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const u8 *ht_mcs_mask;
         const u16 *vht_mcs_mask;
         int i, n;
@@ -2312,7 +2339,7 @@ static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
         const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
         struct cfg80211_chan_def def;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const u16 *vht_mcs_mask;
         u8 ampdu_factor;
 
@@ -2330,7 +2357,7 @@ static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
 
         arg->peer_flags |= ar->wmi.peer_flags->vht;
 
-        if (def.chan->band == IEEE80211_BAND_2GHZ)
+        if (def.chan->band == NL80211_BAND_2GHZ)
                 arg->peer_flags |= ar->wmi.peer_flags->vht_2g;
 
         arg->peer_vht_caps = vht_cap->cap;
@@ -2399,7 +2426,7 @@ static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
 
 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
 {
-        return sta->supp_rates[IEEE80211_BAND_2GHZ] >>
+        return sta->supp_rates[NL80211_BAND_2GHZ] >>
                ATH10K_MAC_FIRST_OFDM_RATE_IDX;
 }
 
@@ -2410,7 +2437,7 @@ static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
 {
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
         struct cfg80211_chan_def def;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const u8 *ht_mcs_mask;
         const u16 *vht_mcs_mask;
         enum wmi_phy_mode phymode = MODE_UNKNOWN;
@@ -2423,7 +2450,7 @@ static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
 
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 if (sta->vht_cap.vht_supported &&
                     !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
@@ -2443,7 +2470,7 @@ static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
                 }
 
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 /*
                  * Check VHT first.
                  */
@@ -2821,7 +2848,7 @@ static int ath10k_update_channel_list(struct ath10k *ar)
 {
         struct ieee80211_hw *hw = ar->hw;
         struct ieee80211_supported_band **bands;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_channel *channel;
         struct wmi_scan_chan_list_arg arg = {0};
         struct wmi_channel_arg *ch;
@@ -2833,7 +2860,7 @@ static int ath10k_update_channel_list(struct ath10k *ar)
         lockdep_assert_held(&ar->conf_mutex);
 
         bands = hw->wiphy->bands;
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 if (!bands[band])
                         continue;
 
@@ -2852,7 +2879,7 @@ static int ath10k_update_channel_list(struct ath10k *ar)
                 return -ENOMEM;
 
         ch = arg.channels;
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 if (!bands[band])
                         continue;
 
@@ -2890,7 +2917,7 @@ static int ath10k_update_channel_list(struct ath10k *ar)
                         /* FIXME: why use only legacy modes, why not any
                          * HT/VHT modes? Would that even make any
                          * difference? */
-                        if (channel->band == IEEE80211_BAND_2GHZ)
+                        if (channel->band == NL80211_BAND_2GHZ)
                                 ch->mode = MODE_11G;
                         else
                                 ch->mode = MODE_11A;
@@ -2994,6 +3021,13 @@ static void ath10k_reg_notifier(struct wiphy *wiphy,
 /* TX handlers */
 /***************/
 
+enum ath10k_mac_tx_path {
+        ATH10K_MAC_TX_HTT,
+        ATH10K_MAC_TX_HTT_MGMT,
+        ATH10K_MAC_TX_WMI_MGMT,
+        ATH10K_MAC_TX_UNKNOWN,
+};
+
 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
 {
         lockdep_assert_held(&ar->htt.tx_lock);
@@ -3271,6 +3305,28 @@ static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
         }
 }
 
+static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar,
+                                    struct ieee80211_vif *vif,
+                                    struct ieee80211_txq *txq,
+                                    struct sk_buff *skb)
+{
+        struct ieee80211_hdr *hdr = (void *)skb->data;
+        struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
+
+        cb->flags = 0;
+        if (!ath10k_tx_h_use_hwcrypto(vif, skb))
+                cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
+
+        if (ieee80211_is_mgmt(hdr->frame_control))
+                cb->flags |= ATH10K_SKB_F_MGMT;
+
+        if (ieee80211_is_data_qos(hdr->frame_control))
+                cb->flags |= ATH10K_SKB_F_QOS;
+
+        cb->vif = vif;
+        cb->txq = txq;
+}
+
 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
 {
         /* FIXME: Not really sure since when the behaviour changed. At some
@@ -3306,26 +3362,50 @@ unlock:
         return ret;
 }
 
-static void ath10k_mac_tx(struct ath10k *ar, enum ath10k_hw_txrx_mode txmode,
-                          struct sk_buff *skb)
+static enum ath10k_mac_tx_path
+ath10k_mac_tx_h_get_txpath(struct ath10k *ar,
+                           struct sk_buff *skb,
+                           enum ath10k_hw_txrx_mode txmode)
 {
-        struct ath10k_htt *htt = &ar->htt;
-        int ret = 0;
-
         switch (txmode) {
         case ATH10K_HW_TXRX_RAW:
         case ATH10K_HW_TXRX_NATIVE_WIFI:
         case ATH10K_HW_TXRX_ETHERNET:
-                ret = ath10k_htt_tx(htt, txmode, skb);
-                break;
+                return ATH10K_MAC_TX_HTT;
         case ATH10K_HW_TXRX_MGMT:
                 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
                              ar->fw_features))
-                        ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
+                        return ATH10K_MAC_TX_WMI_MGMT;
                 else if (ar->htt.target_version_major >= 3)
-                        ret = ath10k_htt_tx(htt, txmode, skb);
+                        return ATH10K_MAC_TX_HTT;
                 else
-                        ret = ath10k_htt_mgmt_tx(htt, skb);
+                        return ATH10K_MAC_TX_HTT_MGMT;
+        }
+
+        return ATH10K_MAC_TX_UNKNOWN;
+}
+
+static int ath10k_mac_tx_submit(struct ath10k *ar,
+                                enum ath10k_hw_txrx_mode txmode,
+                                enum ath10k_mac_tx_path txpath,
+                                struct sk_buff *skb)
+{
+        struct ath10k_htt *htt = &ar->htt;
+        int ret = -EINVAL;
+
+        switch (txpath) {
+        case ATH10K_MAC_TX_HTT:
+                ret = ath10k_htt_tx(htt, txmode, skb);
+                break;
+        case ATH10K_MAC_TX_HTT_MGMT:
+                ret = ath10k_htt_mgmt_tx(htt, skb);
+                break;
+        case ATH10K_MAC_TX_WMI_MGMT:
+                ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
+                break;
+        case ATH10K_MAC_TX_UNKNOWN:
+                WARN_ON_ONCE(1);
+                ret = -EINVAL;
                 break;
         }
 
@@ -3334,6 +3414,64 @@ static void ath10k_mac_tx(struct ath10k *ar, enum ath10k_hw_txrx_mode txmode,
                             ret);
                 ieee80211_free_txskb(ar->hw, skb);
         }
+
+        return ret;
+}
+
+/* This function consumes the sk_buff regardless of return value as far as
+ * caller is concerned so no freeing is necessary afterwards.
+ */
+static int ath10k_mac_tx(struct ath10k *ar,
+                         struct ieee80211_vif *vif,
+                         struct ieee80211_sta *sta,
+                         enum ath10k_hw_txrx_mode txmode,
+                         enum ath10k_mac_tx_path txpath,
+                         struct sk_buff *skb)
+{
+        struct ieee80211_hw *hw = ar->hw;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+        int ret;
+
+        /* We should disable CCK RATE due to P2P */
+        if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
+                ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
+
+        switch (txmode) {
+        case ATH10K_HW_TXRX_MGMT:
+        case ATH10K_HW_TXRX_NATIVE_WIFI:
+                ath10k_tx_h_nwifi(hw, skb);
+                ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
+                ath10k_tx_h_seq_no(vif, skb);
+                break;
+        case ATH10K_HW_TXRX_ETHERNET:
+                ath10k_tx_h_8023(skb);
+                break;
+        case ATH10K_HW_TXRX_RAW:
+                if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
+                        WARN_ON_ONCE(1);
+                        ieee80211_free_txskb(hw, skb);
+                        return -ENOTSUPP;
+                }
+        }
+
+        if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
+                if (!ath10k_mac_tx_frm_has_freq(ar)) {
+                        ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
+                                   skb);
+
+                        skb_queue_tail(&ar->offchan_tx_queue, skb);
+                        ieee80211_queue_work(hw, &ar->offchan_tx_work);
+                        return 0;
+                }
+        }
+
+        ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb);
+        if (ret) {
+                ath10k_warn(ar, "failed to submit frame: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
 }
 
 void ath10k_offchan_tx_purge(struct ath10k *ar)
@@ -3354,12 +3492,13 @@ void ath10k_offchan_tx_work(struct work_struct *work)
         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
         struct ath10k_peer *peer;
         struct ath10k_vif *arvif;
+        enum ath10k_hw_txrx_mode txmode;
+        enum ath10k_mac_tx_path txpath;
         struct ieee80211_hdr *hdr;
         struct ieee80211_vif *vif;
         struct ieee80211_sta *sta;
         struct sk_buff *skb;
         const u8 *peer_addr;
-        enum ath10k_hw_txrx_mode txmode;
         int vdev_id;
         int ret;
         unsigned long time_left;
@@ -3396,7 +3535,8 @@ void ath10k_offchan_tx_work(struct work_struct *work)
                                    peer_addr, vdev_id);
 
                 if (!peer) {
-                        ret = ath10k_peer_create(ar, vdev_id, peer_addr,
+                        ret = ath10k_peer_create(ar, NULL, NULL, vdev_id,
+                                                 peer_addr,
                                                  WMI_PEER_TYPE_DEFAULT);
                         if (ret)
                                 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
@@ -3423,8 +3563,14 @@ void ath10k_offchan_tx_work(struct work_struct *work)
                 }
 
                 txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
+                txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
 
-                ath10k_mac_tx(ar, txmode, skb);
+                ret = ath10k_mac_tx(ar, vif, sta, txmode, txpath, skb);
+                if (ret) {
+                        ath10k_warn(ar, "failed to transmit offchannel frame: %d\n",
+                                    ret);
+                        /* not serious */
+                }
 
                 time_left =
                 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
@@ -3476,6 +3622,175 @@ void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
         }
 }
 
+static void ath10k_mac_txq_init(struct ieee80211_txq *txq)
+{
+        struct ath10k_txq *artxq = (void *)txq->drv_priv;
+
+        if (!txq)
+                return;
+
+        INIT_LIST_HEAD(&artxq->list);
+}
+
+static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq)
+{
+        struct ath10k_txq *artxq = (void *)txq->drv_priv;
+        struct ath10k_skb_cb *cb;
+        struct sk_buff *msdu;
+        int msdu_id;
+
+        if (!txq)
+                return;
+
+        spin_lock_bh(&ar->txqs_lock);
+        if (!list_empty(&artxq->list))
+                list_del_init(&artxq->list);
+        spin_unlock_bh(&ar->txqs_lock);
+
+        spin_lock_bh(&ar->htt.tx_lock);
+        idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) {
+                cb = ATH10K_SKB_CB(msdu);
+                if (cb->txq == txq)
+                        cb->txq = NULL;
+        }
+        spin_unlock_bh(&ar->htt.tx_lock);
+}
+
+struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar,
+                                            u16 peer_id,
+                                            u8 tid)
+{
+        struct ath10k_peer *peer;
+
+        lockdep_assert_held(&ar->data_lock);
+
+        peer = ar->peer_map[peer_id];
+        if (!peer)
+                return NULL;
+
+        if (peer->sta)
+                return peer->sta->txq[tid];
+        else if (peer->vif)
+                return peer->vif->txq;
+        else
+                return NULL;
+}
+
+static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw,
+                                   struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+        struct ath10k_txq *artxq = (void *)txq->drv_priv;
+
+        /* No need to get locks */
+
+        if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH)
+                return true;
+
+        if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed)
+                return true;
+
+        if (artxq->num_fw_queued < artxq->num_push_allowed)
+                return true;
+
+        return false;
+}
+
+int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw,
+                           struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+        struct ath10k_htt *htt = &ar->htt;
+        struct ath10k_txq *artxq = (void *)txq->drv_priv;
+        struct ieee80211_vif *vif = txq->vif;
+        struct ieee80211_sta *sta = txq->sta;
+        enum ath10k_hw_txrx_mode txmode;
+        enum ath10k_mac_tx_path txpath;
+        struct sk_buff *skb;
+        size_t skb_len;
+        int ret;
+
+        spin_lock_bh(&ar->htt.tx_lock);
+        ret = ath10k_htt_tx_inc_pending(htt);
+        spin_unlock_bh(&ar->htt.tx_lock);
+
+        if (ret)
+                return ret;
+
+        skb = ieee80211_tx_dequeue(hw, txq);
+        if (!skb) {
+                spin_lock_bh(&ar->htt.tx_lock);
+                ath10k_htt_tx_dec_pending(htt);
+                spin_unlock_bh(&ar->htt.tx_lock);
+
+                return -ENOENT;
+        }
+
+        ath10k_mac_tx_h_fill_cb(ar, vif, txq, skb);
+
+        skb_len = skb->len;
+        txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
+        txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
+
+        ret = ath10k_mac_tx(ar, vif, sta, txmode, txpath, skb);
+        if (unlikely(ret)) {
+                ath10k_warn(ar, "failed to push frame: %d\n", ret);
+
+                spin_lock_bh(&ar->htt.tx_lock);
+                ath10k_htt_tx_dec_pending(htt);
+                spin_unlock_bh(&ar->htt.tx_lock);
+
+                return ret;
+        }
+
+        spin_lock_bh(&ar->htt.tx_lock);
+        artxq->num_fw_queued++;
+        spin_unlock_bh(&ar->htt.tx_lock);
+
+        return skb_len;
+}
+
+void ath10k_mac_tx_push_pending(struct ath10k *ar)
+{
+        struct ieee80211_hw *hw = ar->hw;
+        struct ieee80211_txq *txq;
+        struct ath10k_txq *artxq;
+        struct ath10k_txq *last;
+        int ret;
+        int max;
+
+        spin_lock_bh(&ar->txqs_lock);
+        rcu_read_lock();
+
+        last = list_last_entry(&ar->txqs, struct ath10k_txq, list);
+        while (!list_empty(&ar->txqs)) {
+                artxq = list_first_entry(&ar->txqs, struct ath10k_txq, list);
+                txq = container_of((void *)artxq, struct ieee80211_txq,
+                                   drv_priv);
+
+                /* Prevent aggressive sta/tid taking over tx queue */
+                max = 16;
+                ret = 0;
+                while (ath10k_mac_tx_can_push(hw, txq) && max--) {
+                        ret = ath10k_mac_tx_push_txq(hw, txq);
+                        if (ret < 0)
+                                break;
+                }
+
+                list_del_init(&artxq->list);
+                if (ret != -ENOENT)
+                        list_add_tail(&artxq->list, &ar->txqs);
+
+                ath10k_htt_tx_txq_update(hw, txq);
+
+                if (artxq == last || (ret < 0 && ret != -ENOENT))
+                        break;
+        }
+
+        rcu_read_unlock();
+        spin_unlock_bh(&ar->txqs_lock);
+}
+
 /************/
 /* Scanning */
 /************/
@@ -3638,66 +3953,86 @@ static int ath10k_start_scan(struct ath10k *ar,
 /* mac80211 callbacks */
 /**********************/
 
-static void ath10k_tx(struct ieee80211_hw *hw,
-                      struct ieee80211_tx_control *control,
-                      struct sk_buff *skb)
+static void ath10k_mac_op_tx(struct ieee80211_hw *hw,
+                             struct ieee80211_tx_control *control,
+                             struct sk_buff *skb)
 {
         struct ath10k *ar = hw->priv;
-        struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
+        struct ath10k_htt *htt = &ar->htt;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct ieee80211_vif *vif = info->control.vif;
         struct ieee80211_sta *sta = control->sta;
-        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
+        struct ieee80211_txq *txq = NULL;
+        struct ieee80211_hdr *hdr = (void *)skb->data;
         enum ath10k_hw_txrx_mode txmode;
+        enum ath10k_mac_tx_path txpath;
+        bool is_htt;
+        bool is_mgmt;
+        bool is_presp;
+        int ret;
 
-        /* We should disable CCK RATE due to P2P */
-        if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
-                ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
+        ath10k_mac_tx_h_fill_cb(ar, vif, txq, skb);
 
         txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
+        txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
+        is_htt = (txpath == ATH10K_MAC_TX_HTT ||
+                  txpath == ATH10K_MAC_TX_HTT_MGMT);
+        is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);
 
-        skb_cb->flags = 0;
-        if (!ath10k_tx_h_use_hwcrypto(vif, skb))
-                skb_cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
+        if (is_htt) {
+                spin_lock_bh(&ar->htt.tx_lock);
+                is_presp = ieee80211_is_probe_resp(hdr->frame_control);
 
-        if (ieee80211_is_mgmt(hdr->frame_control))
-                skb_cb->flags |= ATH10K_SKB_F_MGMT;
-
-        if (ieee80211_is_data_qos(hdr->frame_control))
-                skb_cb->flags |= ATH10K_SKB_F_QOS;
-
-        skb_cb->vif = vif;
+                ret = ath10k_htt_tx_inc_pending(htt);
+                if (ret) {
+                        ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n",
+                                    ret);
+                        spin_unlock_bh(&ar->htt.tx_lock);
+                        ieee80211_free_txskb(ar->hw, skb);
+                        return;
+                }
 
-        switch (txmode) {
-        case ATH10K_HW_TXRX_MGMT:
-        case ATH10K_HW_TXRX_NATIVE_WIFI:
-                ath10k_tx_h_nwifi(hw, skb);
-                ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
-                ath10k_tx_h_seq_no(vif, skb);
-                break;
-        case ATH10K_HW_TXRX_ETHERNET:
-                ath10k_tx_h_8023(skb);
-                break;
-        case ATH10K_HW_TXRX_RAW:
-                if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
-                        WARN_ON_ONCE(1);
-                        ieee80211_free_txskb(hw, skb);
+                ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);
+                if (ret) {
+                        ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n",
+                                   ret);
+                        ath10k_htt_tx_dec_pending(htt);
+                        spin_unlock_bh(&ar->htt.tx_lock);
+                        ieee80211_free_txskb(ar->hw, skb);
                         return;
                 }
+                spin_unlock_bh(&ar->htt.tx_lock);
         }
 
-        if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
-                if (!ath10k_mac_tx_frm_has_freq(ar)) {
-                        ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
-                                   skb);
-
-                        skb_queue_tail(&ar->offchan_tx_queue, skb);
-                        ieee80211_queue_work(hw, &ar->offchan_tx_work);
-                        return;
+        ret = ath10k_mac_tx(ar, vif, sta, txmode, txpath, skb);
+        if (ret) {
+                ath10k_warn(ar, "failed to transmit frame: %d\n", ret);
+                if (is_htt) {
+                        spin_lock_bh(&ar->htt.tx_lock);
+                        ath10k_htt_tx_dec_pending(htt);
+                        if (is_mgmt)
+                                ath10k_htt_tx_mgmt_dec_pending(htt);
+                        spin_unlock_bh(&ar->htt.tx_lock);
                 }
+                return;
         }
+}
+
+static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
+                                        struct ieee80211_txq *txq)
+{
+        struct ath10k *ar = hw->priv;
+        struct ath10k_txq *artxq = (void *)txq->drv_priv;
+
+        spin_lock_bh(&ar->txqs_lock);
+        if (list_empty(&artxq->list))
+                list_add_tail(&artxq->list, &ar->txqs);
+        spin_unlock_bh(&ar->txqs_lock);
+
+        if (ath10k_mac_tx_can_push(hw, txq))
+                tasklet_schedule(&ar->htt.txrx_compl_task);
 
-        ath10k_mac_tx(ar, txmode, skb);
+        ath10k_htt_tx_txq_update(hw, txq);
 }
 
 /* Must not be called with conf_mutex held as workers can use that also. */
@@ -3919,14 +4254,14 @@ static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
         vht_cap = ath10k_create_vht_cap(ar);
 
         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
-                band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
+                band = &ar->mac.sbands[NL80211_BAND_2GHZ];
                 band->ht_cap = ht_cap;
 
                 /* Enable the VHT support at 2.4 GHz */
                 band->vht_cap = vht_cap;
         }
         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
-                band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
+                band = &ar->mac.sbands[NL80211_BAND_5GHZ];
                 band->ht_cap = ht_cap;
                 band->vht_cap = vht_cap;
         }
@@ -4100,7 +4435,7 @@ static int ath10k_start(struct ieee80211_hw *hw)
 
         ar->ani_enabled = true;
 
-        if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
+        if (ath10k_peer_stats_enabled(ar)) {
                 param = ar->wmi.pdev_param->peer_stats_update_period;
                 ret = ath10k_wmi_pdev_set_param(ar, param,
                                                 PEER_DEFAULT_STATS_UPDATE_PERIOD);
@@ -4313,6 +4648,7 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
 {
         struct ath10k *ar = hw->priv;
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
+        struct ath10k_peer *peer;
         enum wmi_sta_powersave_param param;
         int ret = 0;
         u32 value;
@@ -4325,6 +4661,7 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
         mutex_lock(&ar->conf_mutex);
 
         memset(arvif, 0, sizeof(*arvif));
+        ath10k_mac_txq_init(vif->txq);
 
         arvif->ar = ar;
         arvif->vif = vif;
@@ -4489,7 +4826,10 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
                 goto err_vdev_delete;
         }
 
-        if (ar->cfg_tx_chainmask) {
+        /* Configuring number of spatial stream for monitor interface is causing
+         * target assert in qca9888 and qca6174.
+         */
+        if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) {
                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
 
                 vdev_param = ar->wmi.vdev_param->nss;
@@ -4505,13 +4845,31 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
 
         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
-                ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
-                                         WMI_PEER_TYPE_DEFAULT);
+                ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id,
+                                         vif->addr, WMI_PEER_TYPE_DEFAULT);
                 if (ret) {
                         ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
                                     arvif->vdev_id, ret);
                         goto err_vdev_delete;
                 }
+
+                spin_lock_bh(&ar->data_lock);
+
+                peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr);
+                if (!peer) {
+                        ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
+                                    vif->addr, arvif->vdev_id);
+                        spin_unlock_bh(&ar->data_lock);
+                        ret = -ENOENT;
+                        goto err_peer_delete;
+                }
+
+                arvif->peer_id = find_first_bit(peer->peer_ids,
+                                                ATH10K_MAX_NUM_PEER_IDS);
+
+                spin_unlock_bh(&ar->data_lock);
+        } else {
+                arvif->peer_id = HTT_INVALID_PEERID;
         }
 
         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
@@ -4622,7 +4980,9 @@ static void ath10k_remove_interface(struct ieee80211_hw *hw,
 {
         struct ath10k *ar = hw->priv;
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
+        struct ath10k_peer *peer;
         int ret;
+        int i;
 
         cancel_work_sync(&arvif->ap_csa_work);
         cancel_delayed_work_sync(&arvif->connection_loss_work);
@@ -4676,7 +5036,22 @@ static void ath10k_remove_interface(struct ieee80211_hw *hw,
                 spin_unlock_bh(&ar->data_lock);
         }
 
+        spin_lock_bh(&ar->data_lock);
+        for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
+                peer = ar->peer_map[i];
+                if (!peer)
+                        continue;
+
+                if (peer->vif == vif) {
+                        ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n",
+                                    vif->addr, arvif->vdev_id);
+                        peer->vif = NULL;
+                }
+        }
+        spin_unlock_bh(&ar->data_lock);
+
         ath10k_peer_cleanup(ar, arvif->vdev_id);
+        ath10k_mac_txq_unref(ar, vif->txq);
 
         if (vif->type == NL80211_IFTYPE_MONITOR) {
                 ar->monitor_arvif = NULL;
@@ -4689,6 +5064,8 @@ static void ath10k_remove_interface(struct ieee80211_hw *hw,
         ath10k_mac_vif_tx_unlock_all(arvif);
         spin_unlock_bh(&ar->htt.tx_lock);
 
+        ath10k_mac_txq_unref(ar, vif->txq);
+
         mutex_unlock(&ar->conf_mutex);
 }
 
@@ -5218,7 +5595,7 @@ static void ath10k_sta_rc_update_wk(struct work_struct *wk)
         struct ath10k_sta *arsta;
         struct ieee80211_sta *sta;
         struct cfg80211_chan_def def;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const u8 *ht_mcs_mask;
         const u16 *vht_mcs_mask;
         u32 changed, bw, nss, smps;
@@ -5393,13 +5770,18 @@ static int ath10k_sta_state(struct ieee80211_hw *hw,
         struct ath10k *ar = hw->priv;
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
+        struct ath10k_peer *peer;
         int ret = 0;
+        int i;
 
         if (old_state == IEEE80211_STA_NOTEXIST &&
             new_state == IEEE80211_STA_NONE) {
                 memset(arsta, 0, sizeof(*arsta));
                 arsta->arvif = arvif;
                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
+
+                for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
+                        ath10k_mac_txq_init(sta->txq[i]);
         }
 
         /* cancel must be done outside the mutex to avoid deadlock */
@@ -5434,8 +5816,8 @@ static int ath10k_sta_state(struct ieee80211_hw *hw,
                 if (sta->tdls)
                         peer_type = WMI_PEER_TYPE_TDLS;
 
-                ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
-                                         peer_type);
+                ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id,
+                                         sta->addr, peer_type);
                 if (ret) {
                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
                                     sta->addr, arvif->vdev_id, ret);
@@ -5443,6 +5825,24 @@ static int ath10k_sta_state(struct ieee80211_hw *hw,
                         goto exit;
                 }
 
+                spin_lock_bh(&ar->data_lock);
+
+                peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
+                if (!peer) {
+                        ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
+                                    vif->addr, arvif->vdev_id);
+                        spin_unlock_bh(&ar->data_lock);
+                        ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
+                        ath10k_mac_dec_num_stations(arvif, sta);
+                        ret = -ENOENT;
+                        goto exit;
+                }
+
+                arsta->peer_id = find_first_bit(peer->peer_ids,
+                                                ATH10K_MAX_NUM_PEER_IDS);
+
+                spin_unlock_bh(&ar->data_lock);
+
                 if (!sta->tdls)
                         goto exit;
 
@@ -5505,6 +5905,23 @@ static int ath10k_sta_state(struct ieee80211_hw *hw,
 
                 ath10k_mac_dec_num_stations(arvif, sta);
 
+                spin_lock_bh(&ar->data_lock);
+                for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
+                        peer = ar->peer_map[i];
+                        if (!peer)
+                                continue;
+
+                        if (peer->sta == sta) {
+                                ath10k_warn(ar, "found sta peer %pM entry on vdev %i after it was supposedly removed\n",
+                                            sta->addr, arvif->vdev_id);
+                                peer->sta = NULL;
+                        }
+                }
+                spin_unlock_bh(&ar->data_lock);
+
+                for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
+                        ath10k_mac_txq_unref(ar, sta->txq[i]);
+
                 if (!sta->tdls)
                         goto exit;
 
@@ -5977,14 +6394,14 @@ static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
 
         mutex_lock(&ar->conf_mutex);
 
-        sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
+        sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
         if (sband && idx >= sband->n_channels) {
                 idx -= sband->n_channels;
                 sband = NULL;
         }
 
         if (!sband)
-                sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
+                sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
 
         if (!sband || idx >= sband->n_channels) {
                 ret = -ENOENT;
@@ -6007,7 +6424,7 @@ exit:
 
 static bool
 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
-                                        enum ieee80211_band band,
+                                        enum nl80211_band band,
                                         const struct cfg80211_bitrate_mask *mask)
 {
         int num_rates = 0;
@@ -6026,7 +6443,7 @@ ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
 
 static bool
 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
-                                       enum ieee80211_band band,
+                                       enum nl80211_band band,
                                        const struct cfg80211_bitrate_mask *mask,
                                        int *nss)
 {
@@ -6075,7 +6492,7 @@ ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
 
 static int
 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
-                                        enum ieee80211_band band,
+                                        enum nl80211_band band,
                                         const struct cfg80211_bitrate_mask *mask,
                                         u8 *rate, u8 *nss)
 {
@@ -6176,7 +6593,7 @@ static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
 
 static bool
 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
-                                enum ieee80211_band band,
+                                enum nl80211_band band,
                                 const struct cfg80211_bitrate_mask *mask)
 {
         int i;
@@ -6228,7 +6645,7 @@ static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
         struct cfg80211_chan_def def;
         struct ath10k *ar = arvif->ar;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const u8 *ht_mcs_mask;
         const u16 *vht_mcs_mask;
         u8 rate;
@@ -6807,7 +7224,8 @@ ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
 }
 
 static const struct ieee80211_ops ath10k_ops = {
-        .tx                             = ath10k_tx,
+        .tx                             = ath10k_mac_op_tx,
+        .wake_tx_queue                  = ath10k_mac_op_wake_tx_queue,
         .start                          = ath10k_start,
         .stop                           = ath10k_stop,
         .config                         = ath10k_config,
@@ -6857,7 +7275,7 @@ static const struct ieee80211_ops ath10k_ops = {
 };
 
 #define CHAN2G(_channel, _freq, _flags) { \
-        .band                   = IEEE80211_BAND_2GHZ, \
+        .band                   = NL80211_BAND_2GHZ, \
         .hw_value               = (_channel), \
         .center_freq            = (_freq), \
         .flags                  = (_flags), \
@@ -6866,7 +7284,7 @@ static const struct ieee80211_ops ath10k_ops = {
 }
 
 #define CHAN5G(_channel, _freq, _flags) { \
-        .band                   = IEEE80211_BAND_5GHZ, \
+        .band                   = NL80211_BAND_5GHZ, \
         .hw_value               = (_channel), \
         .center_freq            = (_freq), \
         .flags                  = (_flags), \
@@ -7186,13 +7604,13 @@ int ath10k_mac_register(struct ath10k *ar)
                         goto err_free;
                 }
 
-                band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
+                band = &ar->mac.sbands[NL80211_BAND_2GHZ];
                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
                 band->channels = channels;
                 band->n_bitrates = ath10k_g_rates_size;
                 band->bitrates = ath10k_g_rates;
 
-                ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
+                ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
         }
 
         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
@@ -7204,12 +7622,12 @@ int ath10k_mac_register(struct ath10k *ar)
                         goto err_free;
                 }
 
-                band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
+                band = &ar->mac.sbands[NL80211_BAND_5GHZ];
                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
                 band->channels = channels;
                 band->n_bitrates = ath10k_a_rates_size;
                 band->bitrates = ath10k_a_rates;
-                ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
+                ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
         }
 
         ath10k_mac_setup_ht_vht_cap(ar);
@@ -7262,6 +7680,7 @@ int ath10k_mac_register(struct ath10k *ar)
 
         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
+        ar->hw->txq_data_size = sizeof(struct ath10k_txq);
 
         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
 
@@ -7286,7 +7705,8 @@ int ath10k_mac_register(struct ath10k *ar)
         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
 
         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
-        ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
+        ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
+                                   NL80211_FEATURE_AP_SCAN;
 
         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
 
@@ -7395,8 +7815,8 @@ err_dfs_detector_exit:
                 ar->dfs_detector->exit(ar->dfs_detector);
 
 err_free:
-        kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
-        kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
+        kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
+        kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
 
         SET_IEEE80211_DEV(ar->hw, NULL);
         return ret;
@@ -7409,8 +7829,8 @@ void ath10k_mac_unregister(struct ath10k *ar)
         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
                 ar->dfs_detector->exit(ar->dfs_detector);
 
-        kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
-        kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
+        kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
+        kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
 
         SET_IEEE80211_DEV(ar->hw, NULL);
 }
diff --git a/drivers/net/wireless/ath/ath10k/mac.h b/drivers/net/wireless/ath/ath10k/mac.h
index 53091588090d..2c3327beb445 100644
--- a/drivers/net/wireless/ath/ath10k/mac.h
+++ b/drivers/net/wireless/ath/ath10k/mac.h
@@ -75,6 +75,12 @@ void ath10k_mac_tx_unlock(struct ath10k *ar, int reason);
 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason);
 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason);
 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar);
+void ath10k_mac_tx_push_pending(struct ath10k *ar);
+int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw,
+                           struct ieee80211_txq *txq);
+struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar,
+                                            u16 peer_id,
+                                            u8 tid);
 
 static inline struct ath10k_vif *ath10k_vif_to_arvif(struct ieee80211_vif *vif)
 {
diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index b3cff1d3364a..0b305efe6c94 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
@@ -809,7 +809,8 @@ static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
         spin_lock_bh(&ar_pci->ce_lock);
         num = __ath10k_ce_rx_num_free_bufs(ce_pipe);
         spin_unlock_bh(&ar_pci->ce_lock);
-        while (num--) {
+
+        while (num >= 0) {
                 ret = __ath10k_pci_rx_post_buf(pipe);
                 if (ret) {
                         if (ret == -ENOSPC)
@@ -819,6 +820,7 @@ static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
                                   ATH10K_PCI_RX_POST_RETRY_MS);
                         break;
                 }
+                num--;
         }
 }
 
@@ -870,10 +872,8 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
 {
         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
         int ret = 0;
-        u32 buf;
+        u32 *buf;
         unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
-        unsigned int id;
-        unsigned int flags;
         struct ath10k_ce_pipe *ce_diag;
         /* Host buffer address in CE space */
         u32 ce_data;
@@ -909,7 +909,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
                 nbytes = min_t(unsigned int, remaining_bytes,
                                DIAG_TRANSFER_LIMIT);
 
-                ret = __ath10k_ce_rx_post_buf(ce_diag, NULL, ce_data);
+                ret = __ath10k_ce_rx_post_buf(ce_diag, &ce_data, ce_data);
                 if (ret != 0)
                         goto done;
 
@@ -940,9 +940,10 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
                 }
 
                 i = 0;
-                while (ath10k_ce_completed_recv_next_nolock(ce_diag, NULL, &buf,
-                                                            &completed_nbytes,
-                                                            &id, &flags) != 0) {
+                while (ath10k_ce_completed_recv_next_nolock(ce_diag,
+                                                            (void **)&buf,
+                                                            &completed_nbytes)
+                                                                != 0) {
                         mdelay(1);
 
                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
@@ -956,7 +957,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
                         goto done;
                 }
 
-                if (buf != ce_data) {
+                if (*buf != ce_data) {
                         ret = -EIO;
                         goto done;
                 }
@@ -1026,10 +1027,8 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
 {
         struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
         int ret = 0;
-        u32 buf;
+        u32 *buf;
         unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
-        unsigned int id;
-        unsigned int flags;
         struct ath10k_ce_pipe *ce_diag;
         void *data_buf = NULL;
         u32 ce_data;    /* Host buffer address in CE space */
@@ -1078,7 +1077,7 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
                 nbytes = min_t(int, remaining_bytes, DIAG_TRANSFER_LIMIT);
 
                 /* Set up to receive directly into Target(!) address */
-                ret = __ath10k_ce_rx_post_buf(ce_diag, NULL, address);
+                ret = __ath10k_ce_rx_post_buf(ce_diag, &address, address);
                 if (ret != 0)
                         goto done;
 
@@ -1103,9 +1102,10 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
                 }
 
                 i = 0;
-                while (ath10k_ce_completed_recv_next_nolock(ce_diag, NULL, &buf,
-                                                            &completed_nbytes,
-                                                            &id, &flags) != 0) {
+                while (ath10k_ce_completed_recv_next_nolock(ce_diag,
+                                                            (void **)&buf,
+                                                            &completed_nbytes)
+                                                                != 0) {
                         mdelay(1);
 
                         if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
@@ -1119,7 +1119,7 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
                         goto done;
                 }
 
-                if (buf != address) {
+                if (*buf != address) {
                         ret = -EIO;
                         goto done;
                 }
@@ -1181,15 +1181,11 @@ static void ath10k_pci_process_rx_cb(struct ath10k_ce_pipe *ce_state,
         struct sk_buff *skb;
         struct sk_buff_head list;
         void *transfer_context;
-        u32 ce_data;
         unsigned int nbytes, max_nbytes;
-        unsigned int transfer_id;
-        unsigned int flags;
 
         __skb_queue_head_init(&list);
         while (ath10k_ce_completed_recv_next(ce_state, &transfer_context,
-                                             &ce_data, &nbytes, &transfer_id,
-                                             &flags) == 0) {
+                                             &nbytes) == 0) {
                 skb = transfer_context;
                 max_nbytes = skb->len + skb_tailroom(skb);
                 dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
@@ -1218,6 +1214,63 @@ static void ath10k_pci_process_rx_cb(struct ath10k_ce_pipe *ce_state,
         ath10k_pci_rx_post_pipe(pipe_info);
 }
 
+static void ath10k_pci_process_htt_rx_cb(struct ath10k_ce_pipe *ce_state,
+                                         void (*callback)(struct ath10k *ar,
+                                                          struct sk_buff *skb))
+{
+        struct ath10k *ar = ce_state->ar;
+        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+        struct ath10k_pci_pipe *pipe_info =  &ar_pci->pipe_info[ce_state->id];
+        struct ath10k_ce_pipe *ce_pipe = pipe_info->ce_hdl;
+        struct sk_buff *skb;
+        struct sk_buff_head list;
+        void *transfer_context;
+        unsigned int nbytes, max_nbytes, nentries;
+        int orig_len;
+
+        /* No need to aquire ce_lock for CE5, since this is the only place CE5
+         * is processed other than init and deinit. Before releasing CE5
+         * buffers, interrupts are disabled. Thus CE5 access is serialized.
+         */
+        __skb_queue_head_init(&list);
+        while (ath10k_ce_completed_recv_next_nolock(ce_state, &transfer_context,
+                                                    &nbytes) == 0) {
+                skb = transfer_context;
+                max_nbytes = skb->len + skb_tailroom(skb);
+
+                if (unlikely(max_nbytes < nbytes)) {
+                        ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
+                                    nbytes, max_nbytes);
+                        continue;
+                }
+
+                dma_sync_single_for_cpu(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
+                                        max_nbytes, DMA_FROM_DEVICE);
+                skb_put(skb, nbytes);
+                __skb_queue_tail(&list, skb);
+        }
+
+        nentries = skb_queue_len(&list);
+        while ((skb = __skb_dequeue(&list))) {
+                ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
+                           ce_state->id, skb->len);
+                ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
+                                skb->data, skb->len);
+
+                orig_len = skb->len;
+                callback(ar, skb);
+                skb_push(skb, orig_len - skb->len);
+                skb_reset_tail_pointer(skb);
+                skb_trim(skb, 0);
+
+                /*let device gain the buffer again*/
+                dma_sync_single_for_device(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
+                                           skb->len + skb_tailroom(skb),
+                                           DMA_FROM_DEVICE);
+        }
+        ath10k_ce_rx_update_write_idx(ce_pipe, nentries);
+}
+
 /* Called by lower (CE) layer when data is received from the Target. */
 static void ath10k_pci_htc_rx_cb(struct ath10k_ce_pipe *ce_state)
 {
@@ -1274,7 +1327,7 @@ static void ath10k_pci_htt_rx_cb(struct ath10k_ce_pipe *ce_state)
          */
         ath10k_ce_per_engine_service(ce_state->ar, 4);
 
-        ath10k_pci_process_rx_cb(ce_state, ath10k_pci_htt_rx_deliver);
+        ath10k_pci_process_htt_rx_cb(ce_state, ath10k_pci_htt_rx_deliver);
 }
 
 int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
@@ -1835,13 +1888,10 @@ static void ath10k_pci_bmi_recv_data(struct ath10k_ce_pipe *ce_state)
 {
         struct ath10k *ar = ce_state->ar;
         struct bmi_xfer *xfer;
-        u32 ce_data;
         unsigned int nbytes;
-        unsigned int transfer_id;
-        unsigned int flags;
 
-        if (ath10k_ce_completed_recv_next(ce_state, (void **)&xfer, &ce_data,
-                                          &nbytes, &transfer_id, &flags))
+        if (ath10k_ce_completed_recv_next(ce_state, (void **)&xfer,
+                                          &nbytes))
                 return;
 
         if (WARN_ON_ONCE(!xfer))
diff --git a/drivers/net/wireless/ath/ath10k/txrx.c b/drivers/net/wireless/ath/ath10k/txrx.c
index fbfb608e48ab..9369411a9ac0 100644
--- a/drivers/net/wireless/ath/ath10k/txrx.c
+++ b/drivers/net/wireless/ath/ath10k/txrx.c
@@ -49,25 +49,25 @@ out:
         spin_unlock_bh(&ar->data_lock);
 }
 
-void ath10k_txrx_tx_unref(struct ath10k_htt *htt,
-                          const struct htt_tx_done *tx_done)
+int ath10k_txrx_tx_unref(struct ath10k_htt *htt,
+                         const struct htt_tx_done *tx_done)
 {
         struct ath10k *ar = htt->ar;
         struct device *dev = ar->dev;
         struct ieee80211_tx_info *info;
+        struct ieee80211_txq *txq;
         struct ath10k_skb_cb *skb_cb;
+        struct ath10k_txq *artxq;
         struct sk_buff *msdu;
-        bool limit_mgmt_desc = false;
 
         ath10k_dbg(ar, ATH10K_DBG_HTT,
-                   "htt tx completion msdu_id %u discard %d no_ack %d success %d\n",
-                   tx_done->msdu_id, !!tx_done->discard,
-                   !!tx_done->no_ack, !!tx_done->success);
+                   "htt tx completion msdu_id %u status %d\n",
+                   tx_done->msdu_id, tx_done->status);
 
         if (tx_done->msdu_id >= htt->max_num_pending_tx) {
                 ath10k_warn(ar, "warning: msdu_id %d too big, ignoring\n",
                             tx_done->msdu_id);
-                return;
+                return -EINVAL;
         }
 
         spin_lock_bh(&htt->tx_lock);
@@ -76,17 +76,18 @@ void ath10k_txrx_tx_unref(struct ath10k_htt *htt,
                 ath10k_warn(ar, "received tx completion for invalid msdu_id: %d\n",
                             tx_done->msdu_id);
                 spin_unlock_bh(&htt->tx_lock);
-                return;
+                return -ENOENT;
         }
 
         skb_cb = ATH10K_SKB_CB(msdu);
+        txq = skb_cb->txq;
+        artxq = (void *)txq->drv_priv;
 
-        if (unlikely(skb_cb->flags & ATH10K_SKB_F_MGMT) &&
-            ar->hw_params.max_probe_resp_desc_thres)
-                limit_mgmt_desc = true;
+        if (txq)
+                artxq->num_fw_queued--;
 
         ath10k_htt_tx_free_msdu_id(htt, tx_done->msdu_id);
-        __ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
+        ath10k_htt_tx_dec_pending(htt);
         if (htt->num_pending_tx == 0)
                 wake_up(&htt->empty_tx_wq);
         spin_unlock_bh(&htt->tx_lock);
@@ -99,22 +100,24 @@ void ath10k_txrx_tx_unref(struct ath10k_htt *htt,
         memset(&info->status, 0, sizeof(info->status));
         trace_ath10k_txrx_tx_unref(ar, tx_done->msdu_id);
 
-        if (tx_done->discard) {
+        if (tx_done->status == HTT_TX_COMPL_STATE_DISCARD) {
                 ieee80211_free_txskb(htt->ar->hw, msdu);
-                return;
+                return 0;
         }
 
         if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
                 info->flags |= IEEE80211_TX_STAT_ACK;
 
-        if (tx_done->no_ack)
+        if (tx_done->status == HTT_TX_COMPL_STATE_NOACK)
                 info->flags &= ~IEEE80211_TX_STAT_ACK;
 
-        if (tx_done->success && (info->flags & IEEE80211_TX_CTL_NO_ACK))
+        if ((tx_done->status == HTT_TX_COMPL_STATE_ACK) &&
+            (info->flags & IEEE80211_TX_CTL_NO_ACK))
                 info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED;
 
         ieee80211_tx_status(htt->ar->hw, msdu);
         /* we do not own the msdu anymore */
+        return 0;
 }
 
 struct ath10k_peer *ath10k_peer_find(struct ath10k *ar, int vdev_id,
@@ -203,6 +206,7 @@ void ath10k_peer_map_event(struct ath10k_htt *htt,
         ath10k_dbg(ar, ATH10K_DBG_HTT, "htt peer map vdev %d peer %pM id %d\n",
                    ev->vdev_id, ev->addr, ev->peer_id);
 
+        ar->peer_map[ev->peer_id] = peer;
         set_bit(ev->peer_id, peer->peer_ids);
 exit:
         spin_unlock_bh(&ar->data_lock);
@@ -225,6 +229,7 @@ void ath10k_peer_unmap_event(struct ath10k_htt *htt,
         ath10k_dbg(ar, ATH10K_DBG_HTT, "htt peer unmap vdev %d peer %pM id %d\n",
                    peer->vdev_id, peer->addr, ev->peer_id);
 
+        ar->peer_map[ev->peer_id] = NULL;
         clear_bit(ev->peer_id, peer->peer_ids);
 
         if (bitmap_empty(peer->peer_ids, ATH10K_MAX_NUM_PEER_IDS)) {
diff --git a/drivers/net/wireless/ath/ath10k/txrx.h b/drivers/net/wireless/ath/ath10k/txrx.h
index a90e09f5c7f2..e7ea1ae1c438 100644
--- a/drivers/net/wireless/ath/ath10k/txrx.h
+++ b/drivers/net/wireless/ath/ath10k/txrx.h
@@ -19,8 +19,8 @@
 
 #include "htt.h"
 
-void ath10k_txrx_tx_unref(struct ath10k_htt *htt,
-                          const struct htt_tx_done *tx_done);
+int ath10k_txrx_tx_unref(struct ath10k_htt *htt,
+                         const struct htt_tx_done *tx_done);
 
 struct ath10k_peer *ath10k_peer_find(struct ath10k *ar, int vdev_id,
                                      const u8 *addr);
diff --git a/drivers/net/wireless/ath/ath10k/wmi-ops.h b/drivers/net/wireless/ath/ath10k/wmi-ops.h
index 32ab34edceb5..7fb00dcc03b8 100644
--- a/drivers/net/wireless/ath/ath10k/wmi-ops.h
+++ b/drivers/net/wireless/ath/ath10k/wmi-ops.h
@@ -186,6 +186,9 @@ struct wmi_ops {
                                                         u8 enable,
                                                         u32 detect_level,
                                                         u32 detect_margin);
+        struct sk_buff *(*ext_resource_config)(struct ath10k *ar,
+                                               enum wmi_host_platform_type type,
+                                               u32 fw_feature_bitmap);
         int (*get_vdev_subtype)(struct ath10k *ar,
                                 enum wmi_vdev_subtype subtype);
 };
@@ -1330,6 +1333,26 @@ ath10k_wmi_pdev_enable_adaptive_cca(struct ath10k *ar, u8 enable,
 }
 
 static inline int
+ath10k_wmi_ext_resource_config(struct ath10k *ar,
+                               enum wmi_host_platform_type type,
+                               u32 fw_feature_bitmap)
+{
+        struct sk_buff *skb;
+
+        if (!ar->wmi.ops->ext_resource_config)
+                return -EOPNOTSUPP;
+
+        skb = ar->wmi.ops->ext_resource_config(ar, type,
+                                               fw_feature_bitmap);
+
+        if (IS_ERR(skb))
+                return PTR_ERR(skb);
+
+        return ath10k_wmi_cmd_send(ar, skb,
+                                   ar->wmi.cmd->ext_resource_cfg_cmdid);
+}
+
+static inline int
 ath10k_wmi_get_vdev_subtype(struct ath10k *ar, enum wmi_vdev_subtype subtype)
 {
         if (!ar->wmi.ops->get_vdev_subtype)
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index 70261387d1a5..4c75c74be5e7 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
@@ -705,6 +705,7 @@ static struct wmi_cmd_map wmi_10_4_cmd_map = {
         .set_cca_params_cmdid = WMI_10_4_SET_CCA_PARAMS_CMDID,
         .pdev_bss_chan_info_request_cmdid =
                         WMI_10_4_PDEV_BSS_CHAN_INFO_REQUEST_CMDID,
+        .ext_resource_cfg_cmdid = WMI_10_4_EXT_RESOURCE_CFG_CMDID,
 };
 
 /* MAIN WMI VDEV param map */
@@ -2099,34 +2100,6 @@ int ath10k_wmi_event_scan(struct ath10k *ar, struct sk_buff *skb)
         return 0;
 }
 
-static inline enum ieee80211_band phy_mode_to_band(u32 phy_mode)
-{
-        enum ieee80211_band band;
-
-        switch (phy_mode) {
-        case MODE_11A:
-        case MODE_11NA_HT20:
-        case MODE_11NA_HT40:
-        case MODE_11AC_VHT20:
-        case MODE_11AC_VHT40:
-        case MODE_11AC_VHT80:
-                band = IEEE80211_BAND_5GHZ;
-                break;
-        case MODE_11G:
-        case MODE_11B:
-        case MODE_11GONLY:
-        case MODE_11NG_HT20:
-        case MODE_11NG_HT40:
-        case MODE_11AC_VHT20_2G:
-        case MODE_11AC_VHT40_2G:
-        case MODE_11AC_VHT80_2G:
-        default:
-                band = IEEE80211_BAND_2GHZ;
-        }
-
-        return band;
-}
-
 /* If keys are configured, HW decrypts all frames
  * with protected bit set. Mark such frames as decrypted.
  */
@@ -2167,8 +2140,10 @@ static int ath10k_wmi_op_pull_mgmt_rx_ev(struct ath10k *ar, struct sk_buff *skb,
         struct wmi_mgmt_rx_event_v1 *ev_v1;
         struct wmi_mgmt_rx_event_v2 *ev_v2;
         struct wmi_mgmt_rx_hdr_v1 *ev_hdr;
+        struct wmi_mgmt_rx_ext_info *ext_info;
         size_t pull_len;
         u32 msdu_len;
+        u32 len;
 
         if (test_bit(ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX, ar->fw_features)) {
                 ev_v2 = (struct wmi_mgmt_rx_event_v2 *)skb->data;
@@ -2195,6 +2170,12 @@ static int ath10k_wmi_op_pull_mgmt_rx_ev(struct ath10k *ar, struct sk_buff *skb,
         if (skb->len < msdu_len)
                 return -EPROTO;
 
+        if (le32_to_cpu(arg->status) & WMI_RX_STATUS_EXT_INFO) {
+                len = ALIGN(le32_to_cpu(arg->buf_len), 4);
+                ext_info = (struct wmi_mgmt_rx_ext_info *)(skb->data + len);
+                memcpy(&arg->ext_info, ext_info,
+                       sizeof(struct wmi_mgmt_rx_ext_info));
+        }
         /* the WMI buffer might've ended up being padded to 4 bytes due to HTC
          * trailer with credit update. Trim the excess garbage.
          */
@@ -2211,6 +2192,8 @@ static int ath10k_wmi_10_4_op_pull_mgmt_rx_ev(struct ath10k *ar,
         struct wmi_10_4_mgmt_rx_hdr *ev_hdr;
         size_t pull_len;
         u32 msdu_len;
+        struct wmi_mgmt_rx_ext_info *ext_info;
+        u32 len;
 
         ev = (struct wmi_10_4_mgmt_rx_event *)skb->data;
         ev_hdr = &ev->hdr;
@@ -2231,6 +2214,13 @@ static int ath10k_wmi_10_4_op_pull_mgmt_rx_ev(struct ath10k *ar,
         if (skb->len < msdu_len)
                 return -EPROTO;
 
+        if (le32_to_cpu(arg->status) & WMI_RX_STATUS_EXT_INFO) {
+                len = ALIGN(le32_to_cpu(arg->buf_len), 4);
+                ext_info = (struct wmi_mgmt_rx_ext_info *)(skb->data + len);
+                memcpy(&arg->ext_info, ext_info,
+                       sizeof(struct wmi_mgmt_rx_ext_info));
+        }
+
         /* Make sure bytes added for padding are removed. */
         skb_trim(skb, msdu_len);
 
@@ -2281,14 +2271,19 @@ int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
         if (rx_status & WMI_RX_STATUS_ERR_MIC)
                 status->flag |= RX_FLAG_MMIC_ERROR;
 
+        if (rx_status & WMI_RX_STATUS_EXT_INFO) {
+                status->mactime =
+                        __le64_to_cpu(arg.ext_info.rx_mac_timestamp);
+                status->flag |= RX_FLAG_MACTIME_END;
+        }
         /* Hardware can Rx CCK rates on 5GHz. In that case phy_mode is set to
          * MODE_11B. This means phy_mode is not a reliable source for the band
          * of mgmt rx.
          */
         if (channel >= 1 && channel <= 14) {
-                status->band = IEEE80211_BAND_2GHZ;
+                status->band = NL80211_BAND_2GHZ;
         } else if (channel >= 36 && channel <= 165) {
-                status->band = IEEE80211_BAND_5GHZ;
+                status->band = NL80211_BAND_5GHZ;
         } else {
                 /* Shouldn't happen unless list of advertised channels to
                  * mac80211 has been changed.
@@ -2298,7 +2293,7 @@ int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
                 return 0;
         }
 
-        if (phy_mode == MODE_11B && status->band == IEEE80211_BAND_5GHZ)
+        if (phy_mode == MODE_11B && status->band == NL80211_BAND_5GHZ)
                 ath10k_dbg(ar, ATH10K_DBG_MGMT, "wmi mgmt rx 11b (CCK) on 5GHz\n");
 
         sband = &ar->mac.sbands[status->band];
@@ -2310,6 +2305,12 @@ int ath10k_wmi_event_mgmt_rx(struct ath10k *ar, struct sk_buff *skb)
         hdr = (struct ieee80211_hdr *)skb->data;
         fc = le16_to_cpu(hdr->frame_control);
 
+        /* Firmware is guaranteed to report all essential management frames via
+         * WMI while it can deliver some extra via HTT. Since there can be
+         * duplicates split the reporting wrt monitor/sniffing.
+         */
+        status->flag |= RX_FLAG_SKIP_MONITOR;
+
         ath10k_wmi_handle_wep_reauth(ar, skb, status);
 
         /* FW delivers WEP Shared Auth frame with Protected Bit set and
@@ -2351,7 +2352,7 @@ static int freq_to_idx(struct ath10k *ar, int freq)
         struct ieee80211_supported_band *sband;
         int band, ch, idx = 0;
 
-        for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
                 sband = ar->hw->wiphy->bands[band];
                 if (!sband)
                         continue;
@@ -2612,6 +2613,16 @@ void ath10k_wmi_pull_peer_stats(const struct wmi_peer_stats *src,
         dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);
 }
 
+static void
+ath10k_wmi_10_4_pull_peer_stats(const struct wmi_10_4_peer_stats *src,
+                                struct ath10k_fw_stats_peer *dst)
+{
+        ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);
+        dst->peer_rssi = __le32_to_cpu(src->peer_rssi);
+        dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);
+        dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);
+}
+
 static int ath10k_wmi_main_op_pull_fw_stats(struct ath10k *ar,
                                             struct sk_buff *skb,
                                             struct ath10k_fw_stats *stats)
@@ -2865,11 +2876,8 @@ static int ath10k_wmi_10_2_4_op_pull_fw_stats(struct ath10k *ar,
                 const struct wmi_10_2_4_ext_peer_stats *src;
                 struct ath10k_fw_stats_peer *dst;
                 int stats_len;
-                bool ext_peer_stats_support;
 
-                ext_peer_stats_support = test_bit(WMI_SERVICE_PEER_STATS,
-                                                  ar->wmi.svc_map);
-                if (ext_peer_stats_support)
+                if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
                         stats_len = sizeof(struct wmi_10_2_4_ext_peer_stats);
                 else
                         stats_len = sizeof(struct wmi_10_2_4_peer_stats);
@@ -2886,7 +2894,7 @@ static int ath10k_wmi_10_2_4_op_pull_fw_stats(struct ath10k *ar,
 
                 dst->peer_rx_rate = __le32_to_cpu(src->common.peer_rx_rate);
 
-                if (ext_peer_stats_support)
+                if (ath10k_peer_stats_enabled(ar))
                         dst->rx_duration = __le32_to_cpu(src->rx_duration);
                 /* FIXME: expose 10.2 specific values */
 
@@ -2905,6 +2913,7 @@ static int ath10k_wmi_10_4_op_pull_fw_stats(struct ath10k *ar,
         u32 num_pdev_ext_stats;
         u32 num_vdev_stats;
         u32 num_peer_stats;
+        u32 stats_id;
         int i;
 
         if (!skb_pull(skb, sizeof(*ev)))
@@ -2914,6 +2923,7 @@ static int ath10k_wmi_10_4_op_pull_fw_stats(struct ath10k *ar,
         num_pdev_ext_stats = __le32_to_cpu(ev->num_pdev_ext_stats);
         num_vdev_stats = __le32_to_cpu(ev->num_vdev_stats);
         num_peer_stats = __le32_to_cpu(ev->num_peer_stats);
+        stats_id = __le32_to_cpu(ev->stats_id);
 
         for (i = 0; i < num_pdev_stats; i++) {
                 const struct wmi_10_4_pdev_stats *src;
@@ -2953,22 +2963,28 @@ static int ath10k_wmi_10_4_op_pull_fw_stats(struct ath10k *ar,
         /* fw doesn't implement vdev stats */
 
         for (i = 0; i < num_peer_stats; i++) {
-                const struct wmi_10_4_peer_stats *src;
+                const struct wmi_10_4_peer_extd_stats *src;
                 struct ath10k_fw_stats_peer *dst;
+                int stats_len;
+                bool extd_peer_stats = !!(stats_id & WMI_10_4_STAT_PEER_EXTD);
+
+                if (extd_peer_stats)
+                        stats_len = sizeof(struct wmi_10_4_peer_extd_stats);
+                else
+                        stats_len = sizeof(struct wmi_10_4_peer_stats);
 
                 src = (void *)skb->data;
-                if (!skb_pull(skb, sizeof(*src)))
+                if (!skb_pull(skb, stats_len))
                         return -EPROTO;
 
                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
                 if (!dst)
                         continue;
 
-                ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);
-                dst->peer_rssi = __le32_to_cpu(src->peer_rssi);
-                dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);
-                dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);
+                ath10k_wmi_10_4_pull_peer_stats(&src->common, dst);
                 /* FIXME: expose 10.4 specific values */
+                if (extd_peer_stats)
+                        dst->rx_duration = __le32_to_cpu(src->rx_duration);
 
                 list_add_tail(&dst->list, &stats->peers);
         }
@@ -4617,10 +4633,16 @@ static void ath10k_wmi_event_service_ready_work(struct work_struct *work)
         }
 
         if (test_bit(WMI_SERVICE_PEER_CACHING, ar->wmi.svc_map)) {
+                if (test_bit(ATH10K_FW_FEATURE_PEER_FLOW_CONTROL,
+                             ar->fw_features))
+                        ar->num_active_peers = TARGET_10_4_QCACHE_ACTIVE_PEERS_PFC +
+                                               ar->max_num_vdevs;
+                else
+                        ar->num_active_peers = TARGET_10_4_QCACHE_ACTIVE_PEERS +
+                                               ar->max_num_vdevs;
+
                 ar->max_num_peers = TARGET_10_4_NUM_QCACHE_PEERS_MAX +
                                     ar->max_num_vdevs;
-                ar->num_active_peers = ar->hw_params.qcache_active_peers +
-                                       ar->max_num_vdevs;
                 ar->num_tids = ar->num_active_peers * 2;
                 ar->max_num_stations = TARGET_10_4_NUM_QCACHE_PEERS_MAX;
         }
@@ -5517,7 +5539,8 @@ static struct sk_buff *ath10k_wmi_10_2_op_gen_init(struct ath10k *ar)
 
         config.num_vdevs = __cpu_to_le32(TARGET_10X_NUM_VDEVS);
         config.num_peer_keys = __cpu_to_le32(TARGET_10X_NUM_PEER_KEYS);
-        if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
+
+        if (ath10k_peer_stats_enabled(ar)) {
                 config.num_peers = __cpu_to_le32(TARGET_10X_TX_STATS_NUM_PEERS);
                 config.num_tids = __cpu_to_le32(TARGET_10X_TX_STATS_NUM_TIDS);
         } else {
@@ -5579,7 +5602,7 @@ static struct sk_buff *ath10k_wmi_10_2_op_gen_init(struct ath10k *ar)
             test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
                 features |= WMI_10_2_COEX_GPIO;
 
-        if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
+        if (ath10k_peer_stats_enabled(ar))
                 features |= WMI_10_2_PEER_STATS;
 
         cmd->resource_config.feature_mask = __cpu_to_le32(features);
@@ -7484,6 +7507,28 @@ static int ath10k_wmi_10_4_op_get_vdev_subtype(struct ath10k *ar,
         return -ENOTSUPP;
 }
 
+static struct sk_buff *
+ath10k_wmi_10_4_ext_resource_config(struct ath10k *ar,
+                                    enum wmi_host_platform_type type,
+                                    u32 fw_feature_bitmap)
+{
+        struct wmi_ext_resource_config_10_4_cmd *cmd;
+        struct sk_buff *skb;
+
+        skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd));
+        if (!skb)
+                return ERR_PTR(-ENOMEM);
+
+        cmd = (struct wmi_ext_resource_config_10_4_cmd *)skb->data;
+        cmd->host_platform_config = __cpu_to_le32(type);
+        cmd->fw_feature_bitmap = __cpu_to_le32(fw_feature_bitmap);
+
+        ath10k_dbg(ar, ATH10K_DBG_WMI,
+                   "wmi ext resource config host type %d firmware feature bitmap %08x\n",
+                   type, fw_feature_bitmap);
+        return skb;
+}
+
 static const struct wmi_ops wmi_ops = {
         .rx = ath10k_wmi_op_rx,
         .map_svc = wmi_main_svc_map,
@@ -7810,6 +7855,7 @@ static const struct wmi_ops wmi_10_4_ops = {
         .gen_addba_set_resp = ath10k_wmi_op_gen_addba_set_resp,
         .gen_delba_send = ath10k_wmi_op_gen_delba_send,
         .fw_stats_fill = ath10k_wmi_10_4_op_fw_stats_fill,
+        .ext_resource_config = ath10k_wmi_10_4_ext_resource_config,
 
         /* shared with 10.2 */
         .gen_request_stats = ath10k_wmi_op_gen_request_stats,
diff --git a/drivers/net/wireless/ath/ath10k/wmi.h b/drivers/net/wireless/ath/ath10k/wmi.h
index 4d3cbc44fcd2..feebd19ff08c 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.h
+++ b/drivers/net/wireless/ath/ath10k/wmi.h
@@ -816,6 +816,7 @@ struct wmi_cmd_map {
         u32 set_cca_params_cmdid;
         u32 pdev_bss_chan_info_request_cmdid;
         u32 pdev_enable_adaptive_cca_cmdid;
+        u32 ext_resource_cfg_cmdid;
 };
 
 /*
@@ -2667,6 +2668,31 @@ struct wmi_resource_config_10_4 {
         __le32 qwrap_config;
 } __packed;
 
+/**
+ * enum wmi_10_4_feature_mask - WMI 10.4 feature enable/disable flags
+ * @WMI_10_4_LTEU_SUPPORT: LTEU config
+ * @WMI_10_4_COEX_GPIO_SUPPORT: COEX GPIO config
+ * @WMI_10_4_AUX_RADIO_SPECTRAL_INTF: AUX Radio Enhancement for spectral scan
+ * @WMI_10_4_AUX_RADIO_CHAN_LOAD_INTF: AUX Radio Enhancement for chan load scan
+ * @WMI_10_4_BSS_CHANNEL_INFO_64: BSS channel info stats
+ * @WMI_10_4_PEER_STATS: Per station stats
+ */
+enum wmi_10_4_feature_mask {
+        WMI_10_4_LTEU_SUPPORT                   = BIT(0),
+        WMI_10_4_COEX_GPIO_SUPPORT              = BIT(1),
+        WMI_10_4_AUX_RADIO_SPECTRAL_INTF        = BIT(2),
+        WMI_10_4_AUX_RADIO_CHAN_LOAD_INTF       = BIT(3),
+        WMI_10_4_BSS_CHANNEL_INFO_64            = BIT(4),
+        WMI_10_4_PEER_STATS                     = BIT(5),
+};
+
+struct wmi_ext_resource_config_10_4_cmd {
+        /* contains enum wmi_host_platform_type */
+        __le32 host_platform_config;
+        /* see enum wmi_10_4_feature_mask */
+        __le32 fw_feature_bitmap;
+};
+
 /* strucutre describing host memory chunk. */
 struct host_memory_chunk {
         /* id of the request that is passed up in service ready */
@@ -3037,11 +3063,17 @@ struct wmi_10_4_mgmt_rx_event {
         u8 buf[0];
 } __packed;
 
+struct wmi_mgmt_rx_ext_info {
+        __le64 rx_mac_timestamp;
+} __packed __aligned(4);
+
 #define WMI_RX_STATUS_OK                        0x00
 #define WMI_RX_STATUS_ERR_CRC                   0x01
 #define WMI_RX_STATUS_ERR_DECRYPT               0x08
 #define WMI_RX_STATUS_ERR_MIC                   0x10
 #define WMI_RX_STATUS_ERR_KEY_CACHE_MISS        0x20
+/* Extension data at the end of mgmt frame */
+#define WMI_RX_STATUS_EXT_INFO          0x40
 
 #define PHY_ERROR_GEN_SPECTRAL_SCAN             0x26
 #define PHY_ERROR_GEN_FALSE_RADAR_EXT           0x24
@@ -4072,6 +4104,13 @@ enum wmi_stats_id {
         WMI_STAT_VDEV_RATE = BIT(5),
 };
 
+enum wmi_10_4_stats_id {
+        WMI_10_4_STAT_PEER              = BIT(0),
+        WMI_10_4_STAT_AP                = BIT(1),
+        WMI_10_4_STAT_INST              = BIT(2),
+        WMI_10_4_STAT_PEER_EXTD         = BIT(3),
+};
+
 struct wlan_inst_rssi_args {
         __le16 cfg_retry_count;
         __le16 retry_count;
@@ -4271,6 +4310,15 @@ struct wmi_10_4_peer_stats {
         __le32 peer_rssi_changed;
 } __packed;
 
+struct wmi_10_4_peer_extd_stats {
+        struct wmi_10_4_peer_stats common;
+        struct wmi_mac_addr peer_macaddr;
+        __le32 inactive_time;
+        __le32 peer_chain_rssi;
+        __le32 rx_duration;
+        __le32 reserved[10];
+} __packed;
+
 struct wmi_10_2_pdev_ext_stats {
         __le32 rx_rssi_comb;
         __le32 rx_rssi[4];
@@ -6116,6 +6164,7 @@ struct wmi_mgmt_rx_ev_arg {
         __le32 phy_mode;
         __le32 buf_len;
         __le32 status; /* %WMI_RX_STATUS_ */
+        struct wmi_mgmt_rx_ext_info ext_info;
 };
 
 struct wmi_ch_info_ev_arg {
@@ -6401,6 +6450,11 @@ struct wmi_pdev_set_adaptive_cca_params {
         __le32 cca_detect_margin;
 } __packed;
 
+enum wmi_host_platform_type {
+        WMI_HOST_PLATFORM_HIGH_PERF,
+        WMI_HOST_PLATFORM_LOW_PERF,
+};
+
 struct ath10k;
 struct ath10k_vif;
 struct ath10k_fw_stats_pdev;
diff --git a/drivers/net/wireless/ath/ath5k/ani.c b/drivers/net/wireless/ath/ath5k/ani.c
index 38be2702c0e2..0624333f5430 100644
--- a/drivers/net/wireless/ath/ath5k/ani.c
+++ b/drivers/net/wireless/ath/ath5k/ani.c
@@ -279,7 +279,7 @@ ath5k_ani_raise_immunity(struct ath5k_hw *ah, struct ath5k_ani_state *as,
                 if (as->firstep_level < ATH5K_ANI_MAX_FIRSTEP_LVL)
                         ath5k_ani_set_firstep_level(ah, as->firstep_level + 1);
                 return;
-        } else if (ah->ah_current_channel->band == IEEE80211_BAND_2GHZ) {
+        } else if (ah->ah_current_channel->band == NL80211_BAND_2GHZ) {
                 /* beacon RSSI is low. in B/G mode turn of OFDM weak signal
                  * detect and zero firstep level to maximize CCK sensitivity */
                 ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_ANI,
diff --git a/drivers/net/wireless/ath/ath5k/ath5k.h b/drivers/net/wireless/ath/ath5k/ath5k.h
index ba12f7f4061d..67fedb61fcc0 100644
--- a/drivers/net/wireless/ath/ath5k/ath5k.h
+++ b/drivers/net/wireless/ath/ath5k/ath5k.h
@@ -1265,10 +1265,10 @@ struct ath5k_hw {
         void __iomem            *iobase;        /* address of the device */
         struct mutex            lock;           /* dev-level lock */
         struct ieee80211_hw     *hw;            /* IEEE 802.11 common */
-        struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
         struct ieee80211_channel channels[ATH_CHAN_MAX];
-        struct ieee80211_rate   rates[IEEE80211_NUM_BANDS][AR5K_MAX_RATES];
-        s8                      rate_idx[IEEE80211_NUM_BANDS][AR5K_MAX_RATES];
+        struct ieee80211_rate   rates[NUM_NL80211_BANDS][AR5K_MAX_RATES];
+        s8                      rate_idx[NUM_NL80211_BANDS][AR5K_MAX_RATES];
         enum nl80211_iftype     opmode;
 
 #ifdef CONFIG_ATH5K_DEBUG
@@ -1532,7 +1532,7 @@ int ath5k_eeprom_mode_from_channel(struct ath5k_hw *ah,
 
 /* Protocol Control Unit Functions */
 /* Helpers */
-int ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum ieee80211_band band,
+int ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum nl80211_band band,
                 int len, struct ieee80211_rate *rate, bool shortpre);
 unsigned int ath5k_hw_get_default_slottime(struct ath5k_hw *ah);
 unsigned int ath5k_hw_get_default_sifs(struct ath5k_hw *ah);
@@ -1611,7 +1611,7 @@ int ath5k_hw_write_initvals(struct ath5k_hw *ah, u8 mode, bool change_channel);
 
 /* PHY functions */
 /* Misc PHY functions */
-u16 ath5k_hw_radio_revision(struct ath5k_hw *ah, enum ieee80211_band band);
+u16 ath5k_hw_radio_revision(struct ath5k_hw *ah, enum nl80211_band band);
 int ath5k_hw_phy_disable(struct ath5k_hw *ah);
 /* Gain_F optimization */
 enum ath5k_rfgain ath5k_hw_gainf_calibrate(struct ath5k_hw *ah);
diff --git a/drivers/net/wireless/ath/ath5k/attach.c b/drivers/net/wireless/ath/ath5k/attach.c
index 66b6366158b9..233054bd6b52 100644
--- a/drivers/net/wireless/ath/ath5k/attach.c
+++ b/drivers/net/wireless/ath/ath5k/attach.c
@@ -152,7 +152,7 @@ int ath5k_hw_init(struct ath5k_hw *ah)
         ah->ah_phy_revision = ath5k_hw_reg_read(ah, AR5K_PHY_CHIP_ID) &
                         0xffffffff;
         ah->ah_radio_5ghz_revision = ath5k_hw_radio_revision(ah,
-                        IEEE80211_BAND_5GHZ);
+                        NL80211_BAND_5GHZ);
 
         /* Try to identify radio chip based on its srev */
         switch (ah->ah_radio_5ghz_revision & 0xf0) {
@@ -160,14 +160,14 @@ int ath5k_hw_init(struct ath5k_hw *ah)
                 ah->ah_radio = AR5K_RF5111;
                 ah->ah_single_chip = false;
                 ah->ah_radio_2ghz_revision = ath5k_hw_radio_revision(ah,
-                                                        IEEE80211_BAND_2GHZ);
+                                                        NL80211_BAND_2GHZ);
                 break;
         case AR5K_SREV_RAD_5112:
         case AR5K_SREV_RAD_2112:
                 ah->ah_radio = AR5K_RF5112;
                 ah->ah_single_chip = false;
                 ah->ah_radio_2ghz_revision = ath5k_hw_radio_revision(ah,
-                                                        IEEE80211_BAND_2GHZ);
+                                                        NL80211_BAND_2GHZ);
                 break;
         case AR5K_SREV_RAD_2413:
                 ah->ah_radio = AR5K_RF2413;
@@ -204,7 +204,7 @@ int ath5k_hw_init(struct ath5k_hw *ah)
                         ah->ah_radio = AR5K_RF5111;
                         ah->ah_single_chip = false;
                         ah->ah_radio_2ghz_revision = ath5k_hw_radio_revision(ah,
-                                                        IEEE80211_BAND_2GHZ);
+                                                        NL80211_BAND_2GHZ);
                 } else if (ah->ah_mac_version == (AR5K_SREV_AR2425 >> 4) ||
                            ah->ah_mac_version == (AR5K_SREV_AR2417 >> 4) ||
                            ah->ah_phy_revision == AR5K_SREV_PHY_2425) {
diff --git a/drivers/net/wireless/ath/ath5k/base.c b/drivers/net/wireless/ath/ath5k/base.c
index 3d946d8b2db2..d98fd421c7ec 100644
--- a/drivers/net/wireless/ath/ath5k/base.c
+++ b/drivers/net/wireless/ath/ath5k/base.c
@@ -268,15 +268,15 @@ static void ath5k_reg_notifier(struct wiphy *wiphy,
  * Returns true for the channel numbers used.
  */
 #ifdef CONFIG_ATH5K_TEST_CHANNELS
-static bool ath5k_is_standard_channel(short chan, enum ieee80211_band band)
+static bool ath5k_is_standard_channel(short chan, enum nl80211_band band)
 {
         return true;
 }
 
 #else
-static bool ath5k_is_standard_channel(short chan, enum ieee80211_band band)
+static bool ath5k_is_standard_channel(short chan, enum nl80211_band band)
 {
-        if (band == IEEE80211_BAND_2GHZ && chan <= 14)
+        if (band == NL80211_BAND_2GHZ && chan <= 14)
                 return true;
 
         return  /* UNII 1,2 */
@@ -297,18 +297,18 @@ ath5k_setup_channels(struct ath5k_hw *ah, struct ieee80211_channel *channels,
                 unsigned int mode, unsigned int max)
 {
         unsigned int count, size, freq, ch;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         switch (mode) {
         case AR5K_MODE_11A:
                 /* 1..220, but 2GHz frequencies are filtered by check_channel */
                 size = 220;
-                band = IEEE80211_BAND_5GHZ;
+                band = NL80211_BAND_5GHZ;
                 break;
         case AR5K_MODE_11B:
         case AR5K_MODE_11G:
                 size = 26;
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
                 break;
         default:
                 ATH5K_WARN(ah, "bad mode, not copying channels\n");
@@ -363,13 +363,13 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
         int max_c, count_c = 0;
         int i;
 
-        BUILD_BUG_ON(ARRAY_SIZE(ah->sbands) < IEEE80211_NUM_BANDS);
+        BUILD_BUG_ON(ARRAY_SIZE(ah->sbands) < NUM_NL80211_BANDS);
         max_c = ARRAY_SIZE(ah->channels);
 
         /* 2GHz band */
-        sband = &ah->sbands[IEEE80211_BAND_2GHZ];
-        sband->band = IEEE80211_BAND_2GHZ;
-        sband->bitrates = &ah->rates[IEEE80211_BAND_2GHZ][0];
+        sband = &ah->sbands[NL80211_BAND_2GHZ];
+        sband->band = NL80211_BAND_2GHZ;
+        sband->bitrates = &ah->rates[NL80211_BAND_2GHZ][0];
 
         if (test_bit(AR5K_MODE_11G, ah->ah_capabilities.cap_mode)) {
                 /* G mode */
@@ -381,7 +381,7 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
                 sband->n_channels = ath5k_setup_channels(ah, sband->channels,
                                         AR5K_MODE_11G, max_c);
 
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
+                hw->wiphy->bands[NL80211_BAND_2GHZ] = sband;
                 count_c = sband->n_channels;
                 max_c -= count_c;
         } else if (test_bit(AR5K_MODE_11B, ah->ah_capabilities.cap_mode)) {
@@ -407,7 +407,7 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
                 sband->n_channels = ath5k_setup_channels(ah, sband->channels,
                                         AR5K_MODE_11B, max_c);
 
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
+                hw->wiphy->bands[NL80211_BAND_2GHZ] = sband;
                 count_c = sband->n_channels;
                 max_c -= count_c;
         }
@@ -415,9 +415,9 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
 
         /* 5GHz band, A mode */
         if (test_bit(AR5K_MODE_11A, ah->ah_capabilities.cap_mode)) {
-                sband = &ah->sbands[IEEE80211_BAND_5GHZ];
-                sband->band = IEEE80211_BAND_5GHZ;
-                sband->bitrates = &ah->rates[IEEE80211_BAND_5GHZ][0];
+                sband = &ah->sbands[NL80211_BAND_5GHZ];
+                sband->band = NL80211_BAND_5GHZ;
+                sband->bitrates = &ah->rates[NL80211_BAND_5GHZ][0];
 
                 memcpy(sband->bitrates, &ath5k_rates[4],
                        sizeof(struct ieee80211_rate) * 8);
@@ -427,7 +427,7 @@ ath5k_setup_bands(struct ieee80211_hw *hw)
                 sband->n_channels = ath5k_setup_channels(ah, sband->channels,
                                         AR5K_MODE_11A, max_c);
 
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
+                hw->wiphy->bands[NL80211_BAND_5GHZ] = sband;
         }
         ath5k_setup_rate_idx(ah, sband);
 
diff --git a/drivers/net/wireless/ath/ath5k/debug.c b/drivers/net/wireless/ath/ath5k/debug.c
index 654a1e33f827..929d7ccc031c 100644
--- a/drivers/net/wireless/ath/ath5k/debug.c
+++ b/drivers/net/wireless/ath/ath5k/debug.c
@@ -1043,14 +1043,14 @@ ath5k_debug_dump_bands(struct ath5k_hw *ah)
 
         BUG_ON(!ah->sbands);
 
-        for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
+        for (b = 0; b < NUM_NL80211_BANDS; b++) {
                 struct ieee80211_supported_band *band = &ah->sbands[b];
                 char bname[6];
                 switch (band->band) {
-                case IEEE80211_BAND_2GHZ:
+                case NL80211_BAND_2GHZ:
                         strcpy(bname, "2 GHz");
                         break;
-                case IEEE80211_BAND_5GHZ:
+                case NL80211_BAND_5GHZ:
                         strcpy(bname, "5 GHz");
                         break;
                 default:
diff --git a/drivers/net/wireless/ath/ath5k/led.c b/drivers/net/wireless/ath/ath5k/led.c
index 803030fd17d3..6a2a16856763 100644
--- a/drivers/net/wireless/ath/ath5k/led.c
+++ b/drivers/net/wireless/ath/ath5k/led.c
@@ -77,7 +77,7 @@ static const struct pci_device_id ath5k_led_devices[] = {
         /* HP Compaq CQ60-206US (ddreggors@jumptv.com) */
         { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137a), ATH_LED(3, 1) },
         /* HP Compaq C700 (nitrousnrg@gmail.com) */
-        { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 1) },
+        { ATH_SDEVICE(PCI_VENDOR_ID_HP, 0x0137b), ATH_LED(3, 0) },
         /* LiteOn AR5BXB63 (magooz@salug.it) */
         { ATH_SDEVICE(PCI_VENDOR_ID_ATHEROS, 0x3067), ATH_LED(3, 0) },
         /* IBM-specific AR5212 (all others) */
diff --git a/drivers/net/wireless/ath/ath5k/pcu.c b/drivers/net/wireless/ath/ath5k/pcu.c
index bf29da5e90da..fc47b70988b1 100644
--- a/drivers/net/wireless/ath/ath5k/pcu.c
+++ b/drivers/net/wireless/ath/ath5k/pcu.c
@@ -110,7 +110,7 @@ static const unsigned int ack_rates_high[] =
  * bwmodes.
  */
 int
-ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum ieee80211_band band,
+ath5k_hw_get_frame_duration(struct ath5k_hw *ah, enum nl80211_band band,
                 int len, struct ieee80211_rate *rate, bool shortpre)
 {
         int sifs, preamble, plcp_bits, sym_time;
@@ -221,7 +221,7 @@ ath5k_hw_get_default_sifs(struct ath5k_hw *ah)
         case AR5K_BWMODE_DEFAULT:
                 sifs = AR5K_INIT_SIFS_DEFAULT_BG;
         default:
-                if (channel->band == IEEE80211_BAND_5GHZ)
+                if (channel->band == NL80211_BAND_5GHZ)
                         sifs = AR5K_INIT_SIFS_DEFAULT_A;
                 break;
         }
@@ -279,7 +279,7 @@ ath5k_hw_write_rate_duration(struct ath5k_hw *ah)
         struct ieee80211_rate *rate;
         unsigned int i;
         /* 802.11g covers both OFDM and CCK */
-        u8 band = IEEE80211_BAND_2GHZ;
+        u8 band = NL80211_BAND_2GHZ;
 
         /* Write rate duration table */
         for (i = 0; i < ah->sbands[band].n_bitrates; i++) {
diff --git a/drivers/net/wireless/ath/ath5k/phy.c b/drivers/net/wireless/ath/ath5k/phy.c
index 0fce1c76638e..641b13a279e1 100644
--- a/drivers/net/wireless/ath/ath5k/phy.c
+++ b/drivers/net/wireless/ath/ath5k/phy.c
@@ -75,13 +75,13 @@
 /**
  * ath5k_hw_radio_revision() - Get the PHY Chip revision
  * @ah: The &struct ath5k_hw
- * @band: One of enum ieee80211_band
+ * @band: One of enum nl80211_band
  *
  * Returns the revision number of a 2GHz, 5GHz or single chip
  * radio.
  */
 u16
-ath5k_hw_radio_revision(struct ath5k_hw *ah, enum ieee80211_band band)
+ath5k_hw_radio_revision(struct ath5k_hw *ah, enum nl80211_band band)
 {
         unsigned int i;
         u32 srev;
@@ -91,10 +91,10 @@ ath5k_hw_radio_revision(struct ath5k_hw *ah, enum ieee80211_band band)
          * Set the radio chip access register
          */
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_2GHZ, AR5K_PHY(0));
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 ath5k_hw_reg_write(ah, AR5K_PHY_SHIFT_5GHZ, AR5K_PHY(0));
                 break;
         default:
@@ -138,11 +138,11 @@ ath5k_channel_ok(struct ath5k_hw *ah, struct ieee80211_channel *channel)
         u16 freq = channel->center_freq;
 
         /* Check if the channel is in our supported range */
-        if (channel->band == IEEE80211_BAND_2GHZ) {
+        if (channel->band == NL80211_BAND_2GHZ) {
                 if ((freq >= ah->ah_capabilities.cap_range.range_2ghz_min) &&
                     (freq <= ah->ah_capabilities.cap_range.range_2ghz_max))
                         return true;
-        } else if (channel->band == IEEE80211_BAND_5GHZ)
+        } else if (channel->band == NL80211_BAND_5GHZ)
                 if ((freq >= ah->ah_capabilities.cap_range.range_5ghz_min) &&
                     (freq <= ah->ah_capabilities.cap_range.range_5ghz_max))
                         return true;
@@ -743,7 +743,7 @@ done:
 /**
  * ath5k_hw_rfgain_init() - Write initial RF gain settings to hw
  * @ah: The &struct ath5k_hw
- * @band: One of enum ieee80211_band
+ * @band: One of enum nl80211_band
  *
  * Write initial RF gain table to set the RF sensitivity.
  *
@@ -751,7 +751,7 @@ done:
  * with Gain_F calibration
  */
 static int
-ath5k_hw_rfgain_init(struct ath5k_hw *ah, enum ieee80211_band band)
+ath5k_hw_rfgain_init(struct ath5k_hw *ah, enum nl80211_band band)
 {
         const struct ath5k_ini_rfgain *ath5k_rfg;
         unsigned int i, size, index;
@@ -786,7 +786,7 @@ ath5k_hw_rfgain_init(struct ath5k_hw *ah, enum ieee80211_band band)
                 return -EINVAL;
         }
 
-        index = (band == IEEE80211_BAND_2GHZ) ? 1 : 0;
+        index = (band == NL80211_BAND_2GHZ) ? 1 : 0;
 
         for (i = 0; i < size; i++) {
                 AR5K_REG_WAIT(i);
@@ -917,7 +917,7 @@ ath5k_hw_rfregs_init(struct ath5k_hw *ah,
         }
 
         /* Set Output and Driver bias current (OB/DB) */
-        if (channel->band == IEEE80211_BAND_2GHZ) {
+        if (channel->band == NL80211_BAND_2GHZ) {
 
                 if (channel->hw_value == AR5K_MODE_11B)
                         ee_mode = AR5K_EEPROM_MODE_11B;
@@ -944,7 +944,7 @@ ath5k_hw_rfregs_init(struct ath5k_hw *ah,
                                                 AR5K_RF_DB_2GHZ, true);
 
         /* RF5111 always needs OB/DB for 5GHz, even if we use 2GHz */
-        } else if ((channel->band == IEEE80211_BAND_5GHZ) ||
+        } else if ((channel->band == NL80211_BAND_5GHZ) ||
                         (ah->ah_radio == AR5K_RF5111)) {
 
                 /* For 11a, Turbo and XR we need to choose
@@ -1145,7 +1145,7 @@ ath5k_hw_rfregs_init(struct ath5k_hw *ah,
         }
 
         if (ah->ah_radio == AR5K_RF5413 &&
-        channel->band == IEEE80211_BAND_2GHZ) {
+        channel->band == NL80211_BAND_2GHZ) {
 
                 ath5k_hw_rfb_op(ah, rf_regs, 1, AR5K_RF_DERBY_CHAN_SEL_MODE,
                                                                         true);
@@ -1270,7 +1270,7 @@ ath5k_hw_rf5111_channel(struct ath5k_hw *ah,
          */
         data0 = data1 = 0;
 
-        if (channel->band == IEEE80211_BAND_2GHZ) {
+        if (channel->band == NL80211_BAND_2GHZ) {
                 /* Map 2GHz channel to 5GHz Atheros channel ID */
                 ret = ath5k_hw_rf5111_chan2athchan(
                         ieee80211_frequency_to_channel(channel->center_freq),
@@ -1446,7 +1446,7 @@ ath5k_hw_channel(struct ath5k_hw *ah,
                         "channel frequency (%u MHz) out of supported "
                         "band range\n",
                         channel->center_freq);
-                        return -EINVAL;
+                return -EINVAL;
         }
 
         /*
@@ -1919,7 +1919,7 @@ ath5k_hw_set_spur_mitigation_filter(struct ath5k_hw *ah,
         /* Convert current frequency to fbin value (the same way channels
          * are stored on EEPROM, check out ath5k_eeprom_bin2freq) and scale
          * up by 2 so we can compare it later */
-        if (channel->band == IEEE80211_BAND_2GHZ) {
+        if (channel->band == NL80211_BAND_2GHZ) {
                 chan_fbin = (channel->center_freq - 2300) * 10;
                 freq_band = AR5K_EEPROM_BAND_2GHZ;
         } else {
@@ -1983,7 +1983,7 @@ ath5k_hw_set_spur_mitigation_filter(struct ath5k_hw *ah,
                         symbol_width = AR5K_SPUR_SYMBOL_WIDTH_BASE_100Hz / 4;
                         break;
                 default:
-                        if (channel->band == IEEE80211_BAND_5GHZ) {
+                        if (channel->band == NL80211_BAND_5GHZ) {
                                 /* Both sample_freq and chip_freq are 40MHz */
                                 spur_delta_phase = (spur_offset << 17) / 25;
                                 spur_freq_sigma_delta =
diff --git a/drivers/net/wireless/ath/ath5k/qcu.c b/drivers/net/wireless/ath/ath5k/qcu.c
index ddaad712c59a..beda11ce34a7 100644
--- a/drivers/net/wireless/ath/ath5k/qcu.c
+++ b/drivers/net/wireless/ath/ath5k/qcu.c
@@ -559,7 +559,7 @@ ath5k_hw_reset_tx_queue(struct ath5k_hw *ah, unsigned int queue)
 int ath5k_hw_set_ifs_intervals(struct ath5k_hw *ah, unsigned int slot_time)
 {
         struct ieee80211_channel *channel = ah->ah_current_channel;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_rate *rate;
         u32 ack_tx_time, eifs, eifs_clock, sifs, sifs_clock;
@@ -596,10 +596,10 @@ int ath5k_hw_set_ifs_intervals(struct ath5k_hw *ah, unsigned int slot_time)
          *
          * Also we have different lowest rate for 802.11a
          */
-        if (channel->band == IEEE80211_BAND_5GHZ)
-                band = IEEE80211_BAND_5GHZ;
+        if (channel->band == NL80211_BAND_5GHZ)
+                band = NL80211_BAND_5GHZ;
         else
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
 
         switch (ah->ah_bwmode) {
         case AR5K_BWMODE_5MHZ:
diff --git a/drivers/net/wireless/ath/ath5k/reset.c b/drivers/net/wireless/ath/ath5k/reset.c
index 99e62f99a182..56d7925a0c2c 100644
--- a/drivers/net/wireless/ath/ath5k/reset.c
+++ b/drivers/net/wireless/ath/ath5k/reset.c
@@ -634,7 +634,7 @@ ath5k_hw_on_hold(struct ath5k_hw *ah)
                 ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
                         AR5K_RESET_CTL_MAC | AR5K_RESET_CTL_DMA |
                         AR5K_RESET_CTL_PHY | AR5K_RESET_CTL_PCI);
-                        usleep_range(2000, 2500);
+                usleep_range(2000, 2500);
         } else {
                 ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
                         AR5K_RESET_CTL_BASEBAND | bus_flags);
@@ -699,7 +699,7 @@ ath5k_hw_nic_wakeup(struct ath5k_hw *ah, struct ieee80211_channel *channel)
                 ret = ath5k_hw_nic_reset(ah, AR5K_RESET_CTL_PCU |
                         AR5K_RESET_CTL_MAC | AR5K_RESET_CTL_DMA |
                         AR5K_RESET_CTL_PHY | AR5K_RESET_CTL_PCI);
-                        usleep_range(2000, 2500);
+                usleep_range(2000, 2500);
         } else {
                 if (ath5k_get_bus_type(ah) == ATH_AHB)
                         ret = ath5k_hw_wisoc_reset(ah, AR5K_RESET_CTL_PCU |
@@ -752,7 +752,7 @@ ath5k_hw_nic_wakeup(struct ath5k_hw *ah, struct ieee80211_channel *channel)
                         clock = AR5K_PHY_PLL_RF5111;            /*Zero*/
                 }
 
-                if (channel->band == IEEE80211_BAND_2GHZ) {
+                if (channel->band == NL80211_BAND_2GHZ) {
                         mode |= AR5K_PHY_MODE_FREQ_2GHZ;
                         clock |= AR5K_PHY_PLL_44MHZ;
 
@@ -771,7 +771,7 @@ ath5k_hw_nic_wakeup(struct ath5k_hw *ah, struct ieee80211_channel *channel)
                                 else
                                         mode |= AR5K_PHY_MODE_MOD_DYN;
                         }
-                } else if (channel->band == IEEE80211_BAND_5GHZ) {
+                } else if (channel->band == NL80211_BAND_5GHZ) {
                         mode |= (AR5K_PHY_MODE_FREQ_5GHZ |
                                  AR5K_PHY_MODE_MOD_OFDM);
 
@@ -906,7 +906,7 @@ ath5k_hw_tweak_initval_settings(struct ath5k_hw *ah,
                 u32 data;
                 ath5k_hw_reg_write(ah, AR5K_PHY_CCKTXCTL_WORLD,
                                 AR5K_PHY_CCKTXCTL);
-                if (channel->band == IEEE80211_BAND_5GHZ)
+                if (channel->band == NL80211_BAND_5GHZ)
                         data = 0xffb81020;
                 else
                         data = 0xffb80d20;
diff --git a/drivers/net/wireless/ath/ath6kl/cfg80211.c b/drivers/net/wireless/ath/ath6kl/cfg80211.c
index 7f3f94fbf157..4e11ba06f089 100644
--- a/drivers/net/wireless/ath/ath6kl/cfg80211.c
+++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c
@@ -34,7 +34,7 @@
 }
 
 #define CHAN2G(_channel, _freq, _flags) {   \
-        .band           = IEEE80211_BAND_2GHZ,  \
+        .band           = NL80211_BAND_2GHZ,  \
         .hw_value       = (_channel),           \
         .center_freq    = (_freq),              \
         .flags          = (_flags),             \
@@ -43,7 +43,7 @@
 }
 
 #define CHAN5G(_channel, _flags) {                  \
-        .band           = IEEE80211_BAND_5GHZ,      \
+        .band           = NL80211_BAND_5GHZ,      \
         .hw_value       = (_channel),               \
         .center_freq    = 5000 + (5 * (_channel)),  \
         .flags          = (_flags),                 \
@@ -2583,7 +2583,7 @@ void ath6kl_check_wow_status(struct ath6kl *ar)
 }
 #endif
 
-static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum ieee80211_band band,
+static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum nl80211_band band,
                             bool ht_enable)
 {
         struct ath6kl_htcap *htcap = &vif->htcap[band];
@@ -2594,7 +2594,7 @@ static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum ieee80211_band band,
         if (ht_enable) {
                 /* Set default ht capabilities */
                 htcap->ht_enable = true;
-                htcap->cap_info = (band == IEEE80211_BAND_2GHZ) ?
+                htcap->cap_info = (band == NL80211_BAND_2GHZ) ?
                                    ath6kl_g_htcap : ath6kl_a_htcap;
                 htcap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
         } else /* Disable ht */
@@ -2609,7 +2609,7 @@ static int ath6kl_restore_htcap(struct ath6kl_vif *vif)
         struct wiphy *wiphy = vif->ar->wiphy;
         int band, ret = 0;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 if (!wiphy->bands[band])
                         continue;
 
@@ -3530,7 +3530,7 @@ static void ath6kl_cfg80211_reg_notify(struct wiphy *wiphy,
                                        struct regulatory_request *request)
 {
         struct ath6kl *ar = wiphy_priv(wiphy);
-        u32 rates[IEEE80211_NUM_BANDS];
+        u32 rates[NUM_NL80211_BANDS];
         int ret, i;
 
         ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
@@ -3555,7 +3555,7 @@ static void ath6kl_cfg80211_reg_notify(struct wiphy *wiphy,
          * changed.
          */
 
-        for (i = 0; i < IEEE80211_NUM_BANDS; i++)
+        for (i = 0; i < NUM_NL80211_BANDS; i++)
                 if (wiphy->bands[i])
                         rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
 
@@ -3791,8 +3791,8 @@ struct wireless_dev *ath6kl_interface_add(struct ath6kl *ar, const char *name,
         vif->listen_intvl_t = ATH6KL_DEFAULT_LISTEN_INTVAL;
         vif->bmiss_time_t = ATH6KL_DEFAULT_BMISS_TIME;
         vif->bg_scan_period = 0;
-        vif->htcap[IEEE80211_BAND_2GHZ].ht_enable = true;
-        vif->htcap[IEEE80211_BAND_5GHZ].ht_enable = true;
+        vif->htcap[NL80211_BAND_2GHZ].ht_enable = true;
+        vif->htcap[NL80211_BAND_5GHZ].ht_enable = true;
 
         memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
         if (fw_vif_idx != 0) {
@@ -3943,9 +3943,9 @@ int ath6kl_cfg80211_init(struct ath6kl *ar)
         wiphy->available_antennas_rx = ar->hw.rx_ant;
 
         if (band_2gig)
-                wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
+                wiphy->bands[NL80211_BAND_2GHZ] = &ath6kl_band_2ghz;
         if (band_5gig)
-                wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
+                wiphy->bands[NL80211_BAND_5GHZ] = &ath6kl_band_5ghz;
 
         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
 
diff --git a/drivers/net/wireless/ath/ath6kl/core.h b/drivers/net/wireless/ath/ath6kl/core.h
index 5f3acfe6015e..713a571a27ce 100644
--- a/drivers/net/wireless/ath/ath6kl/core.h
+++ b/drivers/net/wireless/ath/ath6kl/core.h
@@ -623,7 +623,7 @@ struct ath6kl_vif {
         struct ath6kl_wep_key wep_key_list[WMI_MAX_KEY_INDEX + 1];
         struct ath6kl_key keys[WMI_MAX_KEY_INDEX + 1];
         struct aggr_info *aggr_cntxt;
-        struct ath6kl_htcap htcap[IEEE80211_NUM_BANDS];
+        struct ath6kl_htcap htcap[NUM_NL80211_BANDS];
 
         struct timer_list disconnect_timer;
         struct timer_list sched_scan_timer;
diff --git a/drivers/net/wireless/ath/ath6kl/wmi.c b/drivers/net/wireless/ath/ath6kl/wmi.c
index a5e1de75a4a3..631c3a0c572b 100644
--- a/drivers/net/wireless/ath/ath6kl/wmi.c
+++ b/drivers/net/wireless/ath/ath6kl/wmi.c
@@ -1584,6 +1584,11 @@ static int ath6kl_wmi_txe_notify_event_rx(struct wmi *wmi, u8 *datap, int len,
         if (len < sizeof(*ev))
                 return -EINVAL;
 
+        if (vif->nw_type != INFRA_NETWORK ||
+            !test_bit(ATH6KL_FW_CAPABILITY_TX_ERR_NOTIFY,
+                      vif->ar->fw_capabilities))
+                return -EOPNOTSUPP;
+
         if (vif->sme_state != SME_CONNECTED)
                 return -ENOTCONN;
 
@@ -2043,7 +2048,7 @@ int ath6kl_wmi_beginscan_cmd(struct wmi *wmi, u8 if_idx,
         sc->no_cck = cpu_to_le32(no_cck);
         sc->num_ch = num_chan;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 sband = ar->wiphy->bands[band];
 
                 if (!sband)
@@ -2765,10 +2770,10 @@ static int ath6kl_set_bitrate_mask64(struct wmi *wmi, u8 if_idx,
         memset(&ratemask, 0, sizeof(ratemask));
 
         /* only check 2.4 and 5 GHz bands, skip the rest */
-        for (band = 0; band <= IEEE80211_BAND_5GHZ; band++) {
+        for (band = 0; band <= NL80211_BAND_5GHZ; band++) {
                 /* copy legacy rate mask */
                 ratemask[band] = mask->control[band].legacy;
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         ratemask[band] =
                                 mask->control[band].legacy << 4;
 
@@ -2794,9 +2799,9 @@ static int ath6kl_set_bitrate_mask64(struct wmi *wmi, u8 if_idx,
                 if (mode == WMI_RATES_MODE_11A ||
                     mode == WMI_RATES_MODE_11A_HT20 ||
                     mode == WMI_RATES_MODE_11A_HT40)
-                        band = IEEE80211_BAND_5GHZ;
+                        band = NL80211_BAND_5GHZ;
                 else
-                        band = IEEE80211_BAND_2GHZ;
+                        band = NL80211_BAND_2GHZ;
                 cmd->ratemask[mode] = cpu_to_le64(ratemask[band]);
         }
 
@@ -2817,10 +2822,10 @@ static int ath6kl_set_bitrate_mask32(struct wmi *wmi, u8 if_idx,
         memset(&ratemask, 0, sizeof(ratemask));
 
         /* only check 2.4 and 5 GHz bands, skip the rest */
-        for (band = 0; band <= IEEE80211_BAND_5GHZ; band++) {
+        for (band = 0; band <= NL80211_BAND_5GHZ; band++) {
                 /* copy legacy rate mask */
                 ratemask[band] = mask->control[band].legacy;
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         ratemask[band] =
                                 mask->control[band].legacy << 4;
 
@@ -2844,9 +2849,9 @@ static int ath6kl_set_bitrate_mask32(struct wmi *wmi, u8 if_idx,
                 if (mode == WMI_RATES_MODE_11A ||
                     mode == WMI_RATES_MODE_11A_HT20 ||
                     mode == WMI_RATES_MODE_11A_HT40)
-                        band = IEEE80211_BAND_5GHZ;
+                        band = NL80211_BAND_5GHZ;
                 else
-                        band = IEEE80211_BAND_2GHZ;
+                        band = NL80211_BAND_2GHZ;
                 cmd->ratemask[mode] = cpu_to_le32(ratemask[band]);
         }
 
@@ -3169,7 +3174,7 @@ int ath6kl_wmi_set_keepalive_cmd(struct wmi *wmi, u8 if_idx,
 }
 
 int ath6kl_wmi_set_htcap_cmd(struct wmi *wmi, u8 if_idx,
-                             enum ieee80211_band band,
+                             enum nl80211_band band,
                              struct ath6kl_htcap *htcap)
 {
         struct sk_buff *skb;
@@ -3182,7 +3187,7 @@ int ath6kl_wmi_set_htcap_cmd(struct wmi *wmi, u8 if_idx,
         cmd = (struct wmi_set_htcap_cmd *) skb->data;
 
         /*
-         * NOTE: Band in firmware matches enum ieee80211_band, it is unlikely
+         * NOTE: Band in firmware matches enum nl80211_band, it is unlikely
          * this will be changed in firmware. If at all there is any change in
          * band value, the host needs to be fixed.
          */
diff --git a/drivers/net/wireless/ath/ath6kl/wmi.h b/drivers/net/wireless/ath/ath6kl/wmi.h
index 05d25a94c781..3af464a73b58 100644
--- a/drivers/net/wireless/ath/ath6kl/wmi.h
+++ b/drivers/net/wireless/ath/ath6kl/wmi.h
@@ -2628,7 +2628,7 @@ int ath6kl_wmi_set_wmm_txop(struct wmi *wmi, u8 if_idx, enum wmi_txop_cfg cfg);
 int ath6kl_wmi_set_keepalive_cmd(struct wmi *wmi, u8 if_idx,
                                  u8 keep_alive_intvl);
 int ath6kl_wmi_set_htcap_cmd(struct wmi *wmi, u8 if_idx,
-                             enum ieee80211_band band,
+                             enum nl80211_band band,
                              struct ath6kl_htcap *htcap);
 int ath6kl_wmi_test_cmd(struct wmi *wmi, void *buf, size_t len);
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h b/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
index c38399bc9aa9..c07866a2fdf9 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_2p2_initvals.h
@@ -331,7 +331,7 @@ static const u32 ar9300_2p2_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0x02321e27, 0x02321e27, 0x02291e27, 0x02291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -351,7 +351,7 @@ static const u32 ar9300_2p2_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000150, 0x00000150},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00041983, 0x00041983, 0x00041981, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_calib.c b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
index 0c391997a2f7..518e649ecff3 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
@@ -1203,12 +1203,12 @@ static void ar9003_hw_tx_iq_cal_reload(struct ath_hw *ah)
 static void ar9003_hw_manual_peak_cal(struct ath_hw *ah, u8 chain, bool is_2g)
 {
         int offset[8] = {0}, total = 0, test;
-        int agc_out, i, peak_detect_threshold;
+        int agc_out, i, peak_detect_threshold = 0;
 
         if (AR_SREV_9550(ah) || AR_SREV_9531(ah))
                 peak_detect_threshold = 8;
-        else
-                peak_detect_threshold = 0;
+        else if (AR_SREV_9561(ah))
+                peak_detect_threshold = 11;
 
         /*
          * Turn off LNA/SW.
@@ -1249,17 +1249,14 @@ static void ar9003_hw_manual_peak_cal(struct ath_hw *ah, u8 chain, bool is_2g)
                 REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),
                               AR_PHY_65NM_RXRF_AGC_AGC2G_CALDAC_OVR, 0x0);
 
-        if (AR_SREV_9003_PCOEM(ah) || AR_SREV_9550(ah) || AR_SREV_9531(ah) ||
-            AR_SREV_9561(ah)) {
-                if (is_2g)
-                        REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),
-                                      AR_PHY_65NM_RXRF_AGC_AGC2G_DBDAC_OVR,
-                                      peak_detect_threshold);
-                else
-                        REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),
-                                      AR_PHY_65NM_RXRF_AGC_AGC5G_DBDAC_OVR,
-                                      peak_detect_threshold);
-        }
+        if (is_2g)
+                REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),
+                              AR_PHY_65NM_RXRF_AGC_AGC2G_DBDAC_OVR,
+                              peak_detect_threshold);
+        else
+                REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),
+                              AR_PHY_65NM_RXRF_AGC_AGC5G_DBDAC_OVR,
+                              peak_detect_threshold);
 
         for (i = 6; i > 0; i--) {
                 offset[i] = BIT(i - 1);
@@ -1311,9 +1308,6 @@ static void ar9003_hw_do_pcoem_manual_peak_cal(struct ath_hw *ah,
         struct ath9k_hw_cal_data *caldata = ah->caldata;
         int i;
 
-        if (!AR_SREV_9462(ah) && !AR_SREV_9565(ah) && !AR_SREV_9485(ah))
-                return;
-
         if ((ah->caps.hw_caps & ATH9K_HW_CAP_RTT) && !run_rtt_cal)
                 return;
 
@@ -1641,14 +1635,12 @@ static bool ar9003_hw_init_cal_soc(struct ath_hw *ah,
 
 skip_tx_iqcal:
         if (run_agc_cal || !(ah->ah_flags & AH_FASTCC)) {
-                if (AR_SREV_9330_11(ah) || AR_SREV_9531(ah) || AR_SREV_9550(ah) ||
-                    AR_SREV_9561(ah)) {
-                        for (i = 0; i < AR9300_MAX_CHAINS; i++) {
-                                if (!(ah->rxchainmask & (1 << i)))
-                                        continue;
-                                ar9003_hw_manual_peak_cal(ah, i,
-                                                          IS_CHAN_2GHZ(chan));
-                        }
+                for (i = 0; i < AR9300_MAX_CHAINS; i++) {
+                        if (!(ah->rxchainmask & (1 << i)))
+                                continue;
+
+                        ar9003_hw_manual_peak_cal(ah, i,
+                                                  IS_CHAN_2GHZ(chan));
                 }
 
                 /*
@@ -1709,7 +1701,7 @@ void ar9003_hw_attach_calib_ops(struct ath_hw *ah)
         struct ath_hw_private_ops *priv_ops = ath9k_hw_private_ops(ah);
         struct ath_hw_ops *ops = ath9k_hw_ops(ah);
 
-        if (AR_SREV_9485(ah) || AR_SREV_9462(ah) || AR_SREV_9565(ah))
+        if (AR_SREV_9003_PCOEM(ah))
                 priv_ops->init_cal = ar9003_hw_init_cal_pcoem;
         else
                 priv_ops->init_cal = ar9003_hw_init_cal_soc;
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
index 54ed2f72d35e..f68098284c43 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
@@ -3590,8 +3590,8 @@ static void ar9003_hw_ant_ctrl_apply(struct ath_hw *ah, bool is2ghz)
                 else
                         gpio = AR9300_EXT_LNA_CTL_GPIO_AR9485;
 
-                ath9k_hw_cfg_output(ah, gpio,
-                                    AR_GPIO_OUTPUT_MUX_AS_PCIE_ATTENTION_LED);
+                ath9k_hw_gpio_request_out(ah, gpio, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_PCIE_ATTENTION_LED);
         }
 
         value = ar9003_hw_ant_ctrl_common_get(ah, is2ghz);
@@ -4097,16 +4097,16 @@ static void ar9003_hw_thermometer_apply(struct ath_hw *ah)
                 REG_RMW_FIELD(ah, AR_PHY_65NM_CH2_RXTX4,
                               AR_PHY_65NM_CH0_RXTX4_THERM_ON_OVR, therm_on);
 
-        therm_on = (thermometer < 0) ? 0 : (thermometer == 0);
+        therm_on = thermometer == 0;
         REG_RMW_FIELD(ah, AR_PHY_65NM_CH0_RXTX4,
                       AR_PHY_65NM_CH0_RXTX4_THERM_ON, therm_on);
         if (pCap->chip_chainmask & BIT(1)) {
-                therm_on = (thermometer < 0) ? 0 : (thermometer == 1);
+                therm_on = thermometer == 1;
                 REG_RMW_FIELD(ah, AR_PHY_65NM_CH1_RXTX4,
                               AR_PHY_65NM_CH0_RXTX4_THERM_ON, therm_on);
         }
         if (pCap->chip_chainmask & BIT(2)) {
-                therm_on = (thermometer < 0) ? 0 : (thermometer == 2);
+                therm_on = thermometer == 2;
                 REG_RMW_FIELD(ah, AR_PHY_65NM_CH2_RXTX4,
                               AR_PHY_65NM_CH0_RXTX4_THERM_ON, therm_on);
         }
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_mci.c b/drivers/net/wireless/ath/ath9k/ar9003_mci.c
index af5ee416a560..0fe9c8378249 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_mci.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_mci.c
@@ -427,21 +427,34 @@ static void ar9003_mci_observation_set_up(struct ath_hw *ah)
         struct ath9k_hw_mci *mci = &ah->btcoex_hw.mci;
 
         if (mci->config & ATH_MCI_CONFIG_MCI_OBS_MCI) {
-                ath9k_hw_cfg_output(ah, 3, AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_DATA);
-                ath9k_hw_cfg_output(ah, 2, AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_CLK);
-                ath9k_hw_cfg_output(ah, 1, AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
-                ath9k_hw_cfg_output(ah, 0, AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
+                ath9k_hw_gpio_request_out(ah, 3, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_DATA);
+                ath9k_hw_gpio_request_out(ah, 2, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_WLAN_CLK);
+                ath9k_hw_gpio_request_out(ah, 1, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
+                ath9k_hw_gpio_request_out(ah, 0, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
         } else if (mci->config & ATH_MCI_CONFIG_MCI_OBS_TXRX) {
-                ath9k_hw_cfg_output(ah, 3, AR_GPIO_OUTPUT_MUX_AS_WL_IN_TX);
-                ath9k_hw_cfg_output(ah, 2, AR_GPIO_OUTPUT_MUX_AS_WL_IN_RX);
-                ath9k_hw_cfg_output(ah, 1, AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
-                ath9k_hw_cfg_output(ah, 0, AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
-                ath9k_hw_cfg_output(ah, 5, AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+                ath9k_hw_gpio_request_out(ah, 3, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_WL_IN_TX);
+                ath9k_hw_gpio_request_out(ah, 2, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_WL_IN_RX);
+                ath9k_hw_gpio_request_out(ah, 1, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
+                ath9k_hw_gpio_request_out(ah, 0, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
+                ath9k_hw_gpio_request_out(ah, 5, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
         } else if (mci->config & ATH_MCI_CONFIG_MCI_OBS_BT) {
-                ath9k_hw_cfg_output(ah, 3, AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
-                ath9k_hw_cfg_output(ah, 2, AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
-                ath9k_hw_cfg_output(ah, 1, AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
-                ath9k_hw_cfg_output(ah, 0, AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
+                ath9k_hw_gpio_request_out(ah, 3, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_BT_IN_TX);
+                ath9k_hw_gpio_request_out(ah, 2, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_BT_IN_RX);
+                ath9k_hw_gpio_request_out(ah, 1, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_BT_DATA);
+                ath9k_hw_gpio_request_out(ah, 0, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_MCI_BT_CLK);
         } else
                 return;
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.c b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
index 06c1ca6e8290..be14a8e01916 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c
@@ -1337,11 +1337,11 @@ skip_ws_det:
                                 chan->channel,
                                 aniState->mrcCCK ? "on" : "off",
                                 is_on ? "on" : "off");
-                if (is_on)
-                        ah->stats.ast_ani_ccklow++;
-                else
-                        ah->stats.ast_ani_cckhigh++;
-                aniState->mrcCCK = is_on;
+                        if (is_on)
+                                ah->stats.ast_ani_ccklow++;
+                        else
+                                ah->stats.ast_ani_cckhigh++;
+                        aniState->mrcCCK = is_on;
                 }
         break;
         }
diff --git a/drivers/net/wireless/ath/ath9k/ar9330_1p1_initvals.h b/drivers/net/wireless/ath/ath9k/ar9330_1p1_initvals.h
index 2c42ff05efa3..29479afbc4f1 100644
--- a/drivers/net/wireless/ath/ath9k/ar9330_1p1_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9330_1p1_initvals.h
@@ -40,7 +40,7 @@ static const u32 ar9331_1p1_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00003221, 0x00003221},
-        {0x00009e3c, 0xcf946222, 0xcf946222, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0x02321e27, 0x02321e27, 0x02282324, 0x02282324},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302010, 0x50302010},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -59,7 +59,7 @@ static const u32 ar9331_1p1_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
         {0x0000a288, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
         {0x0000a28c, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00058d18, 0x00058d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00071982, 0x00071982, 0x00071982, 0x00071982},
         {0x0000a2d8, 0xf999a83a, 0xf999a83a, 0xf999a83a, 0xf999a83a},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9330_1p2_initvals.h b/drivers/net/wireless/ath/ath9k/ar9330_1p2_initvals.h
index 2154efcd3900..c4a6ffa55e8c 100644
--- a/drivers/net/wireless/ath/ath9k/ar9330_1p2_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9330_1p2_initvals.h
@@ -345,7 +345,7 @@ static const u32 ar9331_1p2_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00003221, 0x00003221},
-        {0x00009e3c, 0xcf946222, 0xcf946222, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0x02321e27, 0x02321e27, 0x02282324, 0x02282324},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302010, 0x50302010},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -364,7 +364,7 @@ static const u32 ar9331_1p2_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
         {0x0000a288, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
         {0x0000a28c, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00071981, 0x00071981, 0x00071981, 0x00071981},
         {0x0000a2d8, 0xf999a83a, 0xf999a83a, 0xf999a83a, 0xf999a83a},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9340_initvals.h b/drivers/net/wireless/ath/ath9k/ar9340_initvals.h
index b995ffe88b33..2eb163fc1c18 100644
--- a/drivers/net/wireless/ath/ath9k/ar9340_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9340_initvals.h
@@ -245,7 +245,7 @@ static const u32 ar9340_1p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0x02321e27, 0x02321e27, 0x02291e27, 0x02291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -265,7 +265,7 @@ static const u32 ar9340_1p0_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000150, 0x00000150},
         {0x0000a288, 0x00000220, 0x00000220, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00011111, 0x00011111, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00041983, 0x00041983, 0x00041982, 0x00041982},
         {0x0000a2d8, 0x7999a83a, 0x7999a83a, 0x7999a83a, 0x7999a83a},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9462_2p0_initvals.h b/drivers/net/wireless/ath/ath9k/ar9462_2p0_initvals.h
index 1b6b4d0cfa97..b00dd649453d 100644
--- a/drivers/net/wireless/ath/ath9k/ar9462_2p0_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9462_2p0_initvals.h
@@ -59,7 +59,7 @@ static const u32 ar9462_2p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003a5, 0x000003a5, 0x000003a5, 0x000003a5},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcfd5c782, 0xcfd5c282},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcfd5c780, 0xcfd5c280},
         {0x00009e44, 0x62321e27, 0x62321e27, 0xfe291e27, 0xfe291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -79,7 +79,7 @@ static const u32 ar9462_2p0_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000150, 0x00000150},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00041981, 0x00041981, 0x00041981, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9462_2p1_initvals.h b/drivers/net/wireless/ath/ath9k/ar9462_2p1_initvals.h
index dc3adda46e8b..0f8745ec73b1 100644
--- a/drivers/net/wireless/ath/ath9k/ar9462_2p1_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9462_2p1_initvals.h
@@ -239,7 +239,7 @@ static const u32 ar9462_2p1_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003a5, 0x000003a5, 0x000003a5, 0x000003a5},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcfd5c782, 0xcfd5c282},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcfd5c780, 0xcfd5c280},
         {0x00009e44, 0x62321e27, 0x62321e27, 0xfe291e27, 0xfe291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -259,7 +259,7 @@ static const u32 ar9462_2p1_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000150, 0x00000150},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00041981, 0x00041981, 0x00041981, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9485_initvals.h b/drivers/net/wireless/ath/ath9k/ar9485_initvals.h
index ce83ce47a1ca..bdf6f107f6f1 100644
--- a/drivers/net/wireless/ath/ath9k/ar9485_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9485_initvals.h
@@ -1026,7 +1026,7 @@ static const u32 ar9485_1_1_baseband_postamble[][5] = {
         {0x00009e10, 0x7ec88d2e, 0x7ec88d2e, 0x7ec80d2e, 0x7ec80d2e},
         {0x00009e14, 0x31395d53, 0x31396053, 0x312e6053, 0x312e5d53},
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302010, 0x50302010},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
         {0x0000a204, 0x01303fc0, 0x01303fc4, 0x01303fc4, 0x01303fc0},
@@ -1044,7 +1044,7 @@ static const u32 ar9485_1_1_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x000002a0, 0x000002a0},
         {0x0000a288, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
         {0x0000a28c, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00071981, 0x00071981, 0x00071982, 0x00071982},
         {0x0000a2d8, 0xf999a83a, 0xf999a83a, 0xf999a83a, 0xf999a83a},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ar953x_initvals.h b/drivers/net/wireless/ath/ath9k/ar953x_initvals.h
index c0b90daa3e3d..924ae6bde7f1 100644
--- a/drivers/net/wireless/ath/ath9k/ar953x_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar953x_initvals.h
@@ -988,7 +988,7 @@ static const u32 qca953x_2p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcfa10820, 0xcfa10820, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcfa10820, 0xcfa10820, 0xcf946220, 0xcf946220},
         {0x00009e44, 0xfe321e27, 0xfe321e27, 0xfe291e27, 0xfe291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -1008,7 +1008,7 @@ static const u32 qca953x_2p0_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000010, 0x00000010},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00058d18, 0x00058d18},
         {0x0000a2cc, 0x18c50033, 0x18c43433, 0x18c41033, 0x18c44c33},
         {0x0000a2d0, 0x00041982, 0x00041982, 0x00041982, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
diff --git a/drivers/net/wireless/ath/ath9k/ar955x_1p0_initvals.h b/drivers/net/wireless/ath/ath9k/ar955x_1p0_initvals.h
index 148562addd38..67edf344b427 100644
--- a/drivers/net/wireless/ath/ath9k/ar955x_1p0_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar955x_1p0_initvals.h
@@ -83,7 +83,7 @@ static const u32 ar955x_1p0_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000010, 0x00000010},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00058d18, 0x00058d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2cc, 0x18c50033, 0x18c43433, 0x18c41033, 0x18c44c33},
         {0x0000a2d0, 0x00041982, 0x00041982, 0x00041982, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
diff --git a/drivers/net/wireless/ath/ath9k/ar9565_1p0_initvals.h b/drivers/net/wireless/ath/ath9k/ar9565_1p0_initvals.h
index 10d4a6cb1c3b..35c1bbb2fa8a 100644
--- a/drivers/net/wireless/ath/ath9k/ar9565_1p0_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9565_1p0_initvals.h
@@ -347,7 +347,7 @@ static const u32 ar9565_1p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003a4, 0x000003a4},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946222, 0xcf946222, 0xcf946220, 0xcf946220},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0xfe321e27, 0xfe321e27, 0xfe291e27, 0xfe291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
diff --git a/drivers/net/wireless/ath/ath9k/ar956x_initvals.h b/drivers/net/wireless/ath/ath9k/ar956x_initvals.h
index c3a47eaaf0c0..db051071c676 100644
--- a/drivers/net/wireless/ath/ath9k/ar956x_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar956x_initvals.h
@@ -220,7 +220,7 @@ static const u32 qca956x_1p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003a6, 0x000003a6},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcfa10820, 0xcfa10820, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcfa10820, 0xcfa10820, 0xcf946220, 0xcf946220},
         {0x00009e44, 0xfe321e27, 0xfe321e27, 0xfe291e27, 0xfe291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
diff --git a/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h b/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
index 5d4629f96c15..f4c9befb3949 100644
--- a/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
+++ b/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
@@ -1290,7 +1290,7 @@ static const u32 ar9580_1p0_baseband_postamble[][5] = {
         {0x00009e1c, 0x0001cf9c, 0x0001cf9c, 0x00021f9c, 0x00021f9c},
         {0x00009e20, 0x000003b5, 0x000003b5, 0x000003ce, 0x000003ce},
         {0x00009e2c, 0x0000001c, 0x0000001c, 0x00000021, 0x00000021},
-        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946222, 0xcf946222},
+        {0x00009e3c, 0xcf946220, 0xcf946220, 0xcf946220, 0xcf946220},
         {0x00009e44, 0x02321e27, 0x02321e27, 0x02291e27, 0x02291e27},
         {0x00009e48, 0x5030201a, 0x5030201a, 0x50302012, 0x50302012},
         {0x00009fc8, 0x0003f000, 0x0003f000, 0x0001a000, 0x0001a000},
@@ -1310,7 +1310,7 @@ static const u32 ar9580_1p0_baseband_postamble[][5] = {
         {0x0000a284, 0x00000000, 0x00000000, 0x00000150, 0x00000150},
         {0x0000a288, 0x00000110, 0x00000110, 0x00000110, 0x00000110},
         {0x0000a28c, 0x00022222, 0x00022222, 0x00022222, 0x00022222},
-        {0x0000a2c4, 0x00158d18, 0x00158d18, 0x00158d18, 0x00158d18},
+        {0x0000a2c4, 0x00058d18, 0x00058d18, 0x00058d18, 0x00058d18},
         {0x0000a2d0, 0x00041983, 0x00041983, 0x00041981, 0x00041982},
         {0x0000a2d8, 0x7999a83b, 0x7999a83b, 0x7999a83b, 0x7999a83b},
         {0x0000a358, 0x00000000, 0x00000000, 0x00000000, 0x00000000},
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index 5294595da5a7..93b3793cce2f 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -813,7 +813,6 @@ static inline int ath9k_dump_btcoex(struct ath_softc *sc, u8 *buf, u32 size)
 #ifdef CONFIG_MAC80211_LEDS
 void ath_init_leds(struct ath_softc *sc);
 void ath_deinit_leds(struct ath_softc *sc);
-void ath_fill_led_pin(struct ath_softc *sc);
 #else
 static inline void ath_init_leds(struct ath_softc *sc)
 {
@@ -822,9 +821,6 @@ static inline void ath_init_leds(struct ath_softc *sc)
 static inline void ath_deinit_leds(struct ath_softc *sc)
 {
 }
-static inline void ath_fill_led_pin(struct ath_softc *sc)
-{
-}
 #endif
 
 /************************/
diff --git a/drivers/net/wireless/ath/ath9k/btcoex.c b/drivers/net/wireless/ath/ath9k/btcoex.c
index 5a084d94ed90..618c9df35fc1 100644
--- a/drivers/net/wireless/ath/ath9k/btcoex.c
+++ b/drivers/net/wireless/ath/ath9k/btcoex.c
@@ -15,6 +15,8 @@
  */
 
 #include <linux/export.h>
+#include <linux/types.h>
+#include <linux/ath9k_platform.h>
 #include "hw.h"
 
 enum ath_bt_mode {
@@ -34,6 +36,8 @@ struct ath_btcoex_config {
         u8 bt_priority_time;
         u8 bt_first_slot_time;
         bool bt_hold_rx_clear;
+        u8 wl_active_time;
+        u8 wl_qc_time;
 };
 
 static const u32 ar9003_wlan_weights[ATH_BTCOEX_STOMP_MAX]
@@ -65,31 +69,71 @@ void ath9k_hw_init_btcoex_hw(struct ath_hw *ah, int qnum)
                 .bt_priority_time = 2,
                 .bt_first_slot_time = 5,
                 .bt_hold_rx_clear = true,
+                .wl_active_time = 0x20,
+                .wl_qc_time = 0x20,
         };
         bool rxclear_polarity = ath_bt_config.bt_rxclear_polarity;
+        u8 time_extend = ath_bt_config.bt_time_extend;
+        u8 first_slot_time = ath_bt_config.bt_first_slot_time;
 
         if (AR_SREV_9300_20_OR_LATER(ah))
                 rxclear_polarity = !ath_bt_config.bt_rxclear_polarity;
 
+        if (AR_SREV_SOC(ah)) {
+                first_slot_time = 0x1d;
+                time_extend = 0xa;
+
+                btcoex_hw->bt_coex_mode3 =
+                        SM(ath_bt_config.wl_active_time, AR_BT_WL_ACTIVE_TIME) |
+                        SM(ath_bt_config.wl_qc_time, AR_BT_WL_QC_TIME);
+
+                btcoex_hw->bt_coex_mode2 =
+                        AR_BT_PROTECT_BT_AFTER_WAKEUP |
+                        AR_BT_PHY_ERR_BT_COLL_ENABLE;
+        }
+
         btcoex_hw->bt_coex_mode =
                 (btcoex_hw->bt_coex_mode & AR_BT_QCU_THRESH) |
-                SM(ath_bt_config.bt_time_extend, AR_BT_TIME_EXTEND) |
+                SM(time_extend, AR_BT_TIME_EXTEND) |
                 SM(ath_bt_config.bt_txstate_extend, AR_BT_TXSTATE_EXTEND) |
                 SM(ath_bt_config.bt_txframe_extend, AR_BT_TX_FRAME_EXTEND) |
                 SM(ath_bt_config.bt_mode, AR_BT_MODE) |
                 SM(ath_bt_config.bt_quiet_collision, AR_BT_QUIET) |
                 SM(rxclear_polarity, AR_BT_RX_CLEAR_POLARITY) |
                 SM(ath_bt_config.bt_priority_time, AR_BT_PRIORITY_TIME) |
-                SM(ath_bt_config.bt_first_slot_time, AR_BT_FIRST_SLOT_TIME) |
+                SM(first_slot_time, AR_BT_FIRST_SLOT_TIME) |
                 SM(qnum, AR_BT_QCU_THRESH);
 
-        btcoex_hw->bt_coex_mode2 =
+        btcoex_hw->bt_coex_mode2 |=
                 SM(ath_bt_config.bt_hold_rx_clear, AR_BT_HOLD_RX_CLEAR) |
                 SM(ATH_BTCOEX_BMISS_THRESH, AR_BT_BCN_MISS_THRESH) |
                 AR_BT_DISABLE_BT_ANT;
 }
 EXPORT_SYMBOL(ath9k_hw_init_btcoex_hw);
 
+static void ath9k_hw_btcoex_pin_init(struct ath_hw *ah, u8 wlanactive_gpio,
+                                     u8 btactive_gpio, u8 btpriority_gpio)
+{
+        struct ath_btcoex_hw *btcoex_hw = &ah->btcoex_hw;
+        struct ath9k_platform_data *pdata = ah->dev->platform_data;
+
+        if (btcoex_hw->scheme != ATH_BTCOEX_CFG_2WIRE &&
+            btcoex_hw->scheme != ATH_BTCOEX_CFG_3WIRE)
+                return;
+
+        /* bt priority GPIO will be ignored by 2 wire scheme */
+        if (pdata && (pdata->bt_active_pin || pdata->bt_priority_pin ||
+                      pdata->wlan_active_pin)) {
+                btcoex_hw->btactive_gpio = pdata->bt_active_pin;
+                btcoex_hw->wlanactive_gpio = pdata->wlan_active_pin;
+                btcoex_hw->btpriority_gpio = pdata->bt_priority_pin;
+        } else {
+                btcoex_hw->btactive_gpio = btactive_gpio;
+                btcoex_hw->wlanactive_gpio = wlanactive_gpio;
+                btcoex_hw->btpriority_gpio = btpriority_gpio;
+        }
+}
+
 void ath9k_hw_btcoex_init_scheme(struct ath_hw *ah)
 {
         struct ath_common *common = ath9k_hw_common(ah);
@@ -107,19 +151,19 @@ void ath9k_hw_btcoex_init_scheme(struct ath_hw *ah)
                 btcoex_hw->scheme = ATH_BTCOEX_CFG_MCI;
         } else if (AR_SREV_9300_20_OR_LATER(ah)) {
                 btcoex_hw->scheme = ATH_BTCOEX_CFG_3WIRE;
-                btcoex_hw->btactive_gpio = ATH_BTACTIVE_GPIO_9300;
-                btcoex_hw->wlanactive_gpio = ATH_WLANACTIVE_GPIO_9300;
-                btcoex_hw->btpriority_gpio = ATH_BTPRIORITY_GPIO_9300;
-        } else if (AR_SREV_9280_20_OR_LATER(ah)) {
-                btcoex_hw->btactive_gpio = ATH_BTACTIVE_GPIO_9280;
-                btcoex_hw->wlanactive_gpio = ATH_WLANACTIVE_GPIO_9280;
 
-                if (AR_SREV_9285(ah)) {
+                ath9k_hw_btcoex_pin_init(ah, ATH_WLANACTIVE_GPIO_9300,
+                                         ATH_BTACTIVE_GPIO_9300,
+                                         ATH_BTPRIORITY_GPIO_9300);
+        } else if (AR_SREV_9280_20_OR_LATER(ah)) {
+                if (AR_SREV_9285(ah))
                         btcoex_hw->scheme = ATH_BTCOEX_CFG_3WIRE;
-                        btcoex_hw->btpriority_gpio = ATH_BTPRIORITY_GPIO_9285;
-                } else {
+                else
                         btcoex_hw->scheme = ATH_BTCOEX_CFG_2WIRE;
-                }
+
+                ath9k_hw_btcoex_pin_init(ah, ATH_WLANACTIVE_GPIO_9280,
+                                         ATH_BTACTIVE_GPIO_9280,
+                                         ATH_BTPRIORITY_GPIO_9285);
         }
 }
 EXPORT_SYMBOL(ath9k_hw_btcoex_init_scheme);
@@ -137,12 +181,14 @@ void ath9k_hw_btcoex_init_2wire(struct ath_hw *ah)
                     AR_GPIO_INPUT_EN_VAL_BT_ACTIVE_BB);
 
         /* Set input mux for bt_active to gpio pin */
-        REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
-                      AR_GPIO_INPUT_MUX1_BT_ACTIVE,
-                      btcoex_hw->btactive_gpio);
+        if (!AR_SREV_SOC(ah))
+                REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
+                              AR_GPIO_INPUT_MUX1_BT_ACTIVE,
+                              btcoex_hw->btactive_gpio);
 
         /* Configure the desired gpio port for input */
-        ath9k_hw_cfg_gpio_input(ah, btcoex_hw->btactive_gpio);
+        ath9k_hw_gpio_request_in(ah, btcoex_hw->btactive_gpio,
+                                 "ath9k-btactive");
 }
 EXPORT_SYMBOL(ath9k_hw_btcoex_init_2wire);
 
@@ -157,21 +203,33 @@ void ath9k_hw_btcoex_init_3wire(struct ath_hw *ah)
 
         /* Set input mux for bt_prority_async and
          *                  bt_active_async to GPIO pins */
-        REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
-                        AR_GPIO_INPUT_MUX1_BT_ACTIVE,
-                        btcoex_hw->btactive_gpio);
-
-        REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
-                        AR_GPIO_INPUT_MUX1_BT_PRIORITY,
-                        btcoex_hw->btpriority_gpio);
+        if (!AR_SREV_SOC(ah)) {
+                REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
+                              AR_GPIO_INPUT_MUX1_BT_ACTIVE,
+                              btcoex_hw->btactive_gpio);
+                REG_RMW_FIELD(ah, AR_GPIO_INPUT_MUX1,
+                              AR_GPIO_INPUT_MUX1_BT_PRIORITY,
+                              btcoex_hw->btpriority_gpio);
+        }
 
         /* Configure the desired GPIO ports for input */
-
-        ath9k_hw_cfg_gpio_input(ah, btcoex_hw->btactive_gpio);
-        ath9k_hw_cfg_gpio_input(ah, btcoex_hw->btpriority_gpio);
+        ath9k_hw_gpio_request_in(ah, btcoex_hw->btactive_gpio,
+                                 "ath9k-btactive");
+        ath9k_hw_gpio_request_in(ah, btcoex_hw->btpriority_gpio,
+                                 "ath9k-btpriority");
 }
 EXPORT_SYMBOL(ath9k_hw_btcoex_init_3wire);
 
+void ath9k_hw_btcoex_deinit(struct ath_hw *ah)
+{
+        struct ath_btcoex_hw *btcoex_hw = &ah->btcoex_hw;
+
+        ath9k_hw_gpio_free(ah, btcoex_hw->btactive_gpio);
+        ath9k_hw_gpio_free(ah, btcoex_hw->btpriority_gpio);
+        ath9k_hw_gpio_free(ah, btcoex_hw->wlanactive_gpio);
+}
+EXPORT_SYMBOL(ath9k_hw_btcoex_deinit);
+
 void ath9k_hw_btcoex_init_mci(struct ath_hw *ah)
 {
         ah->btcoex_hw.mci.ready = false;
@@ -201,8 +259,9 @@ static void ath9k_hw_btcoex_enable_2wire(struct ath_hw *ah)
         struct ath_btcoex_hw *btcoex_hw = &ah->btcoex_hw;
 
         /* Configure the desired GPIO port for TX_FRAME output */
-        ath9k_hw_cfg_output(ah, btcoex_hw->wlanactive_gpio,
-                            AR_GPIO_OUTPUT_MUX_AS_TX_FRAME);
+        ath9k_hw_gpio_request_out(ah, btcoex_hw->wlanactive_gpio,
+                                  "ath9k-wlanactive",
+                                  AR_GPIO_OUTPUT_MUX_AS_TX_FRAME);
 }
 
 /*
@@ -247,13 +306,13 @@ void ath9k_hw_btcoex_set_weight(struct ath_hw *ah,
                                  txprio_shift[i-1]);
                 }
         }
+
         /* Last WLAN weight has to be adjusted wrt tx priority */
         if (concur_tx) {
                 btcoex_hw->wlan_weight[i-1] &= ~(0xff << txprio_shift[i-1]);
                 btcoex_hw->wlan_weight[i-1] |= (btcoex_hw->tx_prio[stomp_type]
                                                       << txprio_shift[i-1]);
         }
-
 }
 EXPORT_SYMBOL(ath9k_hw_btcoex_set_weight);
 
@@ -268,9 +327,14 @@ static void ath9k_hw_btcoex_enable_3wire(struct ath_hw *ah)
          * Program coex mode and weight registers to
          * enable coex 3-wire
          */
+        if (AR_SREV_SOC(ah))
+                REG_CLR_BIT(ah, AR_BT_COEX_MODE2, AR_BT_PHY_ERR_BT_COLL_ENABLE);
+
         REG_WRITE(ah, AR_BT_COEX_MODE, btcoex->bt_coex_mode);
         REG_WRITE(ah, AR_BT_COEX_MODE2, btcoex->bt_coex_mode2);
 
+        if (AR_SREV_SOC(ah))
+                REG_WRITE(ah, AR_BT_COEX_MODE3, btcoex->bt_coex_mode3);
 
         if (AR_SREV_9300_20_OR_LATER(ah)) {
                 REG_WRITE(ah, AR_BT_COEX_WL_WEIGHTS0, btcoex->wlan_weight[0]);
@@ -281,8 +345,6 @@ static void ath9k_hw_btcoex_enable_3wire(struct ath_hw *ah)
         } else
                 REG_WRITE(ah, AR_BT_COEX_WEIGHT, btcoex->bt_coex_weights);
 
-
-
         if (AR_SREV_9271(ah)) {
                 val = REG_READ(ah, 0x50040);
                 val &= 0xFFFFFEFF;
@@ -292,8 +354,9 @@ static void ath9k_hw_btcoex_enable_3wire(struct ath_hw *ah)
         REG_RMW_FIELD(ah, AR_QUIET1, AR_QUIET1_QUIET_ACK_CTS_ENABLE, 1);
         REG_RMW_FIELD(ah, AR_PCU_MISC, AR_PCU_BT_ANT_PREVENT_RX, 0);
 
-        ath9k_hw_cfg_output(ah, btcoex->wlanactive_gpio,
-                            AR_GPIO_OUTPUT_MUX_AS_RX_CLEAR_EXTERNAL);
+        ath9k_hw_gpio_request_out(ah, btcoex->wlanactive_gpio,
+                                  "ath9k-wlanactive",
+                                  AR_GPIO_OUTPUT_MUX_AS_RX_CLEAR_EXTERNAL);
 }
 
 static void ath9k_hw_btcoex_enable_mci(struct ath_hw *ah)
@@ -339,7 +402,8 @@ void ath9k_hw_btcoex_enable(struct ath_hw *ah)
                 break;
         }
 
-        if (ath9k_hw_get_btcoex_scheme(ah) != ATH_BTCOEX_CFG_MCI) {
+        if (ath9k_hw_get_btcoex_scheme(ah) != ATH_BTCOEX_CFG_MCI &&
+            !AR_SREV_SOC(ah)) {
                 REG_RMW(ah, AR_GPIO_PDPU,
                         (0x2 << (btcoex_hw->btactive_gpio * 2)),
                         (0x3 << (btcoex_hw->btactive_gpio * 2)));
@@ -364,8 +428,8 @@ void ath9k_hw_btcoex_disable(struct ath_hw *ah)
         if (!AR_SREV_9300_20_OR_LATER(ah))
                 ath9k_hw_set_gpio(ah, btcoex_hw->wlanactive_gpio, 0);
 
-        ath9k_hw_cfg_output(ah, btcoex_hw->wlanactive_gpio,
-                        AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+        ath9k_hw_gpio_request_out(ah, btcoex_hw->wlanactive_gpio,
+                                  NULL, AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 
         if (btcoex_hw->scheme == ATH_BTCOEX_CFG_3WIRE) {
                 REG_WRITE(ah, AR_BT_COEX_MODE, AR_BT_QUIET | AR_BT_MODE);
diff --git a/drivers/net/wireless/ath/ath9k/btcoex.h b/drivers/net/wireless/ath/ath9k/btcoex.h
index cd2f0a2373cb..1bdfa8465b92 100644
--- a/drivers/net/wireless/ath/ath9k/btcoex.h
+++ b/drivers/net/wireless/ath/ath9k/btcoex.h
@@ -115,6 +115,7 @@ struct ath_btcoex_hw {
         u32 bt_coex_mode;       /* Register setting for AR_BT_COEX_MODE */
         u32 bt_coex_weights;    /* Register setting for AR_BT_COEX_WEIGHT */
         u32 bt_coex_mode2;      /* Register setting for AR_BT_COEX_MODE2 */
+        u32 bt_coex_mode3;      /* Register setting for AR_BT_COEX_MODE3 */
         u32 bt_weight[AR9300_NUM_BT_WEIGHTS];
         u32 wlan_weight[AR9300_NUM_WLAN_WEIGHTS];
         u8 tx_prio[ATH_BTCOEX_STOMP_MAX];
@@ -123,6 +124,7 @@ struct ath_btcoex_hw {
 void ath9k_hw_btcoex_init_scheme(struct ath_hw *ah);
 void ath9k_hw_btcoex_init_2wire(struct ath_hw *ah);
 void ath9k_hw_btcoex_init_3wire(struct ath_hw *ah);
+void ath9k_hw_btcoex_deinit(struct ath_hw *ah);
 void ath9k_hw_btcoex_init_mci(struct ath_hw *ah);
 void ath9k_hw_init_btcoex_hw(struct ath_hw *ah, int qnum);
 void ath9k_hw_btcoex_set_weight(struct ath_hw *ah,
diff --git a/drivers/net/wireless/ath/ath9k/calib.c b/drivers/net/wireless/ath/ath9k/calib.c
index 37f6d66d1671..0f71146b781d 100644
--- a/drivers/net/wireless/ath/ath9k/calib.c
+++ b/drivers/net/wireless/ath/ath9k/calib.c
@@ -145,14 +145,14 @@ static void ath9k_hw_update_nfcal_hist_buffer(struct ath_hw *ah,
 }
 
 static bool ath9k_hw_get_nf_thresh(struct ath_hw *ah,
-                                   enum ieee80211_band band,
+                                   enum nl80211_band band,
                                    int16_t *nft)
 {
         switch (band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 *nft = (int8_t)ah->eep_ops->get_eeprom(ah, EEP_NFTHRESH_5);
                 break;
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 *nft = (int8_t)ah->eep_ops->get_eeprom(ah, EEP_NFTHRESH_2);
                 break;
         default:
diff --git a/drivers/net/wireless/ath/ath9k/channel.c b/drivers/net/wireless/ath/ath9k/channel.c
index 319cb5f25f58..e56bafcf5864 100644
--- a/drivers/net/wireless/ath/ath9k/channel.c
+++ b/drivers/net/wireless/ath/ath9k/channel.c
@@ -107,9 +107,9 @@ void ath_chanctx_init(struct ath_softc *sc)
         struct ieee80211_channel *chan;
         int i, j;
 
-        sband = &common->sbands[IEEE80211_BAND_2GHZ];
+        sband = &common->sbands[NL80211_BAND_2GHZ];
         if (!sband->n_channels)
-                sband = &common->sbands[IEEE80211_BAND_5GHZ];
+                sband = &common->sbands[NL80211_BAND_5GHZ];
 
         chan = &sband->channels[0];
         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
@@ -1333,9 +1333,9 @@ void ath9k_offchannel_init(struct ath_softc *sc)
         struct ieee80211_channel *chan;
         int i;
 
-        sband = &common->sbands[IEEE80211_BAND_2GHZ];
+        sband = &common->sbands[NL80211_BAND_2GHZ];
         if (!sband->n_channels)
-                sband = &common->sbands[IEEE80211_BAND_5GHZ];
+                sband = &common->sbands[NL80211_BAND_5GHZ];
 
         chan = &sband->channels[0];
 
diff --git a/drivers/net/wireless/ath/ath9k/common-init.c b/drivers/net/wireless/ath/ath9k/common-init.c
index a006c1499728..8b4f7fdabf58 100644
--- a/drivers/net/wireless/ath/ath9k/common-init.c
+++ b/drivers/net/wireless/ath/ath9k/common-init.c
@@ -19,14 +19,14 @@
 #include "common.h"
 
 #define CHAN2G(_freq, _idx)  { \
-        .band = IEEE80211_BAND_2GHZ, \
+        .band = NL80211_BAND_2GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_idx), \
         .max_power = 20, \
 }
 
 #define CHAN5G(_freq, _idx) { \
-        .band = IEEE80211_BAND_5GHZ, \
+        .band = NL80211_BAND_5GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_idx), \
         .max_power = 20, \
@@ -139,12 +139,12 @@ int ath9k_cmn_init_channels_rates(struct ath_common *common)
 
                 memcpy(channels, ath9k_2ghz_chantable,
                        sizeof(ath9k_2ghz_chantable));
-                common->sbands[IEEE80211_BAND_2GHZ].channels = channels;
-                common->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
-                common->sbands[IEEE80211_BAND_2GHZ].n_channels =
+                common->sbands[NL80211_BAND_2GHZ].channels = channels;
+                common->sbands[NL80211_BAND_2GHZ].band = NL80211_BAND_2GHZ;
+                common->sbands[NL80211_BAND_2GHZ].n_channels =
                         ARRAY_SIZE(ath9k_2ghz_chantable);
-                common->sbands[IEEE80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
-                common->sbands[IEEE80211_BAND_2GHZ].n_bitrates =
+                common->sbands[NL80211_BAND_2GHZ].bitrates = ath9k_legacy_rates;
+                common->sbands[NL80211_BAND_2GHZ].n_bitrates =
                         ARRAY_SIZE(ath9k_legacy_rates);
         }
 
@@ -156,13 +156,13 @@ int ath9k_cmn_init_channels_rates(struct ath_common *common)
 
                 memcpy(channels, ath9k_5ghz_chantable,
                        sizeof(ath9k_5ghz_chantable));
-                common->sbands[IEEE80211_BAND_5GHZ].channels = channels;
-                common->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
-                common->sbands[IEEE80211_BAND_5GHZ].n_channels =
+                common->sbands[NL80211_BAND_5GHZ].channels = channels;
+                common->sbands[NL80211_BAND_5GHZ].band = NL80211_BAND_5GHZ;
+                common->sbands[NL80211_BAND_5GHZ].n_channels =
                         ARRAY_SIZE(ath9k_5ghz_chantable);
-                common->sbands[IEEE80211_BAND_5GHZ].bitrates =
+                common->sbands[NL80211_BAND_5GHZ].bitrates =
                         ath9k_legacy_rates + 4;
-                common->sbands[IEEE80211_BAND_5GHZ].n_bitrates =
+                common->sbands[NL80211_BAND_5GHZ].n_bitrates =
                         ARRAY_SIZE(ath9k_legacy_rates) - 4;
         }
         return 0;
@@ -236,9 +236,9 @@ void ath9k_cmn_reload_chainmask(struct ath_hw *ah)
 
         if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
                 ath9k_cmn_setup_ht_cap(ah,
-                        &common->sbands[IEEE80211_BAND_2GHZ].ht_cap);
+                        &common->sbands[NL80211_BAND_2GHZ].ht_cap);
         if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
                 ath9k_cmn_setup_ht_cap(ah,
-                        &common->sbands[IEEE80211_BAND_5GHZ].ht_cap);
+                        &common->sbands[NL80211_BAND_5GHZ].ht_cap);
 }
 EXPORT_SYMBOL(ath9k_cmn_reload_chainmask);
diff --git a/drivers/net/wireless/ath/ath9k/common.c b/drivers/net/wireless/ath/ath9k/common.c
index e8c699446470..b80e08b13b74 100644
--- a/drivers/net/wireless/ath/ath9k/common.c
+++ b/drivers/net/wireless/ath/ath9k/common.c
@@ -173,7 +173,7 @@ int ath9k_cmn_process_rate(struct ath_common *common,
                            struct ieee80211_rx_status *rxs)
 {
         struct ieee80211_supported_band *sband;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         unsigned int i = 0;
         struct ath_hw *ah = common->ah;
 
@@ -305,7 +305,7 @@ static void ath9k_cmn_update_ichannel(struct ath9k_channel *ichan,
         ichan->channel = chan->center_freq;
         ichan->chan = chan;
 
-        if (chan->band == IEEE80211_BAND_5GHZ)
+        if (chan->band == NL80211_BAND_5GHZ)
                 flags |= CHANNEL_5GHZ;
 
         switch (chandef->width) {
diff --git a/drivers/net/wireless/ath/ath9k/debug.c b/drivers/net/wireless/ath/ath9k/debug.c
index 6de64cface3c..c56e40ff35e5 100644
--- a/drivers/net/wireless/ath/ath9k/debug.c
+++ b/drivers/net/wireless/ath/ath9k/debug.c
@@ -916,10 +916,21 @@ static int open_file_regdump(struct inode *inode, struct file *file)
         struct ath_softc *sc = inode->i_private;
         unsigned int len = 0;
         u8 *buf;
-        int i;
+        int i, j = 0;
         unsigned long num_regs, regdump_len, max_reg_offset;
+        const struct reg_hole {
+                u32 start;
+                u32 end;
+        } reg_hole_list[] = {
+                {0x0200, 0x07fc},
+                {0x0c00, 0x0ffc},
+                {0x2000, 0x3ffc},
+                {0x4100, 0x6ffc},
+                {0x705c, 0x7ffc},
+                {0x0000, 0x0000}
+        };
 
-        max_reg_offset = AR_SREV_9300_20_OR_LATER(sc->sc_ah) ? 0x16bd4 : 0xb500;
+        max_reg_offset = AR_SREV_9300_20_OR_LATER(sc->sc_ah) ? 0x8800 : 0xb500;
         num_regs = max_reg_offset / 4 + 1;
         regdump_len = num_regs * REGDUMP_LINE_SIZE + 1;
         buf = vmalloc(regdump_len);
@@ -927,9 +938,16 @@ static int open_file_regdump(struct inode *inode, struct file *file)
                 return -ENOMEM;
 
         ath9k_ps_wakeup(sc);
-        for (i = 0; i < num_regs; i++)
+        for (i = 0; i < num_regs; i++) {
+                if (reg_hole_list[j].start == i << 2) {
+                        i = reg_hole_list[j].end >> 2;
+                        j++;
+                        continue;
+                }
+
                 len += scnprintf(buf + len, regdump_len - len,
                         "0x%06x 0x%08x\n", i << 2, REG_READ(sc->sc_ah, i << 2));
+        }
         ath9k_ps_restore(sc);
 
         file->private_data = buf;
diff --git a/drivers/net/wireless/ath/ath9k/debug_sta.c b/drivers/net/wireless/ath/ath9k/debug_sta.c
index c2ca57a2ed09..b66cfa91364f 100644
--- a/drivers/net/wireless/ath/ath9k/debug_sta.c
+++ b/drivers/net/wireless/ath/ath9k/debug_sta.c
@@ -139,7 +139,7 @@ void ath_debug_rate_stats(struct ath_softc *sc,
         }
 
         if (IS_OFDM_RATE(rs->rs_rate)) {
-                if (ah->curchan->chan->band == IEEE80211_BAND_2GHZ)
+                if (ah->curchan->chan->band == NL80211_BAND_2GHZ)
                         rstats->ofdm_stats[rxs->rate_idx - 4].ofdm_cnt++;
                 else
                         rstats->ofdm_stats[rxs->rate_idx].ofdm_cnt++;
@@ -173,7 +173,7 @@ static ssize_t read_file_node_recv(struct file *file, char __user *user_buf,
         struct ath_hw *ah = sc->sc_ah;
         struct ath_rx_rate_stats *rstats;
         struct ieee80211_sta *sta = an->sta;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u32 len = 0, size = 4096;
         char *buf;
         size_t retval;
@@ -206,7 +206,7 @@ static ssize_t read_file_node_recv(struct file *file, char __user *user_buf,
         len += scnprintf(buf + len, size - len, "\n");
 
 legacy:
-        if (band == IEEE80211_BAND_2GHZ) {
+        if (band == NL80211_BAND_2GHZ) {
                 PRINT_CCK_RATE("CCK-1M/LP", 0, false);
                 PRINT_CCK_RATE("CCK-2M/LP", 1, false);
                 PRINT_CCK_RATE("CCK-5.5M/LP", 2, false);
diff --git a/drivers/net/wireless/ath/ath9k/dynack.c b/drivers/net/wireless/ath/ath9k/dynack.c
index 22b3cc4c27cd..d2ff0fc0484c 100644
--- a/drivers/net/wireless/ath/ath9k/dynack.c
+++ b/drivers/net/wireless/ath/ath9k/dynack.c
@@ -212,7 +212,7 @@ void ath_dynack_sample_tx_ts(struct ath_hw *ah, struct sk_buff *skb,
                 struct ieee80211_tx_rate *rates = info->status.rates;
 
                 rate = &common->sbands[info->band].bitrates[rates[ridx].idx];
-                if (info->band == IEEE80211_BAND_2GHZ &&
+                if (info->band == NL80211_BAND_2GHZ &&
                     !(rate->flags & IEEE80211_RATE_ERP_G))
                         phy = WLAN_RC_PHY_CCK;
                 else
diff --git a/drivers/net/wireless/ath/ath9k/gpio.c b/drivers/net/wireless/ath/ath9k/gpio.c
index 284706798c71..490f74d9ddf0 100644
--- a/drivers/net/wireless/ath/ath9k/gpio.c
+++ b/drivers/net/wireless/ath/ath9k/gpio.c
@@ -21,6 +21,33 @@
 /********************************/
 
 #ifdef CONFIG_MAC80211_LEDS
+
+void ath_fill_led_pin(struct ath_softc *sc)
+{
+        struct ath_hw *ah = sc->sc_ah;
+
+        /* Set default led pin if invalid */
+        if (ah->led_pin < 0) {
+                if (AR_SREV_9287(ah))
+                        ah->led_pin = ATH_LED_PIN_9287;
+                else if (AR_SREV_9485(ah))
+                        ah->led_pin = ATH_LED_PIN_9485;
+                else if (AR_SREV_9300(ah))
+                        ah->led_pin = ATH_LED_PIN_9300;
+                else if (AR_SREV_9462(ah) || AR_SREV_9565(ah))
+                        ah->led_pin = ATH_LED_PIN_9462;
+                else
+                        ah->led_pin = ATH_LED_PIN_DEF;
+        }
+
+        /* Configure gpio for output */
+        ath9k_hw_gpio_request_out(ah, ah->led_pin, "ath9k-led",
+                                  AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+
+        /* LED off, active low */
+        ath9k_hw_set_gpio(ah, ah->led_pin, ah->config.led_active_high ? 0 : 1);
+}
+
 static void ath_led_brightness(struct led_classdev *led_cdev,
                                enum led_brightness brightness)
 {
@@ -40,6 +67,8 @@ void ath_deinit_leds(struct ath_softc *sc)
 
         ath_led_brightness(&sc->led_cdev, LED_OFF);
         led_classdev_unregister(&sc->led_cdev);
+
+        ath9k_hw_gpio_free(sc->sc_ah, sc->sc_ah->led_pin);
 }
 
 void ath_init_leds(struct ath_softc *sc)
@@ -49,6 +78,8 @@ void ath_init_leds(struct ath_softc *sc)
         if (AR_SREV_9100(sc->sc_ah))
                 return;
 
+        ath_fill_led_pin(sc);
+
         if (!ath9k_led_blink)
                 sc->led_cdev.default_trigger =
                         ieee80211_get_radio_led_name(sc->hw);
@@ -64,37 +95,6 @@ void ath_init_leds(struct ath_softc *sc)
 
         sc->led_registered = true;
 }
-
-void ath_fill_led_pin(struct ath_softc *sc)
-{
-        struct ath_hw *ah = sc->sc_ah;
-
-        if (AR_SREV_9100(ah))
-                return;
-
-        if (ah->led_pin >= 0) {
-                if (!((1 << ah->led_pin) & AR_GPIO_OE_OUT_MASK))
-                        ath9k_hw_request_gpio(ah, ah->led_pin, "ath9k-led");
-                return;
-        }
-
-        if (AR_SREV_9287(ah))
-                ah->led_pin = ATH_LED_PIN_9287;
-        else if (AR_SREV_9485(sc->sc_ah))
-                ah->led_pin = ATH_LED_PIN_9485;
-        else if (AR_SREV_9300(sc->sc_ah))
-                ah->led_pin = ATH_LED_PIN_9300;
-        else if (AR_SREV_9462(sc->sc_ah) || AR_SREV_9565(sc->sc_ah))
-                ah->led_pin = ATH_LED_PIN_9462;
-        else
-                ah->led_pin = ATH_LED_PIN_DEF;
-
-        /* Configure gpio 1 for output */
-        ath9k_hw_cfg_output(ah, ah->led_pin, AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
-
-        /* LED off, active low */
-        ath9k_hw_set_gpio(ah, ah->led_pin, (ah->config.led_active_high) ? 0 : 1);
-}
 #endif
 
 /*******************/
@@ -402,6 +402,13 @@ void ath9k_deinit_btcoex(struct ath_softc *sc)
 
         if (ath9k_hw_mci_is_enabled(ah))
                 ath_mci_cleanup(sc);
+        else {
+                enum ath_btcoex_scheme scheme = ath9k_hw_get_btcoex_scheme(ah);
+
+                if (scheme == ATH_BTCOEX_CFG_2WIRE ||
+                    scheme == ATH_BTCOEX_CFG_3WIRE)
+                        ath9k_hw_btcoex_deinit(sc->sc_ah);
+        }
 }
 
 int ath9k_init_btcoex(struct ath_softc *sc)
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 8cbf4904db7b..e1c338cb9cb5 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -527,7 +527,7 @@ static void ath9k_hif_usb_rx_stream(struct hif_device_usb *hif_dev,
                                     struct sk_buff *skb)
 {
         struct sk_buff *nskb, *skb_pool[MAX_PKT_NUM_IN_TRANSFER];
-        int index = 0, i = 0, len = skb->len;
+        int index = 0, i, len = skb->len;
         int rx_remain_len, rx_pkt_len;
         u16 pool_index = 0;
         u8 *ptr;
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c b/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
index 2aabcbdaba4e..ecb848b60725 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_gpio.c
@@ -253,17 +253,19 @@ void ath9k_deinit_leds(struct ath9k_htc_priv *priv)
         ath9k_led_brightness(&priv->led_cdev, LED_OFF);
         led_classdev_unregister(&priv->led_cdev);
         cancel_work_sync(&priv->led_work);
+
+        ath9k_hw_gpio_free(priv->ah, priv->ah->led_pin);
 }
 
 
 void ath9k_configure_leds(struct ath9k_htc_priv *priv)
 {
         /* Configure gpio 1 for output */
-        ath9k_hw_cfg_output(priv->ah, priv->ah->led_pin,
-                            AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+        ath9k_hw_gpio_request_out(priv->ah, priv->ah->led_pin,
+                                  "ath9k-led",
+                                  AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
         /* LED off, active low */
         ath9k_hw_set_gpio(priv->ah, priv->ah->led_pin, 1);
-
 }
 
 void ath9k_init_leds(struct ath9k_htc_priv *priv)
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_init.c b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
index 8647ab77c019..c148c6c504f7 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
@@ -262,11 +262,11 @@ static void ath9k_multi_regread(void *hw_priv, u32 *addr,
         __be32 tmpval[8];
         int i, ret;
 
-       for (i = 0; i < count; i++) {
-               tmpaddr[i] = cpu_to_be32(addr[i]);
-       }
+        for (i = 0; i < count; i++) {
+                tmpaddr[i] = cpu_to_be32(addr[i]);
+        }
 
-       ret = ath9k_wmi_cmd(priv->wmi, WMI_REG_READ_CMDID,
+        ret = ath9k_wmi_cmd(priv->wmi, WMI_REG_READ_CMDID,
                            (u8 *)tmpaddr , sizeof(u32) * count,
                            (u8 *)tmpval, sizeof(u32) * count,
                            100);
@@ -275,9 +275,9 @@ static void ath9k_multi_regread(void *hw_priv, u32 *addr,
                         "Multiple REGISTER READ FAILED (count: %d)\n", count);
         }
 
-       for (i = 0; i < count; i++) {
-               val[i] = be32_to_cpu(tmpval[i]);
-       }
+        for (i = 0; i < count; i++) {
+                val[i] = be32_to_cpu(tmpval[i]);
+        }
 }
 
 static void ath9k_regwrite_multi(struct ath_common *common)
@@ -765,11 +765,11 @@ static void ath9k_set_hw_capab(struct ath9k_htc_priv *priv,
                 sizeof(struct htc_frame_hdr) + 4;
 
         if (priv->ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                        &common->sbands[IEEE80211_BAND_2GHZ];
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                        &common->sbands[NL80211_BAND_2GHZ];
         if (priv->ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                        &common->sbands[IEEE80211_BAND_5GHZ];
+                hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                        &common->sbands[NL80211_BAND_5GHZ];
 
         ath9k_cmn_reload_chainmask(ah);
 
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_main.c b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
index 639294a9e34d..8a8d7853da15 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
@@ -1770,8 +1770,8 @@ static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
 
         tmask.vif_index = avp->index;
-        tmask.band = IEEE80211_BAND_2GHZ;
-        tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
+        tmask.band = NL80211_BAND_2GHZ;
+        tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_2GHZ].legacy);
 
         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
         if (ret) {
@@ -1781,8 +1781,8 @@ static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
                 goto out;
         }
 
-        tmask.band = IEEE80211_BAND_5GHZ;
-        tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
+        tmask.band = NL80211_BAND_5GHZ;
+        tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_5GHZ].legacy);
 
         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
         if (ret) {
@@ -1793,8 +1793,8 @@ static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
         }
 
         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
-                mask->control[IEEE80211_BAND_2GHZ].legacy,
-                mask->control[IEEE80211_BAND_5GHZ].legacy);
+                mask->control[NL80211_BAND_2GHZ].legacy,
+                mask->control[NL80211_BAND_5GHZ].legacy);
 out:
         return ret;
 }
diff --git a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
index cc9648f844ae..f333ef1e3e7b 100644
--- a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
+++ b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
@@ -494,7 +494,7 @@ static void ath9k_htc_tx_process(struct ath9k_htc_priv *priv,
                 if (txs->ts_flags & ATH9K_HTC_TXSTAT_SGI)
                         rate->flags |= IEEE80211_TX_RC_SHORT_GI;
         } else {
-                if (cur_conf->chandef.chan->band == IEEE80211_BAND_5GHZ)
+                if (cur_conf->chandef.chan->band == NL80211_BAND_5GHZ)
                         rate->idx += 4; /* No CCK rates */
         }
 
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index e7a31016f370..42009065e234 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -1582,8 +1582,10 @@ static void ath9k_hw_apply_gpio_override(struct ath_hw *ah)
                 if (!(gpio_mask & 1))
                         continue;
 
-                ath9k_hw_cfg_output(ah, i, AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+                ath9k_hw_gpio_request_out(ah, i, NULL,
+                                          AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
                 ath9k_hw_set_gpio(ah, i, !!(ah->gpio_val & BIT(i)));
+                ath9k_hw_gpio_free(ah, i);
         }
 }
 
@@ -1958,7 +1960,7 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
         ath9k_hw_init_qos(ah);
 
         if (ah->caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
-                ath9k_hw_cfg_gpio_input(ah, ah->rfkill_gpio);
+                ath9k_hw_gpio_request_in(ah, ah->rfkill_gpio, "ath9k-rfkill");
 
         ath9k_hw_init_global_settings(ah);
 
@@ -2385,6 +2387,61 @@ static bool ath9k_hw_dfs_tested(struct ath_hw *ah)
         }
 }
 
+static void ath9k_gpio_cap_init(struct ath_hw *ah)
+{
+        struct ath9k_hw_capabilities *pCap = &ah->caps;
+
+        if (AR_SREV_9271(ah)) {
+                pCap->num_gpio_pins = AR9271_NUM_GPIO;
+                pCap->gpio_mask = AR9271_GPIO_MASK;
+        } else if (AR_DEVID_7010(ah)) {
+                pCap->num_gpio_pins = AR7010_NUM_GPIO;
+                pCap->gpio_mask = AR7010_GPIO_MASK;
+        } else if (AR_SREV_9287(ah)) {
+                pCap->num_gpio_pins = AR9287_NUM_GPIO;
+                pCap->gpio_mask = AR9287_GPIO_MASK;
+        } else if (AR_SREV_9285(ah)) {
+                pCap->num_gpio_pins = AR9285_NUM_GPIO;
+                pCap->gpio_mask = AR9285_GPIO_MASK;
+        } else if (AR_SREV_9280(ah)) {
+                pCap->num_gpio_pins = AR9280_NUM_GPIO;
+                pCap->gpio_mask = AR9280_GPIO_MASK;
+        } else if (AR_SREV_9300(ah)) {
+                pCap->num_gpio_pins = AR9300_NUM_GPIO;
+                pCap->gpio_mask = AR9300_GPIO_MASK;
+        } else if (AR_SREV_9330(ah)) {
+                pCap->num_gpio_pins = AR9330_NUM_GPIO;
+                pCap->gpio_mask = AR9330_GPIO_MASK;
+        } else if (AR_SREV_9340(ah)) {
+                pCap->num_gpio_pins = AR9340_NUM_GPIO;
+                pCap->gpio_mask = AR9340_GPIO_MASK;
+        } else if (AR_SREV_9462(ah)) {
+                pCap->num_gpio_pins = AR9462_NUM_GPIO;
+                pCap->gpio_mask = AR9462_GPIO_MASK;
+        } else if (AR_SREV_9485(ah)) {
+                pCap->num_gpio_pins = AR9485_NUM_GPIO;
+                pCap->gpio_mask = AR9485_GPIO_MASK;
+        } else if (AR_SREV_9531(ah)) {
+                pCap->num_gpio_pins = AR9531_NUM_GPIO;
+                pCap->gpio_mask = AR9531_GPIO_MASK;
+        } else if (AR_SREV_9550(ah)) {
+                pCap->num_gpio_pins = AR9550_NUM_GPIO;
+                pCap->gpio_mask = AR9550_GPIO_MASK;
+        } else if (AR_SREV_9561(ah)) {
+                pCap->num_gpio_pins = AR9561_NUM_GPIO;
+                pCap->gpio_mask = AR9561_GPIO_MASK;
+        } else if (AR_SREV_9565(ah)) {
+                pCap->num_gpio_pins = AR9565_NUM_GPIO;
+                pCap->gpio_mask = AR9565_GPIO_MASK;
+        } else if (AR_SREV_9580(ah)) {
+                pCap->num_gpio_pins = AR9580_NUM_GPIO;
+                pCap->gpio_mask = AR9580_GPIO_MASK;
+        } else {
+                pCap->num_gpio_pins = AR_NUM_GPIO;
+                pCap->gpio_mask = AR_GPIO_MASK;
+        }
+}
+
 int ath9k_hw_fill_cap_info(struct ath_hw *ah)
 {
         struct ath9k_hw_capabilities *pCap = &ah->caps;
@@ -2478,20 +2535,7 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
         else
                 pCap->hw_caps &= ~ATH9K_HW_CAP_HT;
 
-        if (AR_SREV_9271(ah))
-                pCap->num_gpio_pins = AR9271_NUM_GPIO;
-        else if (AR_DEVID_7010(ah))
-                pCap->num_gpio_pins = AR7010_NUM_GPIO;
-        else if (AR_SREV_9300_20_OR_LATER(ah))
-                pCap->num_gpio_pins = AR9300_NUM_GPIO;
-        else if (AR_SREV_9287_11_OR_LATER(ah))
-                pCap->num_gpio_pins = AR9287_NUM_GPIO;
-        else if (AR_SREV_9285_12_OR_LATER(ah))
-                pCap->num_gpio_pins = AR9285_NUM_GPIO;
-        else if (AR_SREV_9280_20_OR_LATER(ah))
-                pCap->num_gpio_pins = AR928X_NUM_GPIO;
-        else
-                pCap->num_gpio_pins = AR_NUM_GPIO;
+        ath9k_gpio_cap_init(ah);
 
         if (AR_SREV_9160_10_OR_LATER(ah) || AR_SREV_9100(ah))
                 pCap->rts_aggr_limit = ATH_AMPDU_LIMIT_MAX;
@@ -2612,8 +2656,7 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah)
 /* GPIO / RFKILL / Antennae */
 /****************************/
 
-static void ath9k_hw_gpio_cfg_output_mux(struct ath_hw *ah,
-                                         u32 gpio, u32 type)
+static void ath9k_hw_gpio_cfg_output_mux(struct ath_hw *ah, u32 gpio, u32 type)
 {
         int addr;
         u32 gpio_shift, tmp;
@@ -2627,8 +2670,8 @@ static void ath9k_hw_gpio_cfg_output_mux(struct ath_hw *ah,
 
         gpio_shift = (gpio % 6) * 5;
 
-        if (AR_SREV_9280_20_OR_LATER(ah)
-            || (addr != AR_GPIO_OUTPUT_MUX1)) {
+        if (AR_SREV_9280_20_OR_LATER(ah) ||
+            (addr != AR_GPIO_OUTPUT_MUX1)) {
                 REG_RMW(ah, addr, (type << gpio_shift),
                         (0x1f << gpio_shift));
         } else {
@@ -2640,106 +2683,144 @@ static void ath9k_hw_gpio_cfg_output_mux(struct ath_hw *ah,
         }
 }
 
-void ath9k_hw_cfg_gpio_input(struct ath_hw *ah, u32 gpio)
+/* BSP should set the corresponding MUX register correctly.
+ */
+static void ath9k_hw_gpio_cfg_soc(struct ath_hw *ah, u32 gpio, bool out,
+                                  const char *label)
 {
-        u32 gpio_shift;
+        if (ah->caps.gpio_requested & BIT(gpio))
+                return;
 
-        BUG_ON(gpio >= ah->caps.num_gpio_pins);
+        /* may be requested by BSP, free anyway */
+        gpio_free(gpio);
 
-        if (AR_DEVID_7010(ah)) {
-                gpio_shift = gpio;
-                REG_RMW(ah, AR7010_GPIO_OE,
-                        (AR7010_GPIO_OE_AS_INPUT << gpio_shift),
-                        (AR7010_GPIO_OE_MASK << gpio_shift));
+        if (gpio_request_one(gpio, out ? GPIOF_OUT_INIT_LOW : GPIOF_IN, label))
                 return;
-        }
 
-        gpio_shift = gpio << 1;
-        REG_RMW(ah,
-                AR_GPIO_OE_OUT,
-                (AR_GPIO_OE_OUT_DRV_NO << gpio_shift),
-                (AR_GPIO_OE_OUT_DRV << gpio_shift));
+        ah->caps.gpio_requested |= BIT(gpio);
 }
-EXPORT_SYMBOL(ath9k_hw_cfg_gpio_input);
 
-u32 ath9k_hw_gpio_get(struct ath_hw *ah, u32 gpio)
+static void ath9k_hw_gpio_cfg_wmac(struct ath_hw *ah, u32 gpio, bool out,
+                                   u32 ah_signal_type)
 {
-#define MS_REG_READ(x, y) \
-        (MS(REG_READ(ah, AR_GPIO_IN_OUT), x##_GPIO_IN_VAL) & (AR_GPIO_BIT(y)))
-
-        if (gpio >= ah->caps.num_gpio_pins)
-                return 0xffffffff;
+        u32 gpio_set, gpio_shift = gpio;
 
         if (AR_DEVID_7010(ah)) {
-                u32 val;
-                val = REG_READ(ah, AR7010_GPIO_IN);
-                return (MS(val, AR7010_GPIO_IN_VAL) & AR_GPIO_BIT(gpio)) == 0;
-        } else if (AR_SREV_9300_20_OR_LATER(ah))
-                return (MS(REG_READ(ah, AR_GPIO_IN), AR9300_GPIO_IN_VAL) &
-                        AR_GPIO_BIT(gpio)) != 0;
-        else if (AR_SREV_9271(ah))
-                return MS_REG_READ(AR9271, gpio) != 0;
-        else if (AR_SREV_9287_11_OR_LATER(ah))
-                return MS_REG_READ(AR9287, gpio) != 0;
-        else if (AR_SREV_9285_12_OR_LATER(ah))
-                return MS_REG_READ(AR9285, gpio) != 0;
-        else if (AR_SREV_9280_20_OR_LATER(ah))
-                return MS_REG_READ(AR928X, gpio) != 0;
-        else
-                return MS_REG_READ(AR, gpio) != 0;
+                gpio_set = out ?
+                        AR7010_GPIO_OE_AS_OUTPUT : AR7010_GPIO_OE_AS_INPUT;
+                REG_RMW(ah, AR7010_GPIO_OE, gpio_set << gpio_shift,
+                        AR7010_GPIO_OE_MASK << gpio_shift);
+        } else if (AR_SREV_SOC(ah)) {
+                gpio_set = out ? 1 : 0;
+                REG_RMW(ah, AR_GPIO_OE_OUT, gpio_set << gpio_shift,
+                        gpio_set << gpio_shift);
+        } else {
+                gpio_shift = gpio << 1;
+                gpio_set = out ?
+                        AR_GPIO_OE_OUT_DRV_ALL : AR_GPIO_OE_OUT_DRV_NO;
+                REG_RMW(ah, AR_GPIO_OE_OUT, gpio_set << gpio_shift,
+                        AR_GPIO_OE_OUT_DRV << gpio_shift);
+
+                if (out)
+                        ath9k_hw_gpio_cfg_output_mux(ah, gpio, ah_signal_type);
+        }
 }
-EXPORT_SYMBOL(ath9k_hw_gpio_get);
 
-void ath9k_hw_cfg_output(struct ath_hw *ah, u32 gpio,
-                         u32 ah_signal_type)
+static void ath9k_hw_gpio_request(struct ath_hw *ah, u32 gpio, bool out,
+                                  const char *label, u32 ah_signal_type)
 {
-        u32 gpio_shift;
+        WARN_ON(gpio >= ah->caps.num_gpio_pins);
 
-        if (AR_DEVID_7010(ah)) {
-                gpio_shift = gpio;
-                REG_RMW(ah, AR7010_GPIO_OE,
-                        (AR7010_GPIO_OE_AS_OUTPUT << gpio_shift),
-                        (AR7010_GPIO_OE_MASK << gpio_shift));
-                return;
-        }
+        if (BIT(gpio) & ah->caps.gpio_mask)
+                ath9k_hw_gpio_cfg_wmac(ah, gpio, out, ah_signal_type);
+        else if (AR_SREV_SOC(ah))
+                ath9k_hw_gpio_cfg_soc(ah, gpio, out, label);
+        else
+                WARN_ON(1);
+}
 
-        ath9k_hw_gpio_cfg_output_mux(ah, gpio, ah_signal_type);
-        gpio_shift = 2 * gpio;
-        REG_RMW(ah,
-                AR_GPIO_OE_OUT,
-                (AR_GPIO_OE_OUT_DRV_ALL << gpio_shift),
-                (AR_GPIO_OE_OUT_DRV << gpio_shift));
+void ath9k_hw_gpio_request_in(struct ath_hw *ah, u32 gpio, const char *label)
+{
+        ath9k_hw_gpio_request(ah, gpio, false, label, 0);
 }
-EXPORT_SYMBOL(ath9k_hw_cfg_output);
+EXPORT_SYMBOL(ath9k_hw_gpio_request_in);
 
-void ath9k_hw_set_gpio(struct ath_hw *ah, u32 gpio, u32 val)
+void ath9k_hw_gpio_request_out(struct ath_hw *ah, u32 gpio, const char *label,
+                               u32 ah_signal_type)
 {
-        if (AR_DEVID_7010(ah)) {
-                val = val ? 0 : 1;
-                REG_RMW(ah, AR7010_GPIO_OUT, ((val&1) << gpio),
-                        AR_GPIO_BIT(gpio));
+        ath9k_hw_gpio_request(ah, gpio, true, label, ah_signal_type);
+}
+EXPORT_SYMBOL(ath9k_hw_gpio_request_out);
+
+void ath9k_hw_gpio_free(struct ath_hw *ah, u32 gpio)
+{
+        if (!AR_SREV_SOC(ah))
                 return;
+
+        WARN_ON(gpio >= ah->caps.num_gpio_pins);
+
+        if (ah->caps.gpio_requested & BIT(gpio)) {
+                gpio_free(gpio);
+                ah->caps.gpio_requested &= ~BIT(gpio);
         }
+}
+EXPORT_SYMBOL(ath9k_hw_gpio_free);
 
-        if (AR_SREV_9271(ah))
-                val = ~val;
+u32 ath9k_hw_gpio_get(struct ath_hw *ah, u32 gpio)
+{
+        u32 val = 0xffffffff;
 
-        if ((1 << gpio) & AR_GPIO_OE_OUT_MASK)
-                REG_RMW(ah, AR_GPIO_IN_OUT, ((val & 1) << gpio),
-                        AR_GPIO_BIT(gpio));
-        else
-                gpio_set_value(gpio, val & 1);
+#define MS_REG_READ(x, y) \
+        (MS(REG_READ(ah, AR_GPIO_IN_OUT), x##_GPIO_IN_VAL) & BIT(y))
+
+        WARN_ON(gpio >= ah->caps.num_gpio_pins);
+
+        if (BIT(gpio) & ah->caps.gpio_mask) {
+                if (AR_SREV_9271(ah))
+                        val = MS_REG_READ(AR9271, gpio);
+                else if (AR_SREV_9287(ah))
+                        val = MS_REG_READ(AR9287, gpio);
+                else if (AR_SREV_9285(ah))
+                        val = MS_REG_READ(AR9285, gpio);
+                else if (AR_SREV_9280(ah))
+                        val = MS_REG_READ(AR928X, gpio);
+                else if (AR_DEVID_7010(ah))
+                        val = REG_READ(ah, AR7010_GPIO_IN) & BIT(gpio);
+                else if (AR_SREV_9300_20_OR_LATER(ah))
+                        val = REG_READ(ah, AR_GPIO_IN) & BIT(gpio);
+                else
+                        val = MS_REG_READ(AR, gpio);
+        } else if (BIT(gpio) & ah->caps.gpio_requested) {
+                val = gpio_get_value(gpio) & BIT(gpio);
+        } else {
+                WARN_ON(1);
+        }
+
+        return val;
 }
-EXPORT_SYMBOL(ath9k_hw_set_gpio);
+EXPORT_SYMBOL(ath9k_hw_gpio_get);
 
-void ath9k_hw_request_gpio(struct ath_hw *ah, u32 gpio, const char *label)
+void ath9k_hw_set_gpio(struct ath_hw *ah, u32 gpio, u32 val)
 {
-        if (gpio >= ah->caps.num_gpio_pins)
-                return;
+        WARN_ON(gpio >= ah->caps.num_gpio_pins);
+
+        if (AR_DEVID_7010(ah) || AR_SREV_9271(ah))
+                val = !val;
+        else
+                val = !!val;
 
-        gpio_request_one(gpio, GPIOF_DIR_OUT | GPIOF_INIT_LOW, label);
+        if (BIT(gpio) & ah->caps.gpio_mask) {
+                u32 out_addr = AR_DEVID_7010(ah) ?
+                        AR7010_GPIO_OUT : AR_GPIO_IN_OUT;
+
+                REG_RMW(ah, out_addr, val << gpio, BIT(gpio));
+        } else if (BIT(gpio) & ah->caps.gpio_requested) {
+                gpio_set_value(gpio, val);
+        } else {
+                WARN_ON(1);
+        }
 }
-EXPORT_SYMBOL(ath9k_hw_request_gpio);
+EXPORT_SYMBOL(ath9k_hw_set_gpio);
 
 void ath9k_hw_setantenna(struct ath_hw *ah, u32 antenna)
 {
diff --git a/drivers/net/wireless/ath/ath9k/hw.h b/drivers/net/wireless/ath/ath9k/hw.h
index 831a54415a25..9cbca1229bac 100644
--- a/drivers/net/wireless/ath/ath9k/hw.h
+++ b/drivers/net/wireless/ath/ath9k/hw.h
@@ -160,7 +160,6 @@
 #define AR_GPIO_OUTPUT_MUX_AS_RUCKUS_DATA        0x1e
 
 #define AR_GPIOD_MASK               0x00001FFF
-#define AR_GPIO_BIT(_gpio)          (1 << (_gpio))
 
 #define BASE_ACTIVATE_DELAY         100
 #define RTC_PLL_SETTLE_DELAY        (AR_SREV_9340(ah) ? 1000 : 100)
@@ -301,6 +300,8 @@ struct ath9k_hw_capabilities {
         u8 max_txchains;
         u8 max_rxchains;
         u8 num_gpio_pins;
+        u32 gpio_mask;
+        u32 gpio_requested;
         u8 rx_hp_qdepth;
         u8 rx_lp_qdepth;
         u8 rx_status_len;
@@ -1019,12 +1020,12 @@ int ath9k_hw_fill_cap_info(struct ath_hw *ah);
 u32 ath9k_regd_get_ctl(struct ath_regulatory *reg, struct ath9k_channel *chan);
 
 /* GPIO / RFKILL / Antennae */
-void ath9k_hw_cfg_gpio_input(struct ath_hw *ah, u32 gpio);
+void ath9k_hw_gpio_request_in(struct ath_hw *ah, u32 gpio, const char *label);
+void ath9k_hw_gpio_request_out(struct ath_hw *ah, u32 gpio, const char *label,
+                               u32 ah_signal_type);
+void ath9k_hw_gpio_free(struct ath_hw *ah, u32 gpio);
 u32 ath9k_hw_gpio_get(struct ath_hw *ah, u32 gpio);
-void ath9k_hw_cfg_output(struct ath_hw *ah, u32 gpio,
-                         u32 ah_signal_type);
 void ath9k_hw_set_gpio(struct ath_hw *ah, u32 gpio, u32 val);
-void ath9k_hw_request_gpio(struct ath_hw *ah, u32 gpio, const char *label);
 void ath9k_hw_setantenna(struct ath_hw *ah, u32 antenna);
 
 /* General Operation */
diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index 1c226d63bb03..4bf1e244b49b 100644
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -660,7 +660,6 @@ static int ath9k_init_softc(u16 devid, struct ath_softc *sc,
 
         ath9k_cmn_init_crypto(sc->sc_ah);
         ath9k_init_misc(sc);
-        ath_fill_led_pin(sc);
         ath_chanctx_init(sc);
         ath9k_offchannel_init(sc);
 
@@ -706,9 +705,9 @@ static void ath9k_init_txpower_limits(struct ath_softc *sc)
         struct ath9k_channel *curchan = ah->curchan;
 
         if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
-                ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
+                ath9k_init_band_txpower(sc, NL80211_BAND_2GHZ);
         if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
-                ath9k_init_band_txpower(sc, IEEE80211_BAND_5GHZ);
+                ath9k_init_band_txpower(sc, NL80211_BAND_5GHZ);
 
         ah->curchan = curchan;
 }
@@ -880,11 +879,11 @@ static void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
         sc->ant_tx = hw->wiphy->available_antennas_tx;
 
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                        &common->sbands[IEEE80211_BAND_2GHZ];
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                        &common->sbands[NL80211_BAND_2GHZ];
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                        &common->sbands[IEEE80211_BAND_5GHZ];
+                hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                        &common->sbands[NL80211_BAND_5GHZ];
 
 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
         ath9k_set_mcc_capab(sc, hw);
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 3aed43a63f94..8b6398850657 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -718,12 +718,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
         if (!ath_complete_reset(sc, false))
                 ah->reset_power_on = false;
 
-        if (ah->led_pin >= 0) {
-                ath9k_hw_cfg_output(ah, ah->led_pin,
-                                    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
+        if (ah->led_pin >= 0)
                 ath9k_hw_set_gpio(ah, ah->led_pin,
                                   (ah->config.led_active_high) ? 1 : 0);
-        }
 
         /*
          * Reset key cache to sane defaults (all entries cleared) instead of
@@ -867,11 +864,9 @@ static void ath9k_stop(struct ieee80211_hw *hw)
 
         spin_lock_bh(&sc->sc_pcu_lock);
 
-        if (ah->led_pin >= 0) {
+        if (ah->led_pin >= 0)
                 ath9k_hw_set_gpio(ah, ah->led_pin,
                                   (ah->config.led_active_high) ? 0 : 1);
-                ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
-        }
 
         ath_prepare_reset(sc);
 
@@ -1938,14 +1933,14 @@ static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
         if (idx == 0)
                 ath_update_survey_stats(sc);
 
-        sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
+        sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
         if (sband && idx >= sband->n_channels) {
                 idx -= sband->n_channels;
                 sband = NULL;
         }
 
         if (!sband)
-                sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
+                sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
 
         if (!sband || idx >= sband->n_channels) {
                 spin_unlock_bh(&common->cc_lock);
diff --git a/drivers/net/wireless/ath/ath9k/reg.h b/drivers/net/wireless/ath/ath9k/reg.h
index c8d35febaf0f..9272ca90632b 100644
--- a/drivers/net/wireless/ath/ath9k/reg.h
+++ b/drivers/net/wireless/ath/ath9k/reg.h
@@ -985,6 +985,10 @@
 #define AR_SREV_9561(_ah) \
         (((_ah)->hw_version.macVersion == AR_SREV_VERSION_9561))
 
+#define AR_SREV_SOC(_ah) \
+        (AR_SREV_9340(_ah) || AR_SREV_9531(_ah) || AR_SREV_9550(ah) || \
+         AR_SREV_9561(ah))
+
 /* NOTE: When adding chips newer than Peacock, add chip check here */
 #define AR_SREV_9580_10_OR_LATER(_ah) \
         (AR_SREV_9580(_ah))
@@ -1104,14 +1108,46 @@ enum {
 
 #define AR_PCIE_PHY_REG3                         0x18c08
 
+/* Define correct GPIO numbers and MASK bits to indicate the WMAC
+ * GPIO resource.
+ * Allow SOC chips(AR9340, AR9531, AR9550, AR9561) to access all GPIOs
+ * which rely on gpiolib framework. But restrict SOC AR9330 only to
+ * access WMAC GPIO which has the same design with the old chips.
+ */
 #define AR_NUM_GPIO                              14
-#define AR928X_NUM_GPIO                          10
+#define AR9280_NUM_GPIO                          10
 #define AR9285_NUM_GPIO                          12
-#define AR9287_NUM_GPIO                          11
+#define AR9287_NUM_GPIO                          10
 #define AR9271_NUM_GPIO                          16
-#define AR9300_NUM_GPIO                          17
+#define AR9300_NUM_GPIO                          16
+#define AR9330_NUM_GPIO                          16
+#define AR9340_NUM_GPIO                          23
+#define AR9462_NUM_GPIO                          10
+#define AR9485_NUM_GPIO                          12
+#define AR9531_NUM_GPIO                          18
+#define AR9550_NUM_GPIO                          24
+#define AR9561_NUM_GPIO                          23
+#define AR9565_NUM_GPIO                          12
+#define AR9580_NUM_GPIO                          16
 #define AR7010_NUM_GPIO                          16
 
+#define AR_GPIO_MASK                             0x00003FFF
+#define AR9271_GPIO_MASK                         0x0000FFFF
+#define AR9280_GPIO_MASK                         0x000003FF
+#define AR9285_GPIO_MASK                         0x00000FFF
+#define AR9287_GPIO_MASK                         0x000003FF
+#define AR9300_GPIO_MASK                         0x0000F4FF
+#define AR9330_GPIO_MASK                         0x0000F4FF
+#define AR9340_GPIO_MASK                         0x0000000F
+#define AR9462_GPIO_MASK                         0x000003FF
+#define AR9485_GPIO_MASK                         0x00000FFF
+#define AR9531_GPIO_MASK                         0x0000000F
+#define AR9550_GPIO_MASK                         0x0000000F
+#define AR9561_GPIO_MASK                         0x0000000F
+#define AR9565_GPIO_MASK                         0x00000FFF
+#define AR9580_GPIO_MASK                         0x0000F4FF
+#define AR7010_GPIO_MASK                         0x0000FFFF
+
 #define AR_GPIO_IN_OUT                           (AR_SREV_9340(ah) ? 0x4028 : 0x4048)
 #define AR_GPIO_IN_VAL                           0x0FFFC000
 #define AR_GPIO_IN_VAL_S                         14
@@ -1132,8 +1168,6 @@ enum {
 
 #define AR_GPIO_OE_OUT                           (AR_SREV_9340(ah) ? 0x4030 : \
                                                   (AR_SREV_9300_20_OR_LATER(ah) ? 0x4050 : 0x404c))
-#define AR_GPIO_OE_OUT_MASK                      (AR_SREV_9550_OR_LATER(ah) ? \
-                                                  0x0000000F : 0xFFFFFFFF)
 #define AR_GPIO_OE_OUT_DRV                       0x3
 #define AR_GPIO_OE_OUT_DRV_NO                    0x0
 #define AR_GPIO_OE_OUT_DRV_LOW                   0x1
@@ -1858,15 +1892,33 @@ enum {
 
 #define AR9300_BT_WGHT             0xcccc4444
 
-#define AR_BT_COEX_MODE2           0x817c
-#define AR_BT_BCN_MISS_THRESH      0x000000ff
-#define AR_BT_BCN_MISS_THRESH_S    0
-#define AR_BT_BCN_MISS_CNT         0x0000ff00
-#define AR_BT_BCN_MISS_CNT_S       8
-#define AR_BT_HOLD_RX_CLEAR        0x00010000
-#define AR_BT_HOLD_RX_CLEAR_S      16
-#define AR_BT_DISABLE_BT_ANT       0x00100000
-#define AR_BT_DISABLE_BT_ANT_S     20
+#define AR_BT_COEX_MODE2                0x817c
+#define AR_BT_BCN_MISS_THRESH           0x000000ff
+#define AR_BT_BCN_MISS_THRESH_S         0
+#define AR_BT_BCN_MISS_CNT              0x0000ff00
+#define AR_BT_BCN_MISS_CNT_S            8
+#define AR_BT_HOLD_RX_CLEAR             0x00010000
+#define AR_BT_HOLD_RX_CLEAR_S           16
+#define AR_BT_PROTECT_BT_AFTER_WAKEUP   0x00080000
+#define AR_BT_PROTECT_BT_AFTER_WAKEUP_S 19
+#define AR_BT_DISABLE_BT_ANT            0x00100000
+#define AR_BT_DISABLE_BT_ANT_S          20
+#define AR_BT_QUIET_2_WIRE              0x00200000
+#define AR_BT_QUIET_2_WIRE_S            21
+#define AR_BT_WL_ACTIVE_MODE            0x00c00000
+#define AR_BT_WL_ACTIVE_MODE_S          22
+#define AR_BT_WL_TXRX_SEPARATE          0x01000000
+#define AR_BT_WL_TXRX_SEPARATE_S        24
+#define AR_BT_RS_DISCARD_EXTEND         0x02000000
+#define AR_BT_RS_DISCARD_EXTEND_S       25
+#define AR_BT_TSF_BT_ACTIVE_CTRL        0x0c000000
+#define AR_BT_TSF_BT_ACTIVE_CTRL_S      26
+#define AR_BT_TSF_BT_PRIORITY_CTRL      0x30000000
+#define AR_BT_TSF_BT_PRIORITY_CTRL_S    28
+#define AR_BT_INTERRUPT_ENABLE          0x40000000
+#define AR_BT_INTERRUPT_ENABLE_S        30
+#define AR_BT_PHY_ERR_BT_COLL_ENABLE    0x80000000
+#define AR_BT_PHY_ERR_BT_COLL_ENABLE_S  31
 
 #define AR_TXSIFS              0x81d0
 #define AR_TXSIFS_TIME         0x000000FF
@@ -1875,6 +1927,16 @@ enum {
 #define AR_TXSIFS_ACK_SHIFT    0x00007000
 #define AR_TXSIFS_ACK_SHIFT_S  12
 
+#define AR_BT_COEX_MODE3                        0x81d4
+#define AR_BT_WL_ACTIVE_TIME                    0x000000ff
+#define AR_BT_WL_ACTIVE_TIME_S                  0
+#define AR_BT_WL_QC_TIME                        0x0000ff00
+#define AR_BT_WL_QC_TIME_S                      8
+#define AR_BT_ALLOW_CONCURRENT_ACCESS           0x000f0000
+#define AR_BT_ALLOW_CONCURRENT_ACCESS_S         16
+#define AR_BT_AGC_SATURATION_CNT_ENABLE         0x00100000
+#define AR_BT_AGC_SATURATION_CNT_ENABLE_S       20
+
 #define AR_TXOP_X          0x81ec
 #define AR_TXOP_X_VAL      0x000000FF
 
diff --git a/drivers/net/wireless/ath/ath9k/rng.c b/drivers/net/wireless/ath/ath9k/rng.c
index c9cb2aad7b6f..d38e50f96db7 100644
--- a/drivers/net/wireless/ath/ath9k/rng.c
+++ b/drivers/net/wireless/ath/ath9k/rng.c
@@ -55,11 +55,26 @@ static int ath9k_rng_data_read(struct ath_softc *sc, u32 *buf, u32 buf_size)
         return j << 2;
 }
 
+static u32 ath9k_rng_delay_get(u32 fail_stats)
+{
+        u32 delay;
+
+        if (fail_stats < 100)
+                delay = 10;
+        else if (fail_stats < 105)
+                delay = 1000;
+        else
+                delay = 10000;
+
+        return delay;
+}
+
 static int ath9k_rng_kthread(void *data)
 {
         int bytes_read;
         struct ath_softc *sc = data;
         u32 *rng_buf;
+        u32 delay, fail_stats = 0;
 
         rng_buf = kmalloc_array(ATH9K_RNG_BUF_SIZE, sizeof(u32), GFP_KERNEL);
         if (!rng_buf)
@@ -69,10 +84,13 @@ static int ath9k_rng_kthread(void *data)
                 bytes_read = ath9k_rng_data_read(sc, rng_buf,
                                                  ATH9K_RNG_BUF_SIZE);
                 if (unlikely(!bytes_read)) {
-                        msleep_interruptible(10);
+                        delay = ath9k_rng_delay_get(++fail_stats);
+                        msleep_interruptible(delay);
                         continue;
                 }
 
+                fail_stats = 0;
+
                 /* sleep until entropy bits under write_wakeup_threshold */
                 add_hwgenerator_randomness((void *)rng_buf, bytes_read,
                                            ATH9K_RNG_ENTROPY(bytes_read));
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index fe795fc5288c..8ddd604bd00c 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -1112,7 +1112,7 @@ static u8 ath_get_rate_txpower(struct ath_softc *sc, struct ath_buf *bf,
                                 bool is_2ghz;
                                 struct modal_eep_header *pmodal;
 
-                                is_2ghz = info->band == IEEE80211_BAND_2GHZ;
+                                is_2ghz = info->band == NL80211_BAND_2GHZ;
                                 pmodal = &eep->modalHeader[is_2ghz];
                                 power_ht40delta = pmodal->ht40PowerIncForPdadc;
                         } else {
@@ -1236,7 +1236,7 @@ static void ath_buf_set_rate(struct ath_softc *sc, struct ath_buf *bf,
 
                 /* legacy rates */
                 rate = &common->sbands[tx_info->band].bitrates[rates[i].idx];
-                if ((tx_info->band == IEEE80211_BAND_2GHZ) &&
+                if ((tx_info->band == NL80211_BAND_2GHZ) &&
                     !(rate->flags & IEEE80211_RATE_ERP_G))
                         phy = WLAN_RC_PHY_CCK;
                 else
diff --git a/drivers/net/wireless/ath/carl9170/mac.c b/drivers/net/wireless/ath/carl9170/mac.c
index a2f005703c04..7d4a72dc98db 100644
--- a/drivers/net/wireless/ath/carl9170/mac.c
+++ b/drivers/net/wireless/ath/carl9170/mac.c
@@ -48,7 +48,7 @@ int carl9170_set_dyn_sifs_ack(struct ar9170 *ar)
         if (conf_is_ht40(&ar->hw->conf))
                 val = 0x010a;
         else {
-                if (ar->hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ)
+                if (ar->hw->conf.chandef.chan->band == NL80211_BAND_2GHZ)
                         val = 0x105;
                 else
                         val = 0x104;
@@ -66,7 +66,7 @@ int carl9170_set_rts_cts_rate(struct ar9170 *ar)
                 rts_rate = 0x1da;
                 cts_rate = 0x10a;
         } else {
-                if (ar->hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ) {
+                if (ar->hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) {
                         /* 11 mbit CCK */
                         rts_rate = 033;
                         cts_rate = 003;
@@ -93,7 +93,7 @@ int carl9170_set_slot_time(struct ar9170 *ar)
                 return 0;
         }
 
-        if ((ar->hw->conf.chandef.chan->band == IEEE80211_BAND_5GHZ) ||
+        if ((ar->hw->conf.chandef.chan->band == NL80211_BAND_5GHZ) ||
             vif->bss_conf.use_short_slot)
                 slottime = 9;
 
@@ -120,7 +120,7 @@ int carl9170_set_mac_rates(struct ar9170 *ar)
         basic |= (vif->bss_conf.basic_rates & 0xff0) << 4;
         rcu_read_unlock();
 
-        if (ar->hw->conf.chandef.chan->band == IEEE80211_BAND_5GHZ)
+        if (ar->hw->conf.chandef.chan->band == NL80211_BAND_5GHZ)
                 mandatory = 0xff00; /* OFDM 6/9/12/18/24/36/48/54 */
         else
                 mandatory = 0xff0f; /* OFDM (6/9../54) + CCK (1/2/5.5/11) */
@@ -512,10 +512,10 @@ int carl9170_set_mac_tpc(struct ar9170 *ar, struct ieee80211_channel *channel)
                 chains = AR9170_TX_PHY_TXCHAIN_1;
 
         switch (channel->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 power = ar->power_2G_ofdm[0] & 0x3f;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 power = ar->power_5G_leg[0] & 0x3f;
                 break;
         default:
diff --git a/drivers/net/wireless/ath/carl9170/main.c b/drivers/net/wireless/ath/carl9170/main.c
index 4d1527a2e292..ffb22a04beeb 100644
--- a/drivers/net/wireless/ath/carl9170/main.c
+++ b/drivers/net/wireless/ath/carl9170/main.c
@@ -1666,7 +1666,7 @@ static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
                         return err;
         }
 
-        for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
+        for (b = 0; b < NUM_NL80211_BANDS; b++) {
                 band = ar->hw->wiphy->bands[b];
 
                 if (!band)
@@ -1941,13 +1941,13 @@ static int carl9170_parse_eeprom(struct ar9170 *ar)
         }
 
         if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
-                ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                ar->hw->wiphy->bands[NL80211_BAND_2GHZ] =
                         &carl9170_band_2GHz;
                 chans += carl9170_band_2GHz.n_channels;
                 bands++;
         }
         if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
-                ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
+                ar->hw->wiphy->bands[NL80211_BAND_5GHZ] =
                         &carl9170_band_5GHz;
                 chans += carl9170_band_5GHz.n_channels;
                 bands++;
diff --git a/drivers/net/wireless/ath/carl9170/phy.c b/drivers/net/wireless/ath/carl9170/phy.c
index dca6df13fd5b..34d9fd77046e 100644
--- a/drivers/net/wireless/ath/carl9170/phy.c
+++ b/drivers/net/wireless/ath/carl9170/phy.c
@@ -540,11 +540,11 @@ static int carl9170_init_phy_from_eeprom(struct ar9170 *ar,
         return carl9170_regwrite_result();
 }
 
-static int carl9170_init_phy(struct ar9170 *ar, enum ieee80211_band band)
+static int carl9170_init_phy(struct ar9170 *ar, enum nl80211_band band)
 {
         int i, err;
         u32 val;
-        bool is_2ghz = band == IEEE80211_BAND_2GHZ;
+        bool is_2ghz = band == NL80211_BAND_2GHZ;
         bool is_40mhz = conf_is_ht40(&ar->hw->conf);
 
         carl9170_regwrite_begin(ar);
@@ -1125,13 +1125,13 @@ static int carl9170_set_freq_cal_data(struct ar9170 *ar,
         u8 f, tmp;
 
         switch (channel->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 f = channel->center_freq - 2300;
                 cal_freq_pier = ar->eeprom.cal_freq_pier_2G;
                 i = AR5416_NUM_2G_CAL_PIERS - 1;
                 break;
 
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 f = (channel->center_freq - 4800) / 5;
                 cal_freq_pier = ar->eeprom.cal_freq_pier_5G;
                 i = AR5416_NUM_5G_CAL_PIERS - 1;
@@ -1158,12 +1158,12 @@ static int carl9170_set_freq_cal_data(struct ar9170 *ar,
                         int j;
 
                         switch (channel->band) {
-                        case IEEE80211_BAND_2GHZ:
+                        case NL80211_BAND_2GHZ:
                                 cal_pier_data = &ar->eeprom.
                                         cal_pier_data_2G[chain][idx];
                                 break;
 
-                        case IEEE80211_BAND_5GHZ:
+                        case NL80211_BAND_5GHZ:
                                 cal_pier_data = &ar->eeprom.
                                         cal_pier_data_5G[chain][idx];
                                 break;
@@ -1340,7 +1340,7 @@ static void carl9170_calc_ctl(struct ar9170 *ar, u32 freq, enum carl9170_bw bw)
                 /* skip CTL and heavy clip for CTL_MKK and CTL_ETSI */
                 return;
 
-        if (ar->hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ) {
+        if (ar->hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) {
                 modes = mode_list_2ghz;
                 nr_modes = ARRAY_SIZE(mode_list_2ghz);
         } else {
@@ -1607,7 +1607,7 @@ int carl9170_set_channel(struct ar9170 *ar, struct ieee80211_channel *channel,
                 return err;
 
         err = carl9170_init_rf_banks_0_7(ar,
-                                         channel->band == IEEE80211_BAND_5GHZ);
+                                         channel->band == NL80211_BAND_5GHZ);
         if (err)
                 return err;
 
@@ -1621,7 +1621,7 @@ int carl9170_set_channel(struct ar9170 *ar, struct ieee80211_channel *channel,
                 return err;
 
         err = carl9170_init_rf_bank4_pwr(ar,
-                                         channel->band == IEEE80211_BAND_5GHZ,
+                                         channel->band == NL80211_BAND_5GHZ,
                                          channel->center_freq, bw);
         if (err)
                 return err;
diff --git a/drivers/net/wireless/ath/carl9170/rx.c b/drivers/net/wireless/ath/carl9170/rx.c
index d66533cbc38a..0c34c8729dc6 100644
--- a/drivers/net/wireless/ath/carl9170/rx.c
+++ b/drivers/net/wireless/ath/carl9170/rx.c
@@ -417,7 +417,7 @@ static int carl9170_rx_mac_status(struct ar9170 *ar,
 
                         return -EINVAL;
                 }
-                if (status->band == IEEE80211_BAND_2GHZ)
+                if (status->band == NL80211_BAND_2GHZ)
                         status->rate_idx += 4;
                 break;
 
diff --git a/drivers/net/wireless/ath/carl9170/tx.c b/drivers/net/wireless/ath/carl9170/tx.c
index ae86a600d920..2bf04c9edc98 100644
--- a/drivers/net/wireless/ath/carl9170/tx.c
+++ b/drivers/net/wireless/ath/carl9170/tx.c
@@ -720,12 +720,12 @@ static void carl9170_tx_rate_tpc_chains(struct ar9170 *ar,
                         /* +1 dBm for HT40 */
                         *tpc += 2;
 
-                        if (info->band == IEEE80211_BAND_2GHZ)
+                        if (info->band == NL80211_BAND_2GHZ)
                                 txpower = ar->power_2G_ht40;
                         else
                                 txpower = ar->power_5G_ht40;
                 } else {
-                        if (info->band == IEEE80211_BAND_2GHZ)
+                        if (info->band == NL80211_BAND_2GHZ)
                                 txpower = ar->power_2G_ht20;
                         else
                                 txpower = ar->power_5G_ht20;
@@ -734,7 +734,7 @@ static void carl9170_tx_rate_tpc_chains(struct ar9170 *ar,
                 *phyrate = txrate->idx;
                 *tpc += txpower[idx & 7];
         } else {
-                if (info->band == IEEE80211_BAND_2GHZ) {
+                if (info->band == NL80211_BAND_2GHZ) {
                         if (idx < 4)
                                 txpower = ar->power_2G_cck;
                         else
@@ -797,7 +797,7 @@ static __le32 carl9170_tx_physet(struct ar9170 *ar,
                  * tmp |= cpu_to_le32(AR9170_TX_PHY_GREENFIELD);
                  */
         } else {
-                if (info->band == IEEE80211_BAND_2GHZ) {
+                if (info->band == NL80211_BAND_2GHZ) {
                         if (txrate->idx <= AR9170_TX_PHY_RATE_CCK_11M)
                                 tmp |= cpu_to_le32(AR9170_TX_PHY_MOD_CCK);
                         else
diff --git a/drivers/net/wireless/ath/regd.c b/drivers/net/wireless/ath/regd.c
index 06ea6cc9e30a..7e15ed9ed31f 100644
--- a/drivers/net/wireless/ath/regd.c
+++ b/drivers/net/wireless/ath/regd.c
@@ -336,12 +336,12 @@ ath_reg_apply_beaconing_flags(struct wiphy *wiphy,
                               struct ath_regulatory *reg,
                               enum nl80211_reg_initiator initiator)
 {
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
         unsigned int i;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 if (!wiphy->bands[band])
                         continue;
                 sband = wiphy->bands[band];
@@ -374,7 +374,7 @@ ath_reg_apply_ir_flags(struct wiphy *wiphy,
 {
         struct ieee80211_supported_band *sband;
 
-        sband = wiphy->bands[IEEE80211_BAND_2GHZ];
+        sband = wiphy->bands[NL80211_BAND_2GHZ];
         if (!sband)
                 return;
 
@@ -402,10 +402,10 @@ static void ath_reg_apply_radar_flags(struct wiphy *wiphy)
         struct ieee80211_channel *ch;
         unsigned int i;
 
-        if (!wiphy->bands[IEEE80211_BAND_5GHZ])
+        if (!wiphy->bands[NL80211_BAND_5GHZ])
                 return;
 
-        sband = wiphy->bands[IEEE80211_BAND_5GHZ];
+        sband = wiphy->bands[NL80211_BAND_5GHZ];
 
         for (i = 0; i < sband->n_channels; i++) {
                 ch = &sband->channels[i];
@@ -772,7 +772,7 @@ ath_regd_init(struct ath_regulatory *reg,
 EXPORT_SYMBOL(ath_regd_init);
 
 u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
-                          enum ieee80211_band band)
+                          enum nl80211_band band)
 {
         if (!reg->regpair ||
             (reg->country_code == CTRY_DEFAULT &&
@@ -794,9 +794,9 @@ u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
         }
 
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 return reg->regpair->reg_2ghz_ctl;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 return reg->regpair->reg_5ghz_ctl;
         default:
                 return NO_CTL;
diff --git a/drivers/net/wireless/ath/regd.h b/drivers/net/wireless/ath/regd.h
index 37f53bd8fcb1..565d3075f06e 100644
--- a/drivers/net/wireless/ath/regd.h
+++ b/drivers/net/wireless/ath/regd.h
@@ -255,7 +255,7 @@ int ath_regd_init(struct ath_regulatory *reg, struct wiphy *wiphy,
                   void (*reg_notifier)(struct wiphy *wiphy,
                                        struct regulatory_request *request));
 u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
-                          enum ieee80211_band band);
+                          enum nl80211_band band);
 void ath_reg_notifier_apply(struct wiphy *wiphy,
                             struct regulatory_request *request,
                             struct ath_regulatory *reg);
diff --git a/drivers/net/wireless/ath/wcn36xx/main.c b/drivers/net/wireless/ath/wcn36xx/main.c
index a27279c2c695..9a1db3bbec4e 100644
--- a/drivers/net/wireless/ath/wcn36xx/main.c
+++ b/drivers/net/wireless/ath/wcn36xx/main.c
@@ -26,14 +26,14 @@ module_param_named(debug_mask, wcn36xx_dbg_mask, uint, 0644);
 MODULE_PARM_DESC(debug_mask, "Debugging mask");
 
 #define CHAN2G(_freq, _idx) { \
-        .band = IEEE80211_BAND_2GHZ, \
+        .band = NL80211_BAND_2GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_idx), \
         .max_power = 25, \
 }
 
 #define CHAN5G(_freq, _idx) { \
-        .band = IEEE80211_BAND_5GHZ, \
+        .band = NL80211_BAND_5GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_idx), \
         .max_power = 25, \
@@ -516,7 +516,7 @@ static void wcn36xx_sw_scan_complete(struct ieee80211_hw *hw,
 }
 
 static void wcn36xx_update_allowed_rates(struct ieee80211_sta *sta,
-                                         enum ieee80211_band band)
+                                         enum nl80211_band band)
 {
         int i, size;
         u16 *rates_table;
@@ -529,7 +529,7 @@ static void wcn36xx_update_allowed_rates(struct ieee80211_sta *sta,
 
         size = ARRAY_SIZE(sta_priv->supported_rates.dsss_rates);
         rates_table = sta_priv->supported_rates.dsss_rates;
-        if (band == IEEE80211_BAND_2GHZ) {
+        if (band == NL80211_BAND_2GHZ) {
                 for (i = 0; i < size; i++) {
                         if (rates & 0x01) {
                                 rates_table[i] = wcn_2ghz_rates[i].hw_value;
@@ -958,8 +958,8 @@ static int wcn36xx_init_ieee80211(struct wcn36xx *wcn)
                 BIT(NL80211_IFTYPE_ADHOC) |
                 BIT(NL80211_IFTYPE_MESH_POINT);
 
-        wcn->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wcn_band_2ghz;
-        wcn->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wcn_band_5ghz;
+        wcn->hw->wiphy->bands[NL80211_BAND_2GHZ] = &wcn_band_2ghz;
+        wcn->hw->wiphy->bands[NL80211_BAND_5GHZ] = &wcn_band_5ghz;
 
         wcn->hw->wiphy->cipher_suites = cipher_suites;
         wcn->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
diff --git a/drivers/net/wireless/ath/wcn36xx/smd.c b/drivers/net/wireless/ath/wcn36xx/smd.c
index 74f56a81ad9a..96992a2c4b42 100644
--- a/drivers/net/wireless/ath/wcn36xx/smd.c
+++ b/drivers/net/wireless/ath/wcn36xx/smd.c
@@ -104,11 +104,11 @@ static void wcn36xx_smd_set_bss_nw_type(struct wcn36xx *wcn,
                 struct ieee80211_sta *sta,
                 struct wcn36xx_hal_config_bss_params *bss_params)
 {
-        if (IEEE80211_BAND_5GHZ == WCN36XX_BAND(wcn))
+        if (NL80211_BAND_5GHZ == WCN36XX_BAND(wcn))
                 bss_params->nw_type = WCN36XX_HAL_11A_NW_TYPE;
         else if (sta && sta->ht_cap.ht_supported)
                 bss_params->nw_type = WCN36XX_HAL_11N_NW_TYPE;
-        else if (sta && (sta->supp_rates[IEEE80211_BAND_2GHZ] & 0x7f))
+        else if (sta && (sta->supp_rates[NL80211_BAND_2GHZ] & 0x7f))
                 bss_params->nw_type = WCN36XX_HAL_11G_NW_TYPE;
         else
                 bss_params->nw_type = WCN36XX_HAL_11B_NW_TYPE;
diff --git a/drivers/net/wireless/ath/wcn36xx/txrx.c b/drivers/net/wireless/ath/wcn36xx/txrx.c
index 9bec8237231d..6c47a7336c38 100644
--- a/drivers/net/wireless/ath/wcn36xx/txrx.c
+++ b/drivers/net/wireless/ath/wcn36xx/txrx.c
@@ -57,7 +57,7 @@ int wcn36xx_rx_skb(struct wcn36xx *wcn, struct sk_buff *skb)
                        RX_FLAG_MMIC_STRIPPED |
                        RX_FLAG_DECRYPTED;
 
-        wcn36xx_dbg(WCN36XX_DBG_RX, "status.flags=%x\n", status.flag);
+        wcn36xx_dbg(WCN36XX_DBG_RX, "status.flags=%llx\n", status.flag);
 
         memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
 
@@ -225,7 +225,7 @@ static void wcn36xx_set_tx_mgmt(struct wcn36xx_tx_bd *bd,
 
         /* default rate for unicast */
         if (ieee80211_is_mgmt(hdr->frame_control))
-                bd->bd_rate = (WCN36XX_BAND(wcn) == IEEE80211_BAND_5GHZ) ?
+                bd->bd_rate = (WCN36XX_BAND(wcn) == NL80211_BAND_5GHZ) ?
                         WCN36XX_BD_RATE_CTRL :
                         WCN36XX_BD_RATE_MGMT;
         else if (ieee80211_is_ctl(hdr->frame_control))
diff --git a/drivers/net/wireless/ath/wil6210/Makefile b/drivers/net/wireless/ath/wil6210/Makefile
index fdf63d5fe82b..11b544b26c74 100644
--- a/drivers/net/wireless/ath/wil6210/Makefile
+++ b/drivers/net/wireless/ath/wil6210/Makefile
@@ -18,6 +18,7 @@ wil6210-$(CONFIG_WIL6210_TRACING) += trace.o
 wil6210-y += wil_platform.o
 wil6210-y += ethtool.o
 wil6210-y += wil_crash_dump.o
+wil6210-y += p2p.o
 
 # for tracing framework to find trace.h
 CFLAGS_trace.o := -I$(src)
diff --git a/drivers/net/wireless/ath/wil6210/cfg80211.c b/drivers/net/wireless/ath/wil6210/cfg80211.c
index 11f1bb8dfebe..0fb3a7941d84 100644
--- a/drivers/net/wireless/ath/wil6210/cfg80211.c
+++ b/drivers/net/wireless/ath/wil6210/cfg80211.c
@@ -18,8 +18,10 @@
 #include "wil6210.h"
 #include "wmi.h"
 
+#define WIL_MAX_ROC_DURATION_MS 5000
+
 #define CHAN60G(_channel, _flags) {                             \
-        .band                   = IEEE80211_BAND_60GHZ,         \
+        .band                   = NL80211_BAND_60GHZ,           \
         .center_freq            = 56160 + (2160 * (_channel)),  \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -76,12 +78,24 @@ wil_mgmt_stypes[NUM_NL80211_IFTYPES] = {
                 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
                 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
         },
+        [NL80211_IFTYPE_P2P_DEVICE] = {
+                .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
+                BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
+                .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
+                BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
+        },
 };
 
 static const u32 wil_cipher_suites[] = {
         WLAN_CIPHER_SUITE_GCMP,
 };
 
+static const char * const key_usage_str[] = {
+        [WMI_KEY_USE_PAIRWISE]  = "PTK",
+        [WMI_KEY_USE_RX_GROUP]  = "RX_GTK",
+        [WMI_KEY_USE_TX_GROUP]  = "TX_GTK",
+};
+
 int wil_iftype_nl2wmi(enum nl80211_iftype type)
 {
         static const struct {
@@ -113,7 +127,7 @@ int wil_cid_fill_sinfo(struct wil6210_priv *wil, int cid,
                 .interval_usec = 0,
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_notify_req_done_event evt;
         } __packed reply;
         struct wil_net_stats *stats = &wil->sta[cid].stats;
@@ -226,13 +240,82 @@ static int wil_cfg80211_dump_station(struct wiphy *wiphy,
         return rc;
 }
 
+static struct wireless_dev *
+wil_cfg80211_add_iface(struct wiphy *wiphy, const char *name,
+                       unsigned char name_assign_type,
+                       enum nl80211_iftype type,
+                       u32 *flags, struct vif_params *params)
+{
+        struct wil6210_priv *wil = wiphy_to_wil(wiphy);
+        struct net_device *ndev = wil_to_ndev(wil);
+        struct wireless_dev *p2p_wdev;
+
+        wil_dbg_misc(wil, "%s()\n", __func__);
+
+        if (type != NL80211_IFTYPE_P2P_DEVICE) {
+                wil_err(wil, "%s: unsupported iftype %d\n", __func__, type);
+                return ERR_PTR(-EINVAL);
+        }
+
+        if (wil->p2p_wdev) {
+                wil_err(wil, "%s: P2P_DEVICE interface already created\n",
+                        __func__);
+                return ERR_PTR(-EINVAL);
+        }
+
+        p2p_wdev = kzalloc(sizeof(*p2p_wdev), GFP_KERNEL);
+        if (!p2p_wdev)
+                return ERR_PTR(-ENOMEM);
+
+        p2p_wdev->iftype = type;
+        p2p_wdev->wiphy = wiphy;
+        /* use our primary ethernet address */
+        ether_addr_copy(p2p_wdev->address, ndev->perm_addr);
+
+        wil->p2p_wdev = p2p_wdev;
+
+        return p2p_wdev;
+}
+
+static int wil_cfg80211_del_iface(struct wiphy *wiphy,
+                                  struct wireless_dev *wdev)
+{
+        struct wil6210_priv *wil = wiphy_to_wil(wiphy);
+
+        wil_dbg_misc(wil, "%s()\n", __func__);
+
+        if (wdev != wil->p2p_wdev) {
+                wil_err(wil, "%s: delete of incorrect interface 0x%p\n",
+                        __func__, wdev);
+                return -EINVAL;
+        }
+
+        wil_p2p_wdev_free(wil);
+
+        return 0;
+}
+
 static int wil_cfg80211_change_iface(struct wiphy *wiphy,
                                      struct net_device *ndev,
                                      enum nl80211_iftype type, u32 *flags,
                                      struct vif_params *params)
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
-        struct wireless_dev *wdev = wil->wdev;
+        struct wireless_dev *wdev = wil_to_wdev(wil);
+        int rc;
+
+        wil_dbg_misc(wil, "%s() type=%d\n", __func__, type);
+
+        if (netif_running(wil_to_ndev(wil)) && !wil_is_recovery_blocked(wil)) {
+                wil_dbg_misc(wil, "interface is up. resetting...\n");
+                mutex_lock(&wil->mutex);
+                __wil_down(wil);
+                rc = __wil_up(wil);
+                mutex_unlock(&wil->mutex);
+
+                if (rc)
+                        return rc;
+        }
 
         switch (type) {
         case NL80211_IFTYPE_STATION:
@@ -260,7 +343,7 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
                              struct cfg80211_scan_request *request)
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
-        struct wireless_dev *wdev = wil->wdev;
+        struct wireless_dev *wdev = request->wdev;
         struct {
                 struct wmi_start_scan_cmd cmd;
                 u16 chnl[4];
@@ -268,6 +351,9 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
         uint i, n;
         int rc;
 
+        wil_dbg_misc(wil, "%s(), wdev=0x%p iftype=%d\n",
+                     __func__, wdev, wdev->iftype);
+
         if (wil->scan_request) {
                 wil_err(wil, "Already scanning\n");
                 return -EAGAIN;
@@ -277,6 +363,7 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
         switch (wdev->iftype) {
         case NL80211_IFTYPE_STATION:
         case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_P2P_DEVICE:
                 break;
         default:
                 return -EOPNOTSUPP;
@@ -288,6 +375,20 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
                 return -EBUSY;
         }
 
+        /* scan on P2P_DEVICE is handled as p2p search */
+        if (wdev->iftype == NL80211_IFTYPE_P2P_DEVICE) {
+                wil->scan_request = request;
+                wil->radio_wdev = wdev;
+                rc = wil_p2p_search(wil, request);
+                if (rc) {
+                        wil->radio_wdev = wil_to_wdev(wil);
+                        wil->scan_request = NULL;
+                }
+                return rc;
+        }
+
+        (void)wil_p2p_stop_discovery(wil);
+
         wil_dbg_misc(wil, "Start scan_request 0x%p\n", request);
         wil_dbg_misc(wil, "SSID count: %d", request->n_ssids);
 
@@ -313,6 +414,7 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
         mod_timer(&wil->scan_timer, jiffies + WIL6210_SCAN_TO);
 
         memset(&cmd, 0, sizeof(cmd));
+        cmd.cmd.scan_type = WMI_ACTIVE_SCAN;
         cmd.cmd.num_channels = 0;
         n = min(request->n_channels, 4U);
         for (i = 0; i < n; i++) {
@@ -340,12 +442,19 @@ static int wil_cfg80211_scan(struct wiphy *wiphy,
         if (rc)
                 goto out;
 
+        if (wil->discovery_mode && cmd.cmd.scan_type == WMI_ACTIVE_SCAN) {
+                cmd.cmd.discovery_mode = 1;
+                wil_dbg_misc(wil, "active scan with discovery_mode=1\n");
+        }
+
+        wil->radio_wdev = wdev;
         rc = wmi_send(wil, WMI_START_SCAN_CMDID, &cmd, sizeof(cmd.cmd) +
                         cmd.cmd.num_channels * sizeof(cmd.cmd.channel_list[0]));
 
 out:
         if (rc) {
                 del_timer_sync(&wil->scan_timer);
+                wil->radio_wdev = wil_to_wdev(wil);
                 wil->scan_request = NULL;
         }
 
@@ -390,6 +499,7 @@ static void wil_print_connect_params(struct wil6210_priv *wil,
                 print_hex_dump(KERN_INFO, "  SSID: ", DUMP_PREFIX_OFFSET,
                                16, 1, sme->ssid, sme->ssid_len, true);
         wil_info(wil, "  Privacy: %s\n", sme->privacy ? "secure" : "open");
+        wil_info(wil, "  PBSS: %d\n", sme->pbss);
         wil_print_crypto(wil, &sme->crypto);
 }
 
@@ -404,7 +514,9 @@ static int wil_cfg80211_connect(struct wiphy *wiphy,
         const u8 *rsn_eid;
         int ch;
         int rc = 0;
+        enum ieee80211_bss_type bss_type = IEEE80211_BSS_TYPE_ESS;
 
+        wil_dbg_misc(wil, "%s()\n", __func__);
         wil_print_connect_params(wil, sme);
 
         if (test_bit(wil_status_fwconnecting, wil->status) ||
@@ -422,14 +534,12 @@ static int wil_cfg80211_connect(struct wiphy *wiphy,
         if (sme->privacy && !rsn_eid)
                 wil_info(wil, "WSC connection\n");
 
-        if (sme->pbss) {
-                wil_err(wil, "connect - PBSS not yet supported\n");
-                return -EOPNOTSUPP;
-        }
+        if (sme->pbss)
+                bss_type = IEEE80211_BSS_TYPE_PBSS;
 
         bss = cfg80211_get_bss(wiphy, sme->channel, sme->bssid,
                                sme->ssid, sme->ssid_len,
-                               IEEE80211_BSS_TYPE_ESS, IEEE80211_PRIVACY_ANY);
+                               bss_type, IEEE80211_PRIVACY_ANY);
         if (!bss) {
                 wil_err(wil, "Unable to find BSS\n");
                 return -ENOENT;
@@ -568,10 +678,20 @@ int wil_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
         struct ieee80211_mgmt *mgmt_frame = (void *)buf;
         struct wmi_sw_tx_req_cmd *cmd;
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_sw_tx_complete_event evt;
         } __packed evt;
 
+        /* Note, currently we do not support the "wait" parameter, user-space
+         * must call remain_on_channel before mgmt_tx or listen on a channel
+         * another way (AP/PCP or connected station)
+         * in addition we need to check if specified "chan" argument is
+         * different from currently "listened" channel and fail if it is.
+         */
+
+        wil_dbg_misc(wil, "%s()\n", __func__);
+        print_hex_dump_bytes("mgmt tx frame ", DUMP_PREFIX_OFFSET, buf, len);
+
         cmd = kmalloc(sizeof(*cmd) + len, GFP_KERNEL);
         if (!cmd) {
                 rc = -ENOMEM;
@@ -598,7 +718,7 @@ static int wil_cfg80211_set_channel(struct wiphy *wiphy,
                                     struct cfg80211_chan_def *chandef)
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
-        struct wireless_dev *wdev = wil->wdev;
+        struct wireless_dev *wdev = wil_to_wdev(wil);
 
         wdev->preset_chandef = *chandef;
 
@@ -608,22 +728,19 @@ static int wil_cfg80211_set_channel(struct wiphy *wiphy,
 static enum wmi_key_usage wil_detect_key_usage(struct wil6210_priv *wil,
                                                bool pairwise)
 {
-        struct wireless_dev *wdev = wil->wdev;
+        struct wireless_dev *wdev = wil_to_wdev(wil);
         enum wmi_key_usage rc;
-        static const char * const key_usage_str[] = {
-                [WMI_KEY_USE_PAIRWISE]  = "WMI_KEY_USE_PAIRWISE",
-                [WMI_KEY_USE_RX_GROUP]  = "WMI_KEY_USE_RX_GROUP",
-                [WMI_KEY_USE_TX_GROUP]  = "WMI_KEY_USE_TX_GROUP",
-        };
 
         if (pairwise) {
                 rc = WMI_KEY_USE_PAIRWISE;
         } else {
                 switch (wdev->iftype) {
                 case NL80211_IFTYPE_STATION:
+                case NL80211_IFTYPE_P2P_CLIENT:
                         rc = WMI_KEY_USE_RX_GROUP;
                         break;
                 case NL80211_IFTYPE_AP:
+                case NL80211_IFTYPE_P2P_GO:
                         rc = WMI_KEY_USE_TX_GROUP;
                         break;
                 default:
@@ -638,20 +755,86 @@ static enum wmi_key_usage wil_detect_key_usage(struct wil6210_priv *wil,
         return rc;
 }
 
+static struct wil_tid_crypto_rx_single *
+wil_find_crypto_ctx(struct wil6210_priv *wil, u8 key_index,
+                    enum wmi_key_usage key_usage, const u8 *mac_addr)
+{
+        int cid = -EINVAL;
+        int tid = 0;
+        struct wil_sta_info *s;
+        struct wil_tid_crypto_rx *c;
+
+        if (key_usage == WMI_KEY_USE_TX_GROUP)
+                return NULL; /* not needed */
+
+        /* supplicant provides Rx group key in STA mode with NULL MAC address */
+        if (mac_addr)
+                cid = wil_find_cid(wil, mac_addr);
+        else if (key_usage == WMI_KEY_USE_RX_GROUP)
+                cid = wil_find_cid_by_idx(wil, 0);
+        if (cid < 0) {
+                wil_err(wil, "No CID for %pM %s[%d]\n", mac_addr,
+                        key_usage_str[key_usage], key_index);
+                return ERR_PTR(cid);
+        }
+
+        s = &wil->sta[cid];
+        if (key_usage == WMI_KEY_USE_PAIRWISE)
+                c = &s->tid_crypto_rx[tid];
+        else
+                c = &s->group_crypto_rx;
+
+        return &c->key_id[key_index];
+}
+
 static int wil_cfg80211_add_key(struct wiphy *wiphy,
                                 struct net_device *ndev,
                                 u8 key_index, bool pairwise,
                                 const u8 *mac_addr,
                                 struct key_params *params)
 {
+        int rc;
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
         enum wmi_key_usage key_usage = wil_detect_key_usage(wil, pairwise);
+        struct wil_tid_crypto_rx_single *cc = wil_find_crypto_ctx(wil,
+                                                                  key_index,
+                                                                  key_usage,
+                                                                  mac_addr);
+
+        wil_dbg_misc(wil, "%s(%pM %s[%d] PN %*phN)\n", __func__,
+                     mac_addr, key_usage_str[key_usage], key_index,
+                     params->seq_len, params->seq);
+
+        if (IS_ERR(cc)) {
+                wil_err(wil, "Not connected, %s(%pM %s[%d] PN %*phN)\n",
+                        __func__, mac_addr, key_usage_str[key_usage], key_index,
+                        params->seq_len, params->seq);
+                return -EINVAL;
+        }
 
-        wil_dbg_misc(wil, "%s(%pM[%d] %s)\n", __func__, mac_addr, key_index,
-                     pairwise ? "PTK" : "GTK");
+        if (cc)
+                cc->key_set = false;
+
+        if (params->seq && params->seq_len != IEEE80211_GCMP_PN_LEN) {
+                wil_err(wil,
+                        "Wrong PN len %d, %s(%pM %s[%d] PN %*phN)\n",
+                        params->seq_len, __func__, mac_addr,
+                        key_usage_str[key_usage], key_index,
+                        params->seq_len, params->seq);
+                return -EINVAL;
+        }
+
+        rc = wmi_add_cipher_key(wil, key_index, mac_addr, params->key_len,
+                                params->key, key_usage);
+        if ((rc == 0) && cc) {
+                if (params->seq)
+                        memcpy(cc->pn, params->seq, IEEE80211_GCMP_PN_LEN);
+                else
+                        memset(cc->pn, 0, IEEE80211_GCMP_PN_LEN);
+                cc->key_set = true;
+        }
 
-        return wmi_add_cipher_key(wil, key_index, mac_addr, params->key_len,
-                                  params->key, key_usage);
+        return rc;
 }
 
 static int wil_cfg80211_del_key(struct wiphy *wiphy,
@@ -661,9 +844,20 @@ static int wil_cfg80211_del_key(struct wiphy *wiphy,
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
         enum wmi_key_usage key_usage = wil_detect_key_usage(wil, pairwise);
+        struct wil_tid_crypto_rx_single *cc = wil_find_crypto_ctx(wil,
+                                                                  key_index,
+                                                                  key_usage,
+                                                                  mac_addr);
+
+        wil_dbg_misc(wil, "%s(%pM %s[%d])\n", __func__, mac_addr,
+                     key_usage_str[key_usage], key_index);
+
+        if (IS_ERR(cc))
+                wil_info(wil, "Not connected, %s(%pM %s[%d])\n", __func__,
+                         mac_addr, key_usage_str[key_usage], key_index);
 
-        wil_dbg_misc(wil, "%s(%pM[%d] %s)\n", __func__, mac_addr, key_index,
-                     pairwise ? "PTK" : "GTK");
+        if (!IS_ERR_OR_NULL(cc))
+                cc->key_set = false;
 
         return wmi_del_cipher_key(wil, key_index, mac_addr, key_usage);
 }
@@ -674,6 +868,9 @@ static int wil_cfg80211_set_default_key(struct wiphy *wiphy,
                                         u8 key_index, bool unicast,
                                         bool multicast)
 {
+        struct wil6210_priv *wil = wiphy_to_wil(wiphy);
+
+        wil_dbg_misc(wil, "%s: entered\n", __func__);
         return 0;
 }
 
@@ -686,16 +883,19 @@ static int wil_remain_on_channel(struct wiphy *wiphy,
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
         int rc;
 
-        /* TODO: handle duration */
-        wil_info(wil, "%s(%d, %d ms)\n", __func__, chan->center_freq, duration);
+        wil_dbg_misc(wil, "%s() center_freq=%d, duration=%d iftype=%d\n",
+                     __func__, chan->center_freq, duration, wdev->iftype);
 
-        rc = wmi_set_channel(wil, chan->hw_value);
+        rc = wil_p2p_listen(wil, duration, chan, cookie);
         if (rc)
                 return rc;
 
-        rc = wmi_rxon(wil, true);
+        wil->radio_wdev = wdev;
 
-        return rc;
+        cfg80211_ready_on_channel(wdev, *cookie, chan, duration,
+                                  GFP_KERNEL);
+
+        return 0;
 }
 
 static int wil_cancel_remain_on_channel(struct wiphy *wiphy,
@@ -703,13 +903,10 @@ static int wil_cancel_remain_on_channel(struct wiphy *wiphy,
                                         u64 cookie)
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
-        int rc;
-
-        wil_info(wil, "%s()\n", __func__);
 
-        rc = wmi_rxon(wil, false);
+        wil_dbg_misc(wil, "%s()\n", __func__);
 
-        return rc;
+        return wil_p2p_cancel_listen(wil, cookie);
 }
 
 /**
@@ -852,12 +1049,22 @@ static int _wil_cfg80211_start_ap(struct wiphy *wiphy,
                                   const u8 *ssid, size_t ssid_len, u32 privacy,
                                   int bi, u8 chan,
                                   struct cfg80211_beacon_data *bcon,
-                                  u8 hidden_ssid)
+                                  u8 hidden_ssid, u32 pbss)
 {
         struct wil6210_priv *wil = wiphy_to_wil(wiphy);
         int rc;
         struct wireless_dev *wdev = ndev->ieee80211_ptr;
         u8 wmi_nettype = wil_iftype_nl2wmi(wdev->iftype);
+        u8 is_go = (wdev->iftype == NL80211_IFTYPE_P2P_GO);
+
+        if (pbss)
+                wmi_nettype = WMI_NETTYPE_P2P;
+
+        wil_dbg_misc(wil, "%s: is_go=%d\n", __func__, is_go);
+        if (is_go && !pbss) {
+                wil_err(wil, "%s: P2P GO must be in PBSS\n", __func__);
+                return -ENOTSUPP;
+        }
 
         wil_set_recovery_state(wil, fw_recovery_idle);
 
@@ -879,10 +1086,11 @@ static int _wil_cfg80211_start_ap(struct wiphy *wiphy,
         wil->privacy = privacy;
         wil->channel = chan;
         wil->hidden_ssid = hidden_ssid;
+        wil->pbss = pbss;
 
         netif_carrier_on(ndev);
 
-        rc = wmi_pcp_start(wil, bi, wmi_nettype, chan, hidden_ssid);
+        rc = wmi_pcp_start(wil, bi, wmi_nettype, chan, hidden_ssid, is_go);
         if (rc)
                 goto err_pcp_start;
 
@@ -928,7 +1136,8 @@ static int wil_cfg80211_change_beacon(struct wiphy *wiphy,
                                             wdev->ssid_len, privacy,
                                             wdev->beacon_interval,
                                             wil->channel, bcon,
-                                            wil->hidden_ssid);
+                                            wil->hidden_ssid,
+                                            wil->pbss);
         } else {
                 rc = _wil_cfg80211_set_ies(wiphy, bcon);
         }
@@ -954,11 +1163,6 @@ static int wil_cfg80211_start_ap(struct wiphy *wiphy,
                 return -EINVAL;
         }
 
-        if (info->pbss) {
-                wil_err(wil, "AP: PBSS not yet supported\n");
-                return -EOPNOTSUPP;
-        }
-
         switch (info->hidden_ssid) {
         case NL80211_HIDDEN_SSID_NOT_IN_USE:
                 hidden_ssid = WMI_HIDDEN_SSID_DISABLED;
@@ -984,6 +1188,7 @@ static int wil_cfg80211_start_ap(struct wiphy *wiphy,
                      info->hidden_ssid);
         wil_dbg_misc(wil, "BI %d DTIM %d\n", info->beacon_interval,
                      info->dtim_period);
+        wil_dbg_misc(wil, "PBSS %d\n", info->pbss);
         print_hex_dump_bytes("SSID ", DUMP_PREFIX_OFFSET,
                              info->ssid, info->ssid_len);
         wil_print_bcon_data(bcon);
@@ -992,7 +1197,7 @@ static int wil_cfg80211_start_ap(struct wiphy *wiphy,
         rc = _wil_cfg80211_start_ap(wiphy, ndev,
                                     info->ssid, info->ssid_len, info->privacy,
                                     info->beacon_interval, channel->hw_value,
-                                    bcon, hidden_ssid);
+                                    bcon, hidden_ssid, info->pbss);
 
         return rc;
 }
@@ -1139,7 +1344,26 @@ static int wil_cfg80211_change_bss(struct wiphy *wiphy,
         return 0;
 }
 
+static int wil_cfg80211_start_p2p_device(struct wiphy *wiphy,
+                                         struct wireless_dev *wdev)
+{
+        struct wil6210_priv *wil = wiphy_to_wil(wiphy);
+
+        wil_dbg_misc(wil, "%s: entered\n", __func__);
+        return 0;
+}
+
+static void wil_cfg80211_stop_p2p_device(struct wiphy *wiphy,
+                                         struct wireless_dev *wdev)
+{
+        struct wil6210_priv *wil = wiphy_to_wil(wiphy);
+
+        wil_dbg_misc(wil, "%s: entered\n", __func__);
+}
+
 static struct cfg80211_ops wil_cfg80211_ops = {
+        .add_virtual_intf = wil_cfg80211_add_iface,
+        .del_virtual_intf = wil_cfg80211_del_iface,
         .scan = wil_cfg80211_scan,
         .connect = wil_cfg80211_connect,
         .disconnect = wil_cfg80211_disconnect,
@@ -1160,20 +1384,25 @@ static struct cfg80211_ops wil_cfg80211_ops = {
         .del_station = wil_cfg80211_del_station,
         .probe_client = wil_cfg80211_probe_client,
         .change_bss = wil_cfg80211_change_bss,
+        /* P2P device */
+        .start_p2p_device = wil_cfg80211_start_p2p_device,
+        .stop_p2p_device = wil_cfg80211_stop_p2p_device,
 };
 
 static void wil_wiphy_init(struct wiphy *wiphy)
 {
         wiphy->max_scan_ssids = 1;
         wiphy->max_scan_ie_len = WMI_MAX_IE_LEN;
+        wiphy->max_remain_on_channel_duration = WIL_MAX_ROC_DURATION_MS;
         wiphy->max_num_pmkids = 0 /* TODO: */;
         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
                                  BIT(NL80211_IFTYPE_AP) |
+                                 BIT(NL80211_IFTYPE_P2P_CLIENT) |
+                                 BIT(NL80211_IFTYPE_P2P_GO) |
+                                 BIT(NL80211_IFTYPE_P2P_DEVICE) |
                                  BIT(NL80211_IFTYPE_MONITOR);
-        /* TODO: enable P2P when integrated with supplicant:
-         * BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO)
-         */
         wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
+                        WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
                         WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
         dev_dbg(wiphy_dev(wiphy), "%s : flags = 0x%08x\n",
                 __func__, wiphy->flags);
@@ -1182,7 +1411,7 @@ static void wil_wiphy_init(struct wiphy *wiphy)
                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
 
-        wiphy->bands[IEEE80211_BAND_60GHZ] = &wil_band_60ghz;
+        wiphy->bands[NL80211_BAND_60GHZ] = &wil_band_60ghz;
 
         /* TODO: figure this out */
         wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
@@ -1241,3 +1470,18 @@ void wil_wdev_free(struct wil6210_priv *wil)
         wiphy_free(wdev->wiphy);
         kfree(wdev);
 }
+
+void wil_p2p_wdev_free(struct wil6210_priv *wil)
+{
+        struct wireless_dev *p2p_wdev;
+
+        mutex_lock(&wil->p2p_wdev_mutex);
+        p2p_wdev = wil->p2p_wdev;
+        if (p2p_wdev) {
+                wil->p2p_wdev = NULL;
+                wil->radio_wdev = wil_to_wdev(wil);
+                cfg80211_unregister_wdev(p2p_wdev);
+                kfree(p2p_wdev);
+        }
+        mutex_unlock(&wil->p2p_wdev_mutex);
+}
diff --git a/drivers/net/wireless/ath/wil6210/debugfs.c b/drivers/net/wireless/ath/wil6210/debugfs.c
index 3bbe73b6d05a..b338a09175ad 100644
--- a/drivers/net/wireless/ath/wil6210/debugfs.c
+++ b/drivers/net/wireless/ath/wil6210/debugfs.c
@@ -37,6 +37,7 @@ enum dbg_off_type {
         doff_x32 = 1,
         doff_ulong = 2,
         doff_io32 = 3,
+        doff_u8 = 4
 };
 
 /* offset to "wil" */
@@ -346,6 +347,10 @@ static void wil6210_debugfs_init_offset(struct wil6210_priv *wil,
                                                          tbl[i].mode, dbg,
                                                          base + tbl[i].off);
                         break;
+                case doff_u8:
+                        f = debugfs_create_u8(tbl[i].name, tbl[i].mode, dbg,
+                                              base + tbl[i].off);
+                        break;
                 default:
                         f = ERR_PTR(-EINVAL);
                 }
@@ -821,13 +826,13 @@ static ssize_t wil_write_file_wmi(struct file *file, const char __user *buf,
                                   size_t len, loff_t *ppos)
 {
         struct wil6210_priv *wil = file->private_data;
-        struct wil6210_mbox_hdr_wmi *wmi;
+        struct wmi_cmd_hdr *wmi;
         void *cmd;
-        int cmdlen = len - sizeof(struct wil6210_mbox_hdr_wmi);
+        int cmdlen = len - sizeof(struct wmi_cmd_hdr);
         u16 cmdid;
         int rc, rc1;
 
-        if (cmdlen <= 0)
+        if (cmdlen < 0)
                 return -EINVAL;
 
         wmi = kmalloc(len, GFP_KERNEL);
@@ -840,8 +845,8 @@ static ssize_t wil_write_file_wmi(struct file *file, const char __user *buf,
                 return rc;
         }
 
-        cmd = &wmi[1];
-        cmdid = le16_to_cpu(wmi->id);
+        cmd = (cmdlen > 0) ? &wmi[1] : NULL;
+        cmdid = le16_to_cpu(wmi->command_id);
 
         rc1 = wmi_send(wil, cmdid, cmd, cmdlen);
         kfree(wmi);
@@ -985,7 +990,7 @@ static int wil_bf_debugfs_show(struct seq_file *s, void *data)
                 .interval_usec = 0,
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_notify_req_done_event evt;
         } __packed reply;
 
@@ -1333,6 +1338,34 @@ static void wil_print_rxtid(struct seq_file *s, struct wil_tid_ampdu_rx *r)
                    r->ssn_last_drop);
 }
 
+static void wil_print_rxtid_crypto(struct seq_file *s, int tid,
+                                   struct wil_tid_crypto_rx *c)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                struct wil_tid_crypto_rx_single *cc = &c->key_id[i];
+
+                if (cc->key_set)
+                        goto has_keys;
+        }
+        return;
+
+has_keys:
+        if (tid < WIL_STA_TID_NUM)
+                seq_printf(s, "  [%2d] PN", tid);
+        else
+                seq_puts(s, "  [GR] PN");
+
+        for (i = 0; i < 4; i++) {
+                struct wil_tid_crypto_rx_single *cc = &c->key_id[i];
+
+                seq_printf(s, " [%i%s]%6phN", i, cc->key_set ? "+" : "-",
+                           cc->pn);
+        }
+        seq_puts(s, "\n");
+}
+
 static int wil_sta_debugfs_show(struct seq_file *s, void *data)
 __acquires(&p->tid_rx_lock) __releases(&p->tid_rx_lock)
 {
@@ -1360,18 +1393,25 @@ __acquires(&p->tid_rx_lock) __releases(&p->tid_rx_lock)
                         spin_lock_bh(&p->tid_rx_lock);
                         for (tid = 0; tid < WIL_STA_TID_NUM; tid++) {
                                 struct wil_tid_ampdu_rx *r = p->tid_rx[tid];
+                                struct wil_tid_crypto_rx *c =
+                                                &p->tid_crypto_rx[tid];
 
                                 if (r) {
-                                        seq_printf(s, "[%2d] ", tid);
+                                        seq_printf(s, "  [%2d] ", tid);
                                         wil_print_rxtid(s, r);
                                 }
+
+                                wil_print_rxtid_crypto(s, tid, c);
                         }
+                        wil_print_rxtid_crypto(s, WIL_STA_TID_NUM,
+                                               &p->group_crypto_rx);
                         spin_unlock_bh(&p->tid_rx_lock);
                         seq_printf(s,
-                                   "Rx invalid frame: non-data %lu, short %lu, large %lu\n",
+                                   "Rx invalid frame: non-data %lu, short %lu, large %lu, replay %lu\n",
                                    p->stats.rx_non_data_frame,
                                    p->stats.rx_short_frame,
-                                   p->stats.rx_large_frame);
+                                   p->stats.rx_large_frame,
+                                   p->stats.rx_replay);
 
                         seq_puts(s, "Rx/MCS:");
                         for (mcs = 0; mcs < ARRAY_SIZE(p->stats.rx_per_mcs);
@@ -1487,6 +1527,7 @@ static const struct dbg_off dbg_wil_off[] = {
         WIL_FIELD(hw_version,   S_IRUGO,                doff_x32),
         WIL_FIELD(recovery_count, S_IRUGO,              doff_u32),
         WIL_FIELD(ap_isolate,   S_IRUGO,                doff_u32),
+        WIL_FIELD(discovery_mode, S_IRUGO | S_IWUSR,    doff_u8),
         {},
 };
 
diff --git a/drivers/net/wireless/ath/wil6210/interrupt.c b/drivers/net/wireless/ath/wil6210/interrupt.c
index 4f2ffa5c6e17..fe66b2b646f0 100644
--- a/drivers/net/wireless/ath/wil6210/interrupt.c
+++ b/drivers/net/wireless/ath/wil6210/interrupt.c
@@ -391,12 +391,14 @@ static irqreturn_t wil6210_irq_misc_thread(int irq, void *cookie)
         wil_dbg_irq(wil, "Thread ISR MISC 0x%08x\n", isr);
 
         if (isr & ISR_MISC_FW_ERROR) {
+                wil->recovery_state = fw_recovery_pending;
                 wil_fw_core_dump(wil);
                 wil_notify_fw_error(wil);
                 isr &= ~ISR_MISC_FW_ERROR;
-                if (wil->platform_ops.notify_crash) {
+                if (wil->platform_ops.notify) {
                         wil_err(wil, "notify platform driver about FW crash");
-                        wil->platform_ops.notify_crash(wil->platform_handle);
+                        wil->platform_ops.notify(wil->platform_handle,
+                                                 WIL_PLATFORM_EVT_FW_CRASH);
                 } else {
                         wil_fw_error_recovery(wil);
                 }
diff --git a/drivers/net/wireless/ath/wil6210/ioctl.c b/drivers/net/wireless/ath/wil6210/ioctl.c
index f7f948621951..630380078236 100644
--- a/drivers/net/wireless/ath/wil6210/ioctl.c
+++ b/drivers/net/wireless/ath/wil6210/ioctl.c
@@ -161,13 +161,20 @@ out_free:
 
 int wil_ioctl(struct wil6210_priv *wil, void __user *data, int cmd)
 {
+        int ret;
+
         switch (cmd) {
         case WIL_IOCTL_MEMIO:
-                return wil_ioc_memio_dword(wil, data);
+                ret = wil_ioc_memio_dword(wil, data);
+                break;
         case WIL_IOCTL_MEMIO_BLOCK:
-                return wil_ioc_memio_block(wil, data);
+                ret = wil_ioc_memio_block(wil, data);
+                break;
         default:
                 wil_dbg_ioctl(wil, "Unsupported IOCTL 0x%04x\n", cmd);
                 return -ENOIOCTLCMD;
         }
+
+        wil_dbg_ioctl(wil, "ioctl(0x%04x) -> %d\n", cmd, ret);
+        return ret;
 }
diff --git a/drivers/net/wireless/ath/wil6210/main.c b/drivers/net/wireless/ath/wil6210/main.c
index 78ba6e04c944..8d4e8843004e 100644
--- a/drivers/net/wireless/ath/wil6210/main.c
+++ b/drivers/net/wireless/ath/wil6210/main.c
@@ -27,6 +27,11 @@ bool debug_fw; /* = false; */
 module_param(debug_fw, bool, S_IRUGO);
 MODULE_PARM_DESC(debug_fw, " do not perform card reset. For FW debug");
 
+static bool oob_mode;
+module_param(oob_mode, bool, S_IRUGO);
+MODULE_PARM_DESC(oob_mode,
+                 " enable out of the box (OOB) mode in FW, for diagnostics and certification");
+
 bool no_fw_recovery;
 module_param(no_fw_recovery, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(no_fw_recovery, " disable automatic FW error recovery");
@@ -149,7 +154,7 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
         might_sleep();
         wil_dbg_misc(wil, "%s(CID %d, status %d)\n", __func__, cid,
                      sta->status);
-
+        /* inform upper/lower layers */
         if (sta->status != wil_sta_unused) {
                 if (!from_event)
                         wmi_disconnect_sta(wil, sta->addr, reason_code, true);
@@ -165,7 +170,7 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
                 }
                 sta->status = wil_sta_unused;
         }
-
+        /* reorder buffers */
         for (i = 0; i < WIL_STA_TID_NUM; i++) {
                 struct wil_tid_ampdu_rx *r;
 
@@ -177,10 +182,15 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
 
                 spin_unlock_bh(&sta->tid_rx_lock);
         }
+        /* crypto context */
+        memset(sta->tid_crypto_rx, 0, sizeof(sta->tid_crypto_rx));
+        memset(&sta->group_crypto_rx, 0, sizeof(sta->group_crypto_rx));
+        /* release vrings */
         for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) {
                 if (wil->vring2cid_tid[i][0] == cid)
                         wil_vring_fini_tx(wil, i);
         }
+        /* statistics */
         memset(&sta->stats, 0, sizeof(sta->stats));
 }
 
@@ -300,6 +310,11 @@ void wil_set_recovery_state(struct wil6210_priv *wil, int state)
         wake_up_interruptible(&wil->wq);
 }
 
+bool wil_is_recovery_blocked(struct wil6210_priv *wil)
+{
+        return no_fw_recovery && (wil->recovery_state == fw_recovery_pending);
+}
+
 static void wil_fw_error_worker(struct work_struct *work)
 {
         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
@@ -440,9 +455,8 @@ int wil_priv_init(struct wil6210_priv *wil)
 
         mutex_init(&wil->mutex);
         mutex_init(&wil->wmi_mutex);
-        mutex_init(&wil->back_rx_mutex);
-        mutex_init(&wil->back_tx_mutex);
         mutex_init(&wil->probe_client_mutex);
+        mutex_init(&wil->p2p_wdev_mutex);
 
         init_completion(&wil->wmi_ready);
         init_completion(&wil->wmi_call);
@@ -450,17 +464,15 @@ int wil_priv_init(struct wil6210_priv *wil)
         wil->bcast_vring = -1;
         setup_timer(&wil->connect_timer, wil_connect_timer_fn, (ulong)wil);
         setup_timer(&wil->scan_timer, wil_scan_timer_fn, (ulong)wil);
+        setup_timer(&wil->p2p.discovery_timer, wil_p2p_discovery_timer_fn,
+                    (ulong)wil);
 
         INIT_WORK(&wil->disconnect_worker, wil_disconnect_worker);
         INIT_WORK(&wil->wmi_event_worker, wmi_event_worker);
         INIT_WORK(&wil->fw_error_worker, wil_fw_error_worker);
-        INIT_WORK(&wil->back_rx_worker, wil_back_rx_worker);
-        INIT_WORK(&wil->back_tx_worker, wil_back_tx_worker);
         INIT_WORK(&wil->probe_client_worker, wil_probe_client_worker);
 
         INIT_LIST_HEAD(&wil->pending_wmi_ev);
-        INIT_LIST_HEAD(&wil->back_rx_pending);
-        INIT_LIST_HEAD(&wil->back_tx_pending);
         INIT_LIST_HEAD(&wil->probe_client_pending);
         spin_lock_init(&wil->wmi_ev_lock);
         init_waitqueue_head(&wil->wq);
@@ -514,16 +526,14 @@ void wil_priv_deinit(struct wil6210_priv *wil)
 
         wil_set_recovery_state(wil, fw_recovery_idle);
         del_timer_sync(&wil->scan_timer);
+        del_timer_sync(&wil->p2p.discovery_timer);
         cancel_work_sync(&wil->disconnect_worker);
         cancel_work_sync(&wil->fw_error_worker);
+        cancel_work_sync(&wil->p2p.discovery_expired_work);
         mutex_lock(&wil->mutex);
         wil6210_disconnect(wil, NULL, WLAN_REASON_DEAUTH_LEAVING, false);
         mutex_unlock(&wil->mutex);
         wmi_event_flush(wil);
-        wil_back_rx_flush(wil);
-        cancel_work_sync(&wil->back_rx_worker);
-        wil_back_tx_flush(wil);
-        cancel_work_sync(&wil->back_tx_worker);
         wil_probe_client_flush(wil);
         cancel_work_sync(&wil->probe_client_worker);
         destroy_workqueue(wil->wq_service);
@@ -542,6 +552,16 @@ static inline void wil_release_cpu(struct wil6210_priv *wil)
         wil_w(wil, RGF_USER_USER_CPU_0, 1);
 }
 
+static void wil_set_oob_mode(struct wil6210_priv *wil, bool enable)
+{
+        wil_info(wil, "%s: enable=%d\n", __func__, enable);
+        if (enable) {
+                wil_s(wil, RGF_USER_USAGE_6, BIT_USER_OOB_MODE);
+        } else {
+                wil_c(wil, RGF_USER_USAGE_6, BIT_USER_OOB_MODE);
+        }
+}
+
 static int wil_target_reset(struct wil6210_priv *wil)
 {
         int delay = 0;
@@ -637,6 +657,7 @@ void wil_mbox_ring_le2cpus(struct wil6210_mbox_ring *r)
 static int wil_get_bl_info(struct wil6210_priv *wil)
 {
         struct net_device *ndev = wil_to_ndev(wil);
+        struct wiphy *wiphy = wil_to_wiphy(wil);
         union {
                 struct bl_dedicated_registers_v0 bl0;
                 struct bl_dedicated_registers_v1 bl1;
@@ -681,6 +702,7 @@ static int wil_get_bl_info(struct wil6210_priv *wil)
         }
 
         ether_addr_copy(ndev->perm_addr, mac);
+        ether_addr_copy(wiphy->perm_addr, mac);
         if (!is_valid_ether_addr(ndev->dev_addr))
                 ether_addr_copy(ndev->dev_addr, mac);
 
@@ -767,6 +789,15 @@ int wil_reset(struct wil6210_priv *wil, bool load_fw)
         if (wil->hw_version == HW_VER_UNKNOWN)
                 return -ENODEV;
 
+        if (wil->platform_ops.notify) {
+                rc = wil->platform_ops.notify(wil->platform_handle,
+                                              WIL_PLATFORM_EVT_PRE_RESET);
+                if (rc)
+                        wil_err(wil,
+                                "%s: PRE_RESET platform notify failed, rc %d\n",
+                                __func__, rc);
+        }
+
         set_bit(wil_status_resetting, wil->status);
 
         cancel_work_sync(&wil->disconnect_worker);
@@ -807,6 +838,7 @@ int wil_reset(struct wil6210_priv *wil, bool load_fw)
         if (rc)
                 return rc;
 
+        wil_set_oob_mode(wil, oob_mode);
         if (load_fw) {
                 wil_info(wil, "Use firmware <%s> + board <%s>\n", WIL_FW_NAME,
                          WIL_FW2_NAME);
@@ -846,8 +878,27 @@ int wil_reset(struct wil6210_priv *wil, bool load_fw)
 
                 /* we just started MAC, wait for FW ready */
                 rc = wil_wait_for_fw_ready(wil);
-                if (rc == 0) /* check FW is responsive */
-                        rc = wmi_echo(wil);
+                if (rc)
+                        return rc;
+
+                /* check FW is responsive */
+                rc = wmi_echo(wil);
+                if (rc) {
+                        wil_err(wil, "%s: wmi_echo failed, rc %d\n",
+                                __func__, rc);
+                        return rc;
+                }
+
+                if (wil->platform_ops.notify) {
+                        rc = wil->platform_ops.notify(wil->platform_handle,
+                                                      WIL_PLATFORM_EVT_FW_RDY);
+                        if (rc) {
+                                wil_err(wil,
+                                        "%s: FW_RDY notify failed, rc %d\n",
+                                        __func__, rc);
+                                rc = 0;
+                        }
+                }
         }
 
         return rc;
@@ -954,6 +1005,8 @@ int __wil_down(struct wil6210_priv *wil)
         }
         wil_enable_irq(wil);
 
+        (void)wil_p2p_stop_discovery(wil);
+
         if (wil->scan_request) {
                 wil_dbg_misc(wil, "Abort scan_request 0x%p\n",
                              wil->scan_request);
diff --git a/drivers/net/wireless/ath/wil6210/netdev.c b/drivers/net/wireless/ath/wil6210/netdev.c
index ecc3c1bdae4b..098409753d5b 100644
--- a/drivers/net/wireless/ath/wil6210/netdev.c
+++ b/drivers/net/wireless/ath/wil6210/netdev.c
@@ -60,11 +60,7 @@ static int wil_do_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
 {
         struct wil6210_priv *wil = ndev_to_wil(ndev);
 
-        int ret = wil_ioctl(wil, ifr->ifr_data, cmd);
-
-        wil_dbg_misc(wil, "ioctl(0x%04x) -> %d\n", cmd, ret);
-
-        return ret;
+        return wil_ioctl(wil, ifr->ifr_data, cmd);
 }
 
 static const struct net_device_ops wil_netdev_ops = {
@@ -149,6 +145,7 @@ void *wil_if_alloc(struct device *dev)
 
         wil = wdev_to_wil(wdev);
         wil->wdev = wdev;
+        wil->radio_wdev = wdev;
 
         wil_dbg_misc(wil, "%s()\n", __func__);
 
@@ -160,7 +157,7 @@ void *wil_if_alloc(struct device *dev)
 
         wdev->iftype = NL80211_IFTYPE_STATION; /* TODO */
         /* default monitor channel */
-        ch = wdev->wiphy->bands[IEEE80211_BAND_60GHZ]->channels;
+        ch = wdev->wiphy->bands[NL80211_BAND_60GHZ]->channels;
         cfg80211_chandef_create(&wdev->preset_chandef, ch, NL80211_CHAN_NO_HT);
 
         ndev = alloc_netdev(0, "wlan%d", NET_NAME_UNKNOWN, wil_dev_setup);
diff --git a/drivers/net/wireless/ath/wil6210/p2p.c b/drivers/net/wireless/ath/wil6210/p2p.c
new file mode 100644
index 000000000000..2c1b8958180e
--- /dev/null
+++ b/drivers/net/wireless/ath/wil6210/p2p.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2014-2016 Qualcomm Atheros, Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "wil6210.h"
+#include "wmi.h"
+
+#define P2P_WILDCARD_SSID "DIRECT-"
+#define P2P_DMG_SOCIAL_CHANNEL 2
+#define P2P_SEARCH_DURATION_MS 500
+#define P2P_DEFAULT_BI 100
+
+void wil_p2p_discovery_timer_fn(ulong x)
+{
+        struct wil6210_priv *wil = (void *)x;
+
+        wil_dbg_misc(wil, "%s\n", __func__);
+
+        schedule_work(&wil->p2p.discovery_expired_work);
+}
+
+int wil_p2p_search(struct wil6210_priv *wil,
+                   struct cfg80211_scan_request *request)
+{
+        int rc;
+        struct wil_p2p_info *p2p = &wil->p2p;
+
+        wil_dbg_misc(wil, "%s: channel %d\n",
+                     __func__, P2P_DMG_SOCIAL_CHANNEL);
+
+        mutex_lock(&wil->mutex);
+
+        if (p2p->discovery_started) {
+                wil_err(wil, "%s: search failed. discovery already ongoing\n",
+                        __func__);
+                rc = -EBUSY;
+                goto out;
+        }
+
+        rc = wmi_p2p_cfg(wil, P2P_DMG_SOCIAL_CHANNEL, P2P_DEFAULT_BI);
+        if (rc) {
+                wil_err(wil, "%s: wmi_p2p_cfg failed\n", __func__);
+                goto out;
+        }
+
+        rc = wmi_set_ssid(wil, strlen(P2P_WILDCARD_SSID), P2P_WILDCARD_SSID);
+        if (rc) {
+                wil_err(wil, "%s: wmi_set_ssid failed\n", __func__);
+                goto out_stop;
+        }
+
+        /* Set application IE to probe request and probe response */
+        rc = wmi_set_ie(wil, WMI_FRAME_PROBE_REQ,
+                        request->ie_len, request->ie);
+        if (rc) {
+                wil_err(wil, "%s: wmi_set_ie(WMI_FRAME_PROBE_REQ) failed\n",
+                        __func__);
+                goto out_stop;
+        }
+
+        /* supplicant doesn't provide Probe Response IEs. As a workaround -
+         * re-use Probe Request IEs
+         */
+        rc = wmi_set_ie(wil, WMI_FRAME_PROBE_RESP,
+                        request->ie_len, request->ie);
+        if (rc) {
+                wil_err(wil, "%s: wmi_set_ie(WMI_FRAME_PROBE_RESP) failed\n",
+                        __func__);
+                goto out_stop;
+        }
+
+        rc = wmi_start_search(wil);
+        if (rc) {
+                wil_err(wil, "%s: wmi_start_search failed\n", __func__);
+                goto out_stop;
+        }
+
+        p2p->discovery_started = 1;
+        INIT_WORK(&p2p->discovery_expired_work, wil_p2p_search_expired);
+        mod_timer(&p2p->discovery_timer,
+                  jiffies + msecs_to_jiffies(P2P_SEARCH_DURATION_MS));
+
+out_stop:
+        if (rc)
+                wmi_stop_discovery(wil);
+
+out:
+        mutex_unlock(&wil->mutex);
+        return rc;
+}
+
+int wil_p2p_listen(struct wil6210_priv *wil, unsigned int duration,
+                   struct ieee80211_channel *chan, u64 *cookie)
+{
+        struct wil_p2p_info *p2p = &wil->p2p;
+        u8 channel = P2P_DMG_SOCIAL_CHANNEL;
+        int rc;
+
+        if (chan)
+                channel = chan->hw_value;
+
+        wil_dbg_misc(wil, "%s: duration %d\n", __func__, duration);
+
+        mutex_lock(&wil->mutex);
+
+        if (p2p->discovery_started) {
+                wil_err(wil, "%s: discovery already ongoing\n", __func__);
+                rc = -EBUSY;
+                goto out;
+        }
+
+        rc = wmi_p2p_cfg(wil, channel, P2P_DEFAULT_BI);
+        if (rc) {
+                wil_err(wil, "%s: wmi_p2p_cfg failed\n", __func__);
+                goto out;
+        }
+
+        rc = wmi_set_ssid(wil, strlen(P2P_WILDCARD_SSID), P2P_WILDCARD_SSID);
+        if (rc) {
+                wil_err(wil, "%s: wmi_set_ssid failed\n", __func__);
+                goto out_stop;
+        }
+
+        rc = wmi_start_listen(wil);
+        if (rc) {
+                wil_err(wil, "%s: wmi_start_listen failed\n", __func__);
+                goto out_stop;
+        }
+
+        memcpy(&p2p->listen_chan, chan, sizeof(*chan));
+        *cookie = ++p2p->cookie;
+
+        p2p->discovery_started = 1;
+        INIT_WORK(&p2p->discovery_expired_work, wil_p2p_listen_expired);
+        mod_timer(&p2p->discovery_timer,
+                  jiffies + msecs_to_jiffies(duration));
+
+out_stop:
+        if (rc)
+                wmi_stop_discovery(wil);
+
+out:
+        mutex_unlock(&wil->mutex);
+        return rc;
+}
+
+u8 wil_p2p_stop_discovery(struct wil6210_priv *wil)
+{
+        struct wil_p2p_info *p2p = &wil->p2p;
+        u8 started = p2p->discovery_started;
+
+        if (p2p->discovery_started) {
+                del_timer_sync(&p2p->discovery_timer);
+                p2p->discovery_started = 0;
+                wmi_stop_discovery(wil);
+        }
+
+        return started;
+}
+
+int wil_p2p_cancel_listen(struct wil6210_priv *wil, u64 cookie)
+{
+        struct wil_p2p_info *p2p = &wil->p2p;
+        u8 started;
+
+        mutex_lock(&wil->mutex);
+
+        if (cookie != p2p->cookie) {
+                wil_info(wil, "%s: Cookie mismatch: 0x%016llx vs. 0x%016llx\n",
+                         __func__, p2p->cookie, cookie);
+                mutex_unlock(&wil->mutex);
+                return -ENOENT;
+        }
+
+        started = wil_p2p_stop_discovery(wil);
+
+        mutex_unlock(&wil->mutex);
+
+        if (!started) {
+                wil_err(wil, "%s: listen not started\n", __func__);
+                return -ENOENT;
+        }
+
+        mutex_lock(&wil->p2p_wdev_mutex);
+        cfg80211_remain_on_channel_expired(wil->radio_wdev,
+                                           p2p->cookie,
+                                           &p2p->listen_chan,
+                                           GFP_KERNEL);
+        wil->radio_wdev = wil->wdev;
+        mutex_unlock(&wil->p2p_wdev_mutex);
+        return 0;
+}
+
+void wil_p2p_listen_expired(struct work_struct *work)
+{
+        struct wil_p2p_info *p2p = container_of(work,
+                        struct wil_p2p_info, discovery_expired_work);
+        struct wil6210_priv *wil = container_of(p2p,
+                        struct wil6210_priv, p2p);
+        u8 started;
+
+        wil_dbg_misc(wil, "%s()\n", __func__);
+
+        mutex_lock(&wil->mutex);
+        started = wil_p2p_stop_discovery(wil);
+        mutex_unlock(&wil->mutex);
+
+        if (started) {
+                mutex_lock(&wil->p2p_wdev_mutex);
+                cfg80211_remain_on_channel_expired(wil->radio_wdev,
+                                                   p2p->cookie,
+                                                   &p2p->listen_chan,
+                                                   GFP_KERNEL);
+                wil->radio_wdev = wil->wdev;
+                mutex_unlock(&wil->p2p_wdev_mutex);
+        }
+
+}
+
+void wil_p2p_search_expired(struct work_struct *work)
+{
+        struct wil_p2p_info *p2p = container_of(work,
+                        struct wil_p2p_info, discovery_expired_work);
+        struct wil6210_priv *wil = container_of(p2p,
+                        struct wil6210_priv, p2p);
+        u8 started;
+
+        wil_dbg_misc(wil, "%s()\n", __func__);
+
+        mutex_lock(&wil->mutex);
+        started = wil_p2p_stop_discovery(wil);
+        mutex_unlock(&wil->mutex);
+
+        if (started) {
+                mutex_lock(&wil->p2p_wdev_mutex);
+                cfg80211_scan_done(wil->scan_request, 0);
+                wil->scan_request = NULL;
+                wil->radio_wdev = wil->wdev;
+                mutex_unlock(&wil->p2p_wdev_mutex);
+        }
+}
diff --git a/drivers/net/wireless/ath/wil6210/pcie_bus.c b/drivers/net/wireless/ath/wil6210/pcie_bus.c
index e36f2a0c8cb6..aeb72c438e44 100644
--- a/drivers/net/wireless/ath/wil6210/pcie_bus.c
+++ b/drivers/net/wireless/ath/wil6210/pcie_bus.c
@@ -275,6 +275,7 @@ static void wil_pcie_remove(struct pci_dev *pdev)
         pci_disable_device(pdev);
         if (wil->platform_ops.uninit)
                 wil->platform_ops.uninit(wil->platform_handle);
+        wil_p2p_wdev_free(wil);
         wil_if_free(wil);
 }
 
diff --git a/drivers/net/wireless/ath/wil6210/rx_reorder.c b/drivers/net/wireless/ath/wil6210/rx_reorder.c
index 32031e7a11d5..19ed127d4d05 100644
--- a/drivers/net/wireless/ath/wil6210/rx_reorder.c
+++ b/drivers/net/wireless/ath/wil6210/rx_reorder.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2015 Qualcomm Atheros, Inc.
+ * Copyright (c) 2014-2016 Qualcomm Atheros, Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -291,35 +291,15 @@ static u16 wil_agg_size(struct wil6210_priv *wil, u16 req_agg_wsize)
         return min(max_agg_size, req_agg_wsize);
 }
 
-/* Block Ack - Rx side (recipient */
+/* Block Ack - Rx side (recipient) */
 int wil_addba_rx_request(struct wil6210_priv *wil, u8 cidxtid,
                          u8 dialog_token, __le16 ba_param_set,
                          __le16 ba_timeout, __le16 ba_seq_ctrl)
-{
-        struct wil_back_rx *req = kzalloc(sizeof(*req), GFP_KERNEL);
-
-        if (!req)
-                return -ENOMEM;
-
-        req->cidxtid = cidxtid;
-        req->dialog_token = dialog_token;
-        req->ba_param_set = le16_to_cpu(ba_param_set);
-        req->ba_timeout = le16_to_cpu(ba_timeout);
-        req->ba_seq_ctrl = le16_to_cpu(ba_seq_ctrl);
-
-        mutex_lock(&wil->back_rx_mutex);
-        list_add_tail(&req->list, &wil->back_rx_pending);
-        mutex_unlock(&wil->back_rx_mutex);
-
-        queue_work(wil->wq_service, &wil->back_rx_worker);
-
-        return 0;
-}
-
-static void wil_back_rx_handle(struct wil6210_priv *wil,
-                               struct wil_back_rx *req)
 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
 {
+        u16 param_set = le16_to_cpu(ba_param_set);
+        u16 agg_timeout = le16_to_cpu(ba_timeout);
+        u16 seq_ctrl = le16_to_cpu(ba_seq_ctrl);
         struct wil_sta_info *sta;
         u8 cid, tid;
         u16 agg_wsize = 0;
@@ -328,34 +308,35 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
          * bits 2..5: TID
          * bits 6..15: buffer size
          */
-        u16 req_agg_wsize = WIL_GET_BITS(req->ba_param_set, 6, 15);
-        bool agg_amsdu = !!(req->ba_param_set & BIT(0));
-        int ba_policy = req->ba_param_set & BIT(1);
-        u16 agg_timeout = req->ba_timeout;
+        u16 req_agg_wsize = WIL_GET_BITS(param_set, 6, 15);
+        bool agg_amsdu = !!(param_set & BIT(0));
+        int ba_policy = param_set & BIT(1);
         u16 status = WLAN_STATUS_SUCCESS;
-        u16 ssn = req->ba_seq_ctrl >> 4;
+        u16 ssn = seq_ctrl >> 4;
         struct wil_tid_ampdu_rx *r;
-        int rc;
+        int rc = 0;
 
         might_sleep();
-        parse_cidxtid(req->cidxtid, &cid, &tid);
+        parse_cidxtid(cidxtid, &cid, &tid);
 
         /* sanity checks */
         if (cid >= WIL6210_MAX_CID) {
                 wil_err(wil, "BACK: invalid CID %d\n", cid);
-                return;
+                rc = -EINVAL;
+                goto out;
         }
 
         sta = &wil->sta[cid];
         if (sta->status != wil_sta_connected) {
                 wil_err(wil, "BACK: CID %d not connected\n", cid);
-                return;
+                rc = -EINVAL;
+                goto out;
         }
 
         wil_dbg_wmi(wil,
                     "ADDBA request for CID %d %pM TID %d size %d timeout %d AMSDU%s policy %d token %d SSN 0x%03x\n",
-                    cid, sta->addr, tid, req_agg_wsize, req->ba_timeout,
-                    agg_amsdu ? "+" : "-", !!ba_policy, req->dialog_token, ssn);
+                    cid, sta->addr, tid, req_agg_wsize, agg_timeout,
+                    agg_amsdu ? "+" : "-", !!ba_policy, dialog_token, ssn);
 
         /* apply policies */
         if (ba_policy) {
@@ -365,10 +346,13 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
         if (status == WLAN_STATUS_SUCCESS)
                 agg_wsize = wil_agg_size(wil, req_agg_wsize);
 
-        rc = wmi_addba_rx_resp(wil, cid, tid, req->dialog_token, status,
+        rc = wmi_addba_rx_resp(wil, cid, tid, dialog_token, status,
                                agg_amsdu, agg_wsize, agg_timeout);
-        if (rc || (status != WLAN_STATUS_SUCCESS))
-                return;
+        if (rc || (status != WLAN_STATUS_SUCCESS)) {
+                wil_err(wil, "%s: do not apply ba, rc(%d), status(%d)\n",
+                        __func__, rc, status);
+                goto out;
+        }
 
         /* apply */
         r = wil_tid_ampdu_rx_alloc(wil, agg_wsize, ssn);
@@ -376,143 +360,37 @@ __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
         wil_tid_ampdu_rx_free(wil, sta->tid_rx[tid]);
         sta->tid_rx[tid] = r;
         spin_unlock_bh(&sta->tid_rx_lock);
-}
-
-void wil_back_rx_flush(struct wil6210_priv *wil)
-{
-        struct wil_back_rx *evt, *t;
 
-        wil_dbg_misc(wil, "%s()\n", __func__);
-
-        mutex_lock(&wil->back_rx_mutex);
-
-        list_for_each_entry_safe(evt, t, &wil->back_rx_pending, list) {
-                list_del(&evt->list);
-                kfree(evt);
-        }
-
-        mutex_unlock(&wil->back_rx_mutex);
-}
-
-/* Retrieve next ADDBA request from the pending list */
-static struct list_head *next_back_rx(struct wil6210_priv *wil)
-{
-        struct list_head *ret = NULL;
-
-        mutex_lock(&wil->back_rx_mutex);
-
-        if (!list_empty(&wil->back_rx_pending)) {
-                ret = wil->back_rx_pending.next;
-                list_del(ret);
-        }
-
-        mutex_unlock(&wil->back_rx_mutex);
-
-        return ret;
-}
-
-void wil_back_rx_worker(struct work_struct *work)
-{
-        struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
-                                                back_rx_worker);
-        struct wil_back_rx *evt;
-        struct list_head *lh;
-
-        while ((lh = next_back_rx(wil)) != NULL) {
-                evt = list_entry(lh, struct wil_back_rx, list);
-
-                wil_back_rx_handle(wil, evt);
-                kfree(evt);
-        }
+out:
+        return rc;
 }
 
-/* BACK - Tx (originator) side */
-static void wil_back_tx_handle(struct wil6210_priv *wil,
-                               struct wil_back_tx *req)
+/* BACK - Tx side (originator) */
+int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize)
 {
-        struct vring_tx_data *txdata = &wil->vring_tx_data[req->ringid];
-        int rc;
+        u8 agg_wsize = wil_agg_size(wil, wsize);
+        u16 agg_timeout = 0;
+        struct vring_tx_data *txdata = &wil->vring_tx_data[ringid];
+        int rc = 0;
 
         if (txdata->addba_in_progress) {
                 wil_dbg_misc(wil, "ADDBA for vring[%d] already in progress\n",
-                             req->ringid);
-                return;
+                             ringid);
+                goto out;
         }
         if (txdata->agg_wsize) {
                 wil_dbg_misc(wil,
-                             "ADDBA for vring[%d] already established wsize %d\n",
-                             req->ringid, txdata->agg_wsize);
-                return;
+                             "ADDBA for vring[%d] already done for wsize %d\n",
+                             ringid, txdata->agg_wsize);
+                goto out;
         }
         txdata->addba_in_progress = true;
-        rc = wmi_addba(wil, req->ringid, req->agg_wsize, req->agg_timeout);
-        if (rc)
+        rc = wmi_addba(wil, ringid, agg_wsize, agg_timeout);
+        if (rc) {
+                wil_err(wil, "%s: wmi_addba failed, rc (%d)", __func__, rc);
                 txdata->addba_in_progress = false;
-}
-
-static struct list_head *next_back_tx(struct wil6210_priv *wil)
-{
-        struct list_head *ret = NULL;
-
-        mutex_lock(&wil->back_tx_mutex);
-
-        if (!list_empty(&wil->back_tx_pending)) {
-                ret = wil->back_tx_pending.next;
-                list_del(ret);
-        }
-
-        mutex_unlock(&wil->back_tx_mutex);
-
-        return ret;
-}
-
-void wil_back_tx_worker(struct work_struct *work)
-{
-        struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
-                                                 back_tx_worker);
-        struct wil_back_tx *evt;
-        struct list_head *lh;
-
-        while ((lh = next_back_tx(wil)) != NULL) {
-                evt = list_entry(lh, struct wil_back_tx, list);
-
-                wil_back_tx_handle(wil, evt);
-                kfree(evt);
         }
-}
-
-void wil_back_tx_flush(struct wil6210_priv *wil)
-{
-        struct wil_back_tx *evt, *t;
-
-        wil_dbg_misc(wil, "%s()\n", __func__);
-
-        mutex_lock(&wil->back_tx_mutex);
-
-        list_for_each_entry_safe(evt, t, &wil->back_tx_pending, list) {
-                list_del(&evt->list);
-                kfree(evt);
-        }
-
-        mutex_unlock(&wil->back_tx_mutex);
-}
-
-int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize)
-{
-        struct wil_back_tx *req = kzalloc(sizeof(*req), GFP_KERNEL);
-
-        if (!req)
-                return -ENOMEM;
 
-        req->ringid = ringid;
-        req->agg_wsize = wil_agg_size(wil, wsize);
-        req->agg_timeout = 0;
-
-        mutex_lock(&wil->back_tx_mutex);
-        list_add_tail(&req->list, &wil->back_tx_pending);
-        mutex_unlock(&wil->back_tx_mutex);
-
-        queue_work(wil->wq_service, &wil->back_tx_worker);
-
-        return 0;
+out:
+        return rc;
 }
diff --git a/drivers/net/wireless/ath/wil6210/trace.h b/drivers/net/wireless/ath/wil6210/trace.h
index e59239d22b94..c4db2a9d9f7f 100644
--- a/drivers/net/wireless/ath/wil6210/trace.h
+++ b/drivers/net/wireless/ath/wil6210/trace.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Qualcomm Atheros, Inc.
+ * Copyright (c) 2013-2016 Qualcomm Atheros, Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -37,39 +37,40 @@ static inline void trace_ ## name(proto) {}
 #endif /* !CONFIG_WIL6210_TRACING || defined(__CHECKER__) */
 
 DECLARE_EVENT_CLASS(wil6210_wmi,
-        TP_PROTO(struct wil6210_mbox_hdr_wmi *wmi, void *buf, u16 buf_len),
+        TP_PROTO(struct wmi_cmd_hdr *wmi, void *buf, u16 buf_len),
 
         TP_ARGS(wmi, buf, buf_len),
 
         TP_STRUCT__entry(
                 __field(u8, mid)
-                __field(u16, id)
-                __field(u32, timestamp)
+                __field(u16, command_id)
+                __field(u32, fw_timestamp)
                 __field(u16, buf_len)
                 __dynamic_array(u8, buf, buf_len)
         ),
 
         TP_fast_assign(
                 __entry->mid = wmi->mid;
-                __entry->id = le16_to_cpu(wmi->id);
-                __entry->timestamp = le32_to_cpu(wmi->timestamp);
+                __entry->command_id = le16_to_cpu(wmi->command_id);
+                __entry->fw_timestamp = le32_to_cpu(wmi->fw_timestamp);
                 __entry->buf_len = buf_len;
                 memcpy(__get_dynamic_array(buf), buf, buf_len);
         ),
 
         TP_printk(
                 "MID %d id 0x%04x len %d timestamp %d",
-                __entry->mid, __entry->id, __entry->buf_len, __entry->timestamp
+                __entry->mid, __entry->command_id, __entry->buf_len,
+                __entry->fw_timestamp
         )
 );
 
 DEFINE_EVENT(wil6210_wmi, wil6210_wmi_cmd,
-        TP_PROTO(struct wil6210_mbox_hdr_wmi *wmi, void *buf, u16 buf_len),
+        TP_PROTO(struct wmi_cmd_hdr *wmi, void *buf, u16 buf_len),
         TP_ARGS(wmi, buf, buf_len)
 );
 
 DEFINE_EVENT(wil6210_wmi, wil6210_wmi_event,
-        TP_PROTO(struct wil6210_mbox_hdr_wmi *wmi, void *buf, u16 buf_len),
+        TP_PROTO(struct wmi_cmd_hdr *wmi, void *buf, u16 buf_len),
         TP_ARGS(wmi, buf, buf_len)
 );
 
diff --git a/drivers/net/wireless/ath/wil6210/txrx.c b/drivers/net/wireless/ath/wil6210/txrx.c
index 6af20903cf89..f260b232fd57 100644
--- a/drivers/net/wireless/ath/wil6210/txrx.c
+++ b/drivers/net/wireless/ath/wil6210/txrx.c
@@ -549,6 +549,60 @@ static int wil_rx_refill(struct wil6210_priv *wil, int count)
         return rc;
 }
 
+/**
+ * reverse_memcmp - Compare two areas of memory, in reverse order
+ * @cs: One area of memory
+ * @ct: Another area of memory
+ * @count: The size of the area.
+ *
+ * Cut'n'paste from original memcmp (see lib/string.c)
+ * with minimal modifications
+ */
+static int reverse_memcmp(const void *cs, const void *ct, size_t count)
+{
+        const unsigned char *su1, *su2;
+        int res = 0;
+
+        for (su1 = cs + count - 1, su2 = ct + count - 1; count > 0;
+             --su1, --su2, count--) {
+                res = *su1 - *su2;
+                if (res)
+                        break;
+        }
+        return res;
+}
+
+static int wil_rx_crypto_check(struct wil6210_priv *wil, struct sk_buff *skb)
+{
+        struct vring_rx_desc *d = wil_skb_rxdesc(skb);
+        int cid = wil_rxdesc_cid(d);
+        int tid = wil_rxdesc_tid(d);
+        int key_id = wil_rxdesc_key_id(d);
+        int mc = wil_rxdesc_mcast(d);
+        struct wil_sta_info *s = &wil->sta[cid];
+        struct wil_tid_crypto_rx *c = mc ? &s->group_crypto_rx :
+                                      &s->tid_crypto_rx[tid];
+        struct wil_tid_crypto_rx_single *cc = &c->key_id[key_id];
+        const u8 *pn = (u8 *)&d->mac.pn_15_0;
+
+        if (!cc->key_set) {
+                wil_err_ratelimited(wil,
+                                    "Key missing. CID %d TID %d MCast %d KEY_ID %d\n",
+                                    cid, tid, mc, key_id);
+                return -EINVAL;
+        }
+
+        if (reverse_memcmp(pn, cc->pn, IEEE80211_GCMP_PN_LEN) <= 0) {
+                wil_err_ratelimited(wil,
+                                    "Replay attack. CID %d TID %d MCast %d KEY_ID %d PN %6phN last %6phN\n",
+                                    cid, tid, mc, key_id, pn, cc->pn);
+                return -EINVAL;
+        }
+        memcpy(cc->pn, pn, IEEE80211_GCMP_PN_LEN);
+
+        return 0;
+}
+
 /*
  * Pass Rx packet to the netif. Update statistics.
  * Called in softirq context (NAPI poll).
@@ -561,6 +615,7 @@ void wil_netif_rx_any(struct sk_buff *skb, struct net_device *ndev)
         unsigned int len = skb->len;
         struct vring_rx_desc *d = wil_skb_rxdesc(skb);
         int cid = wil_rxdesc_cid(d); /* always 0..7, no need to check */
+        int security = wil_rxdesc_security(d);
         struct ethhdr *eth = (void *)skb->data;
         /* here looking for DA, not A1, thus Rxdesc's 'mcast' indication
          * is not suitable, need to look at data
@@ -586,6 +641,13 @@ void wil_netif_rx_any(struct sk_buff *skb, struct net_device *ndev)
 
         skb_orphan(skb);
 
+        if (security && (wil_rx_crypto_check(wil, skb) != 0)) {
+                rc = GRO_DROP;
+                dev_kfree_skb(skb);
+                stats->rx_replay++;
+                goto stats;
+        }
+
         if (wdev->iftype == NL80211_IFTYPE_AP && !wil->ap_isolate) {
                 if (mcast) {
                         /* send multicast frames both to higher layers in
@@ -627,6 +689,7 @@ void wil_netif_rx_any(struct sk_buff *skb, struct net_device *ndev)
                 wil_dbg_txrx(wil, "Rx complete %d bytes => %s\n",
                              len, gro_res_str[rc]);
         }
+stats:
         /* statistics. rc set to GRO_NORMAL for AP bridging */
         if (unlikely(rc == GRO_DROP)) {
                 ndev->stats.rx_dropped++;
@@ -757,7 +820,7 @@ int wil_vring_init_tx(struct wil6210_priv *wil, int id, int size,
                 },
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_vring_cfg_done_event cmd;
         } __packed reply;
         struct vring *vring = &wil->vring_tx[id];
@@ -834,7 +897,7 @@ int wil_vring_init_bcast(struct wil6210_priv *wil, int id, int size)
                 },
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_vring_cfg_done_event cmd;
         } __packed reply;
         struct vring *vring = &wil->vring_tx[id];
diff --git a/drivers/net/wireless/ath/wil6210/txrx.h b/drivers/net/wireless/ath/wil6210/txrx.h
index ee7c7b4b9a17..fcdffaa8251b 100644
--- a/drivers/net/wireless/ath/wil6210/txrx.h
+++ b/drivers/net/wireless/ath/wil6210/txrx.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2014 Qualcomm Atheros, Inc.
+ * Copyright (c) 2012-2016 Qualcomm Atheros, Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -480,6 +480,16 @@ static inline int wil_rxdesc_ext_subtype(struct vring_rx_desc *d)
         return WIL_GET_BITS(d->mac.d0, 28, 31);
 }
 
+static inline int wil_rxdesc_key_id(struct vring_rx_desc *d)
+{
+        return WIL_GET_BITS(d->mac.d1, 4, 5);
+}
+
+static inline int wil_rxdesc_security(struct vring_rx_desc *d)
+{
+        return WIL_GET_BITS(d->mac.d1, 7, 7);
+}
+
 static inline int wil_rxdesc_ds_bits(struct vring_rx_desc *d)
 {
         return WIL_GET_BITS(d->mac.d1, 8, 9);
diff --git a/drivers/net/wireless/ath/wil6210/wil6210.h b/drivers/net/wireless/ath/wil6210/wil6210.h
index 8427d68b6fa8..4d699ea46373 100644
--- a/drivers/net/wireless/ath/wil6210/wil6210.h
+++ b/drivers/net/wireless/ath/wil6210/wil6210.h
@@ -22,6 +22,7 @@
 #include <net/cfg80211.h>
 #include <linux/timex.h>
 #include <linux/types.h>
+#include "wmi.h"
 #include "wil_platform.h"
 
 extern bool no_fw_recovery;
@@ -131,6 +132,7 @@ struct RGF_ICR {
 /* registers - FW addresses */
 #define RGF_USER_USAGE_1                (0x880004)
 #define RGF_USER_USAGE_6                (0x880018)
+        #define BIT_USER_OOB_MODE               BIT(31)
 #define RGF_USER_HW_MACHINE_STATE       (0x8801dc)
         #define HW_MACHINE_BOOT_DONE    (0x3fffffd)
 #define RGF_USER_USER_CPU_0             (0x8801e0)
@@ -334,29 +336,11 @@ struct wil6210_mbox_hdr {
 /* max. value for wil6210_mbox_hdr.len */
 #define MAX_MBOXITEM_SIZE   (240)
 
-/**
- * struct wil6210_mbox_hdr_wmi - WMI header
- *
- * @mid: MAC ID
- *      00 - default, created by FW
- *      01..0f - WiFi ports, driver to create
- *      10..fe - debug
- *      ff - broadcast
- * @id: command/event ID
- * @timestamp: FW fills for events, free-running msec timer
- */
-struct wil6210_mbox_hdr_wmi {
-        u8 mid;
-        u8 reserved;
-        __le16 id;
-        __le32 timestamp;
-} __packed;
-
 struct pending_wmi_event {
         struct list_head list;
         struct {
                 struct wil6210_mbox_hdr hdr;
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 u8 data[0];
         } __packed event;
 };
@@ -455,6 +439,29 @@ struct wil_tid_ampdu_rx {
         bool first_time; /* is it 1-st time this buffer used? */
 };
 
+/**
+ * struct wil_tid_crypto_rx_single - TID crypto information (Rx).
+ *
+ * @pn: GCMP PN for the session
+ * @key_set: valid key present
+ */
+struct wil_tid_crypto_rx_single {
+        u8 pn[IEEE80211_GCMP_PN_LEN];
+        bool key_set;
+};
+
+struct wil_tid_crypto_rx {
+        struct wil_tid_crypto_rx_single key_id[4];
+};
+
+struct wil_p2p_info {
+        struct ieee80211_channel listen_chan;
+        u8 discovery_started;
+        u64 cookie;
+        struct timer_list discovery_timer; /* listen/search duration */
+        struct work_struct discovery_expired_work; /* listen/search expire */
+};
+
 enum wil_sta_status {
         wil_sta_unused = 0,
         wil_sta_conn_pending = 1,
@@ -474,6 +481,7 @@ struct wil_net_stats {
         unsigned long   rx_non_data_frame;
         unsigned long   rx_short_frame;
         unsigned long   rx_large_frame;
+        unsigned long   rx_replay;
         u16 last_mcs_rx;
         u64 rx_per_mcs[WIL_MCS_MAX + 1];
 };
@@ -495,6 +503,8 @@ struct wil_sta_info {
         spinlock_t tid_rx_lock; /* guarding tid_rx array */
         unsigned long tid_rx_timer_expired[BITS_TO_LONGS(WIL_STA_TID_NUM)];
         unsigned long tid_rx_stop_requested[BITS_TO_LONGS(WIL_STA_TID_NUM)];
+        struct wil_tid_crypto_rx tid_crypto_rx[WIL_STA_TID_NUM];
+        struct wil_tid_crypto_rx group_crypto_rx;
 };
 
 enum {
@@ -507,24 +517,6 @@ enum {
         hw_capability_last
 };
 
-struct wil_back_rx {
-        struct list_head list;
-        /* request params, converted to CPU byte order - what we asked for */
-        u8 cidxtid;
-        u8 dialog_token;
-        u16 ba_param_set;
-        u16 ba_timeout;
-        u16 ba_seq_ctrl;
-};
-
-struct wil_back_tx {
-        struct list_head list;
-        /* request params, converted to CPU byte order - what we asked for */
-        u8 ringid;
-        u8 agg_wsize;
-        u16 agg_timeout;
-};
-
 struct wil_probe_client_req {
         struct list_head list;
         u64 cookie;
@@ -595,13 +587,6 @@ struct wil6210_priv {
         spinlock_t wmi_ev_lock;
         struct napi_struct napi_rx;
         struct napi_struct napi_tx;
-        /* BACK */
-        struct list_head back_rx_pending;
-        struct mutex back_rx_mutex; /* protect @back_rx_pending */
-        struct work_struct back_rx_worker;
-        struct list_head back_tx_pending;
-        struct mutex back_tx_mutex; /* protect @back_tx_pending */
-        struct work_struct back_tx_worker;
         /* keep alive */
         struct list_head probe_client_pending;
         struct mutex probe_client_mutex; /* protect @probe_client_pending */
@@ -622,11 +607,21 @@ struct wil6210_priv {
         /* debugfs */
         struct dentry *debug;
         struct debugfs_blob_wrapper blobs[ARRAY_SIZE(fw_mapping)];
+        u8 discovery_mode;
 
         void *platform_handle;
         struct wil_platform_ops platform_ops;
 
         struct pmc_ctx pmc;
+
+        bool pbss;
+
+        struct wil_p2p_info p2p;
+
+        /* P2P_DEVICE vif */
+        struct wireless_dev *p2p_wdev;
+        struct mutex p2p_wdev_mutex; /* protect @p2p_wdev */
+        struct wireless_dev *radio_wdev;
 };
 
 #define wil_to_wiphy(i) (i->wdev->wiphy)
@@ -722,6 +717,7 @@ void wil_priv_deinit(struct wil6210_priv *wil);
 int wil_reset(struct wil6210_priv *wil, bool no_fw);
 void wil_fw_error_recovery(struct wil6210_priv *wil);
 void wil_set_recovery_state(struct wil6210_priv *wil, int state);
+bool wil_is_recovery_blocked(struct wil6210_priv *wil);
 int wil_up(struct wil6210_priv *wil);
 int __wil_up(struct wil6210_priv *wil);
 int wil_down(struct wil6210_priv *wil);
@@ -752,7 +748,6 @@ int wmi_add_cipher_key(struct wil6210_priv *wil, u8 key_index,
 int wmi_echo(struct wil6210_priv *wil);
 int wmi_set_ie(struct wil6210_priv *wil, u8 type, u16 ie_len, const void *ie);
 int wmi_rx_chain_add(struct wil6210_priv *wil, struct vring *vring);
-int wmi_p2p_cfg(struct wil6210_priv *wil, int channel);
 int wmi_rxon(struct wil6210_priv *wil, bool on);
 int wmi_get_temperature(struct wil6210_priv *wil, u32 *t_m, u32 *t_r);
 int wmi_disconnect_sta(struct wil6210_priv *wil, const u8 *mac, u16 reason,
@@ -765,11 +760,7 @@ int wmi_addba_rx_resp(struct wil6210_priv *wil, u8 cid, u8 tid, u8 token,
 int wil_addba_rx_request(struct wil6210_priv *wil, u8 cidxtid,
                          u8 dialog_token, __le16 ba_param_set,
                          __le16 ba_timeout, __le16 ba_seq_ctrl);
-void wil_back_rx_worker(struct work_struct *work);
-void wil_back_rx_flush(struct wil6210_priv *wil);
 int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize);
-void wil_back_tx_worker(struct work_struct *work);
-void wil_back_tx_flush(struct wil6210_priv *wil);
 
 void wil6210_clear_irq(struct wil6210_priv *wil);
 int wil6210_init_irq(struct wil6210_priv *wil, int irq, bool use_msi);
@@ -779,6 +770,24 @@ void wil_unmask_irq(struct wil6210_priv *wil);
 void wil_configure_interrupt_moderation(struct wil6210_priv *wil);
 void wil_disable_irq(struct wil6210_priv *wil);
 void wil_enable_irq(struct wil6210_priv *wil);
+
+/* P2P */
+void wil_p2p_discovery_timer_fn(ulong x);
+int wil_p2p_search(struct wil6210_priv *wil,
+                   struct cfg80211_scan_request *request);
+int wil_p2p_listen(struct wil6210_priv *wil, unsigned int duration,
+                   struct ieee80211_channel *chan, u64 *cookie);
+u8 wil_p2p_stop_discovery(struct wil6210_priv *wil);
+int wil_p2p_cancel_listen(struct wil6210_priv *wil, u64 cookie);
+void wil_p2p_listen_expired(struct work_struct *work);
+void wil_p2p_search_expired(struct work_struct *work);
+
+/* WMI for P2P */
+int wmi_p2p_cfg(struct wil6210_priv *wil, int channel, int bi);
+int wmi_start_listen(struct wil6210_priv *wil);
+int wmi_start_search(struct wil6210_priv *wil);
+int wmi_stop_discovery(struct wil6210_priv *wil);
+
 int wil_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
                          struct cfg80211_mgmt_tx_params *params,
                          u64 *cookie);
@@ -790,10 +799,11 @@ int wil_cid_fill_sinfo(struct wil6210_priv *wil, int cid,
 
 struct wireless_dev *wil_cfg80211_init(struct device *dev);
 void wil_wdev_free(struct wil6210_priv *wil);
+void wil_p2p_wdev_free(struct wil6210_priv *wil);
 
 int wmi_set_mac_address(struct wil6210_priv *wil, void *addr);
 int wmi_pcp_start(struct wil6210_priv *wil, int bi, u8 wmi_nettype,
-                  u8 chan, u8 hidden_ssid);
+                  u8 chan, u8 hidden_ssid, u8 is_go);
 int wmi_pcp_stop(struct wil6210_priv *wil);
 void wil6210_disconnect(struct wil6210_priv *wil, const u8 *bssid,
                         u16 reason_code, bool from_event);
diff --git a/drivers/net/wireless/ath/wil6210/wil_platform.h b/drivers/net/wireless/ath/wil6210/wil_platform.h
index 9a949d910343..33d4a34b3b1c 100644
--- a/drivers/net/wireless/ath/wil6210/wil_platform.h
+++ b/drivers/net/wireless/ath/wil6210/wil_platform.h
@@ -19,6 +19,12 @@
 
 struct device;
 
+enum wil_platform_event {
+        WIL_PLATFORM_EVT_FW_CRASH = 0,
+        WIL_PLATFORM_EVT_PRE_RESET = 1,
+        WIL_PLATFORM_EVT_FW_RDY = 2,
+};
+
 /**
  * struct wil_platform_ops - wil platform module calls from this
  * driver to platform driver
@@ -28,7 +34,7 @@ struct wil_platform_ops {
         int (*suspend)(void *handle);
         int (*resume)(void *handle);
         void (*uninit)(void *handle);
-        int (*notify_crash)(void *handle);
+        int (*notify)(void *handle, enum wil_platform_event evt);
 };
 
 /**
diff --git a/drivers/net/wireless/ath/wil6210/wmi.c b/drivers/net/wireless/ath/wil6210/wmi.c
index 493e721c4fa7..6ca28c3eff0a 100644
--- a/drivers/net/wireless/ath/wil6210/wmi.c
+++ b/drivers/net/wireless/ath/wil6210/wmi.c
@@ -176,7 +176,7 @@ static int __wmi_send(struct wil6210_priv *wil, u16 cmdid, void *buf, u16 len)
 {
         struct {
                 struct wil6210_mbox_hdr hdr;
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
         } __packed cmd = {
                 .hdr = {
                         .type = WIL_MBOX_HDR_TYPE_WMI,
@@ -185,7 +185,7 @@ static int __wmi_send(struct wil6210_priv *wil, u16 cmdid, void *buf, u16 len)
                 },
                 .wmi = {
                         .mid = 0,
-                        .id = cpu_to_le16(cmdid),
+                        .command_id = cpu_to_le16(cmdid),
                 },
         };
         struct wil6210_mbox_ring *r = &wil->mbox_ctl.tx;
@@ -333,7 +333,7 @@ static void wmi_evt_rx_mgmt(struct wil6210_priv *wil, int id, void *d, int len)
         }
 
         ch_no = data->info.channel + 1;
-        freq = ieee80211_channel_to_frequency(ch_no, IEEE80211_BAND_60GHZ);
+        freq = ieee80211_channel_to_frequency(ch_no, NL80211_BAND_60GHZ);
         channel = ieee80211_get_channel(wiphy, freq);
         signal = data->info.sqi;
         d_status = le16_to_cpu(data->info.status);
@@ -368,6 +368,8 @@ static void wmi_evt_rx_mgmt(struct wil6210_priv *wil, int id, void *d, int len)
                 wil_hex_dump_wmi("IE ", DUMP_PREFIX_OFFSET, 16, 1, ie_buf,
                                  ie_len, true);
 
+                wil_dbg_wmi(wil, "Capability info : 0x%04x\n", cap);
+
                 bss = cfg80211_inform_bss_frame(wiphy, channel, rx_mgmt_frame,
                                                 d_len, signal, GFP_KERNEL);
                 if (bss) {
@@ -378,8 +380,10 @@ static void wmi_evt_rx_mgmt(struct wil6210_priv *wil, int id, void *d, int len)
                         wil_err(wil, "cfg80211_inform_bss_frame() failed\n");
                 }
         } else {
-                cfg80211_rx_mgmt(wil->wdev, freq, signal,
+                mutex_lock(&wil->p2p_wdev_mutex);
+                cfg80211_rx_mgmt(wil->radio_wdev, freq, signal,
                                  (void *)rx_mgmt_frame, d_len, 0);
+                mutex_unlock(&wil->p2p_wdev_mutex);
         }
 }
 
@@ -406,7 +410,10 @@ static void wmi_evt_scan_complete(struct wil6210_priv *wil, int id,
                              wil->scan_request, aborted);
 
                 del_timer_sync(&wil->scan_timer);
+                mutex_lock(&wil->p2p_wdev_mutex);
                 cfg80211_scan_done(wil->scan_request, aborted);
+                wil->radio_wdev = wil->wdev;
+                mutex_unlock(&wil->p2p_wdev_mutex);
                 wil->scan_request = NULL;
         } else {
                 wil_err(wil, "SCAN_COMPLETE while not scanning\n");
@@ -487,6 +494,14 @@ static void wmi_evt_connect(struct wil6210_priv *wil, int id, void *d, int len)
                         return;
                 }
                 del_timer_sync(&wil->connect_timer);
+        } else if ((wdev->iftype == NL80211_IFTYPE_AP) ||
+                   (wdev->iftype == NL80211_IFTYPE_P2P_GO)) {
+                if (wil->sta[evt->cid].status != wil_sta_unused) {
+                        wil_err(wil, "%s: AP: Invalid status %d for CID %d\n",
+                                __func__, wil->sta[evt->cid].status, evt->cid);
+                        mutex_unlock(&wil->mutex);
+                        return;
+                }
         }
 
         /* FIXME FW can transmit only ucast frames to peer */
@@ -648,7 +663,7 @@ static void wmi_evt_vring_en(struct wil6210_priv *wil, int id, void *d, int len)
 static void wmi_evt_ba_status(struct wil6210_priv *wil, int id, void *d,
                               int len)
 {
-        struct wmi_vring_ba_status_event *evt = d;
+        struct wmi_ba_status_event *evt = d;
         struct vring_tx_data *txdata;
 
         wil_dbg_wmi(wil, "BACK[%d] %s {%d} timeout %d AMSDU%s\n",
@@ -834,10 +849,10 @@ void wmi_recv_cmd(struct wil6210_priv *wil)
                       offsetof(struct wil6210_mbox_ring_desc, sync), 0);
                 /* indicate */
                 if ((hdr.type == WIL_MBOX_HDR_TYPE_WMI) &&
-                    (len >= sizeof(struct wil6210_mbox_hdr_wmi))) {
-                        struct wil6210_mbox_hdr_wmi *wmi = &evt->event.wmi;
-                        u16 id = le16_to_cpu(wmi->id);
-                        u32 tstamp = le32_to_cpu(wmi->timestamp);
+                    (len >= sizeof(struct wmi_cmd_hdr))) {
+                        struct wmi_cmd_hdr *wmi = &evt->event.wmi;
+                        u16 id = le16_to_cpu(wmi->command_id);
+                        u32 tstamp = le32_to_cpu(wmi->fw_timestamp);
                         spin_lock_irqsave(&wil->wmi_ev_lock, flags);
                         if (wil->reply_id && wil->reply_id == id) {
                                 if (wil->reply_buf) {
@@ -947,7 +962,7 @@ int wmi_set_mac_address(struct wil6210_priv *wil, void *addr)
 }
 
 int wmi_pcp_start(struct wil6210_priv *wil, int bi, u8 wmi_nettype,
-                  u8 chan, u8 hidden_ssid)
+                  u8 chan, u8 hidden_ssid, u8 is_go)
 {
         int rc;
 
@@ -958,9 +973,10 @@ int wmi_pcp_start(struct wil6210_priv *wil, int bi, u8 wmi_nettype,
                 .channel = chan - 1,
                 .pcp_max_assoc_sta = max_assoc_sta,
                 .hidden_ssid = hidden_ssid,
+                .is_go = is_go,
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_pcp_started_event evt;
         } __packed reply;
 
@@ -1014,7 +1030,7 @@ int wmi_get_ssid(struct wil6210_priv *wil, u8 *ssid_len, void *ssid)
 {
         int rc;
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_set_ssid_cmd cmd;
         } __packed reply;
         int len; /* reply.cmd.ssid_len in CPU order */
@@ -1047,7 +1063,7 @@ int wmi_get_channel(struct wil6210_priv *wil, int *channel)
 {
         int rc;
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_set_pcp_channel_cmd cmd;
         } __packed reply;
 
@@ -1064,14 +1080,86 @@ int wmi_get_channel(struct wil6210_priv *wil, int *channel)
         return 0;
 }
 
-int wmi_p2p_cfg(struct wil6210_priv *wil, int channel)
+int wmi_p2p_cfg(struct wil6210_priv *wil, int channel, int bi)
 {
+        int rc;
         struct wmi_p2p_cfg_cmd cmd = {
-                .discovery_mode = WMI_DISCOVERY_MODE_NON_OFFLOAD,
+                .discovery_mode = WMI_DISCOVERY_MODE_PEER2PEER,
+                .bcon_interval = cpu_to_le16(bi),
                 .channel = channel - 1,
         };
+        struct {
+                struct wmi_cmd_hdr wmi;
+                struct wmi_p2p_cfg_done_event evt;
+        } __packed reply;
+
+        wil_dbg_wmi(wil, "sending WMI_P2P_CFG_CMDID\n");
+
+        rc = wmi_call(wil, WMI_P2P_CFG_CMDID, &cmd, sizeof(cmd),
+                      WMI_P2P_CFG_DONE_EVENTID, &reply, sizeof(reply), 300);
+        if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
+                wil_err(wil, "P2P_CFG failed. status %d\n", reply.evt.status);
+                rc = -EINVAL;
+        }
 
-        return wmi_send(wil, WMI_P2P_CFG_CMDID, &cmd, sizeof(cmd));
+        return rc;
+}
+
+int wmi_start_listen(struct wil6210_priv *wil)
+{
+        int rc;
+        struct {
+                struct wmi_cmd_hdr wmi;
+                struct wmi_listen_started_event evt;
+        } __packed reply;
+
+        wil_dbg_wmi(wil, "sending WMI_START_LISTEN_CMDID\n");
+
+        rc = wmi_call(wil, WMI_START_LISTEN_CMDID, NULL, 0,
+                      WMI_LISTEN_STARTED_EVENTID, &reply, sizeof(reply), 300);
+        if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
+                wil_err(wil, "device failed to start listen. status %d\n",
+                        reply.evt.status);
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+int wmi_start_search(struct wil6210_priv *wil)
+{
+        int rc;
+        struct {
+                struct wmi_cmd_hdr wmi;
+                struct wmi_search_started_event evt;
+        } __packed reply;
+
+        wil_dbg_wmi(wil, "sending WMI_START_SEARCH_CMDID\n");
+
+        rc = wmi_call(wil, WMI_START_SEARCH_CMDID, NULL, 0,
+                      WMI_SEARCH_STARTED_EVENTID, &reply, sizeof(reply), 300);
+        if (!rc && reply.evt.status != WMI_FW_STATUS_SUCCESS) {
+                wil_err(wil, "device failed to start search. status %d\n",
+                        reply.evt.status);
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+int wmi_stop_discovery(struct wil6210_priv *wil)
+{
+        int rc;
+
+        wil_dbg_wmi(wil, "sending WMI_DISCOVERY_STOP_CMDID\n");
+
+        rc = wmi_call(wil, WMI_DISCOVERY_STOP_CMDID, NULL, 0,
+                      WMI_DISCOVERY_STOPPED_EVENTID, NULL, 0, 100);
+
+        if (rc)
+                wil_err(wil, "Failed to stop discovery\n");
+
+        return rc;
 }
 
 int wmi_del_cipher_key(struct wil6210_priv *wil, u8 key_index,
@@ -1155,7 +1243,7 @@ int wmi_rxon(struct wil6210_priv *wil, bool on)
 {
         int rc;
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_listen_started_event evt;
         } __packed reply;
 
@@ -1192,7 +1280,7 @@ int wmi_rx_chain_add(struct wil6210_priv *wil, struct vring *vring)
                 .host_thrsh = cpu_to_le16(rx_ring_overflow_thrsh),
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_cfg_rx_chain_done_event evt;
         } __packed evt;
         int rc;
@@ -1246,7 +1334,7 @@ int wmi_get_temperature(struct wil6210_priv *wil, u32 *t_bb, u32 *t_rf)
                 .measure_mode = cpu_to_le32(TEMPERATURE_MEASURE_NOW),
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_temp_sense_done_event evt;
         } __packed reply;
 
@@ -1272,7 +1360,7 @@ int wmi_disconnect_sta(struct wil6210_priv *wil, const u8 *mac, u16 reason,
                 .disconnect_reason = cpu_to_le16(reason),
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_disconnect_event evt;
         } __packed reply;
 
@@ -1364,7 +1452,7 @@ int wmi_addba_rx_resp(struct wil6210_priv *wil, u8 cid, u8 tid, u8 token,
                 .ba_timeout = cpu_to_le16(timeout),
         };
         struct {
-                struct wil6210_mbox_hdr_wmi wmi;
+                struct wmi_cmd_hdr wmi;
                 struct wmi_rcp_addba_resp_sent_event evt;
         } __packed reply;
 
@@ -1420,10 +1508,10 @@ static void wmi_event_handle(struct wil6210_priv *wil,
         u16 len = le16_to_cpu(hdr->len);
 
         if ((hdr->type == WIL_MBOX_HDR_TYPE_WMI) &&
-            (len >= sizeof(struct wil6210_mbox_hdr_wmi))) {
-                struct wil6210_mbox_hdr_wmi *wmi = (void *)(&hdr[1]);
+            (len >= sizeof(struct wmi_cmd_hdr))) {
+                struct wmi_cmd_hdr *wmi = (void *)(&hdr[1]);
                 void *evt_data = (void *)(&wmi[1]);
-                u16 id = le16_to_cpu(wmi->id);
+                u16 id = le16_to_cpu(wmi->command_id);
 
                 wil_dbg_wmi(wil, "Handle WMI 0x%04x (reply_id 0x%04x)\n",
                             id, wil->reply_id);
diff --git a/drivers/net/wireless/ath/wil6210/wmi.h b/drivers/net/wireless/ath/wil6210/wmi.h
index 6e90e78f1554..29865e0b5203 100644
--- a/drivers/net/wireless/ath/wil6210/wmi.h
+++ b/drivers/net/wireless/ath/wil6210/wmi.h
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012-2015 Qualcomm Atheros, Inc.
- * Copyright (c) 2006-2012 Wilocity .
+ * Copyright (c) 2012-2016 Qualcomm Atheros, Inc.
+ * Copyright (c) 2006-2012 Wilocity
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -17,187 +17,197 @@
 
 /*
  * This file contains the definitions of the WMI protocol specified in the
- * Wireless Module Interface (WMI) for the Wilocity
- * MARLON 60 Gigabit wireless solution.
+ * Wireless Module Interface (WMI) for the Qualcomm
+ * 60 GHz wireless solution.
  * It includes definitions of all the commands and events.
  * Commands are messages from the host to the WM.
  * Events are messages from the WM to the host.
+ *
+ * This is an automatically generated file.
  */
 
 #ifndef __WILOCITY_WMI_H__
 #define __WILOCITY_WMI_H__
 
 /* General */
-#define WILOCITY_MAX_ASSOC_STA (8)
-#define WILOCITY_DEFAULT_ASSOC_STA (1)
-#define WMI_MAC_LEN             (6)
-#define WMI_PROX_RANGE_NUM      (3)
-#define WMI_MAX_LOSS_DMG_BEACONS        (32)
+#define WMI_MAX_ASSOC_STA               (8)
+#define WMI_DEFAULT_ASSOC_STA           (1)
+#define WMI_MAC_LEN                     (6)
+#define WMI_PROX_RANGE_NUM              (3)
+#define WMI_MAX_LOSS_DMG_BEACONS        (20)
+
+/* Mailbox interface
+ * used for commands and events
+ */
+enum wmi_mid {
+        MID_DEFAULT             = 0x00,
+        FIRST_DBG_MID_ID        = 0x10,
+        LAST_DBG_MID_ID         = 0xFE,
+        MID_BROADCAST           = 0xFF,
+};
+
+/* WMI_CMD_HDR */
+struct wmi_cmd_hdr {
+        u8 mid;
+        u8 reserved;
+        __le16 command_id;
+        __le32 fw_timestamp;
+} __packed;
 
 /* List of Commands */
 enum wmi_command_id {
-        WMI_CONNECT_CMDID               = 0x0001,
-        WMI_DISCONNECT_CMDID            = 0x0003,
-        WMI_DISCONNECT_STA_CMDID        = 0x0004,
-        WMI_START_SCAN_CMDID            = 0x0007,
-        WMI_SET_BSS_FILTER_CMDID        = 0x0009,
-        WMI_SET_PROBED_SSID_CMDID       = 0x000a,
-        WMI_SET_LISTEN_INT_CMDID        = 0x000b,
-        WMI_BCON_CTRL_CMDID             = 0x000f,
-        WMI_ADD_CIPHER_KEY_CMDID        = 0x0016,
-        WMI_DELETE_CIPHER_KEY_CMDID     = 0x0017,
-        WMI_SET_APPIE_CMDID             = 0x003f,
-        WMI_SET_WSC_STATUS_CMDID        = 0x0041,
-        WMI_PXMT_RANGE_CFG_CMDID        = 0x0042,
-        WMI_PXMT_SNR2_RANGE_CFG_CMDID   = 0x0043,
-/*      WMI_FAST_MEM_ACC_MODE_CMDID     = 0x0300, */
-        WMI_MEM_READ_CMDID              = 0x0800,
-        WMI_MEM_WR_CMDID                = 0x0801,
-        WMI_ECHO_CMDID                  = 0x0803,
-        WMI_DEEP_ECHO_CMDID             = 0x0804,
-        WMI_CONFIG_MAC_CMDID            = 0x0805,
-        WMI_CONFIG_PHY_DEBUG_CMDID      = 0x0806,
-        WMI_ADD_DEBUG_TX_PCKT_CMDID     = 0x0808,
-        WMI_PHY_GET_STATISTICS_CMDID    = 0x0809,
-        WMI_FS_TUNE_CMDID               = 0x080a,
-        WMI_CORR_MEASURE_CMDID          = 0x080b,
-        WMI_READ_RSSI_CMDID             = 0x080c,
-        WMI_TEMP_SENSE_CMDID            = 0x080e,
-        WMI_DC_CALIB_CMDID              = 0x080f,
-        WMI_SEND_TONE_CMDID             = 0x0810,
-        WMI_IQ_TX_CALIB_CMDID           = 0x0811,
-        WMI_IQ_RX_CALIB_CMDID           = 0x0812,
-        WMI_SET_UCODE_IDLE_CMDID        = 0x0813,
-        WMI_SET_WORK_MODE_CMDID         = 0x0815,
-        WMI_LO_LEAKAGE_CALIB_CMDID      = 0x0816,
-        WMI_MARLON_R_READ_CMDID         = 0x0818,
-        WMI_MARLON_R_WRITE_CMDID        = 0x0819,
-        WMI_MARLON_R_TXRX_SEL_CMDID     = 0x081a,
-        MAC_IO_STATIC_PARAMS_CMDID      = 0x081b,
-        MAC_IO_DYNAMIC_PARAMS_CMDID     = 0x081c,
-        WMI_SILENT_RSSI_CALIB_CMDID     = 0x081d,
-        WMI_RF_RX_TEST_CMDID            = 0x081e,
-        WMI_CFG_RX_CHAIN_CMDID          = 0x0820,
-        WMI_VRING_CFG_CMDID             = 0x0821,
-        WMI_BCAST_VRING_CFG_CMDID       = 0x0822,
-        WMI_VRING_BA_EN_CMDID           = 0x0823,
-        WMI_VRING_BA_DIS_CMDID          = 0x0824,
-        WMI_RCP_ADDBA_RESP_CMDID        = 0x0825,
-        WMI_RCP_DELBA_CMDID             = 0x0826,
-        WMI_SET_SSID_CMDID              = 0x0827,
-        WMI_GET_SSID_CMDID              = 0x0828,
-        WMI_SET_PCP_CHANNEL_CMDID       = 0x0829,
-        WMI_GET_PCP_CHANNEL_CMDID       = 0x082a,
-        WMI_SW_TX_REQ_CMDID             = 0x082b,
-        WMI_READ_MAC_RXQ_CMDID          = 0x0830,
-        WMI_READ_MAC_TXQ_CMDID          = 0x0831,
-        WMI_WRITE_MAC_RXQ_CMDID         = 0x0832,
-        WMI_WRITE_MAC_TXQ_CMDID         = 0x0833,
-        WMI_WRITE_MAC_XQ_FIELD_CMDID    = 0x0834,
-        WMI_MLME_PUSH_CMDID             = 0x0835,
-        WMI_BEAMFORMING_MGMT_CMDID      = 0x0836,
-        WMI_BF_TXSS_MGMT_CMDID          = 0x0837,
-        WMI_BF_SM_MGMT_CMDID            = 0x0838,
-        WMI_BF_RXSS_MGMT_CMDID          = 0x0839,
-        WMI_BF_TRIG_CMDID               = 0x083A,
-        WMI_SET_SECTORS_CMDID           = 0x0849,
-        WMI_MAINTAIN_PAUSE_CMDID        = 0x0850,
-        WMI_MAINTAIN_RESUME_CMDID       = 0x0851,
-        WMI_RS_MGMT_CMDID               = 0x0852,
-        WMI_RF_MGMT_CMDID               = 0x0853,
-        WMI_THERMAL_THROTTLING_CTRL_CMDID       = 0x0854,
-        WMI_THERMAL_THROTTLING_GET_STATUS_CMDID = 0x0855,
+        WMI_CONNECT_CMDID                       = 0x01,
+        WMI_DISCONNECT_CMDID                    = 0x03,
+        WMI_DISCONNECT_STA_CMDID                = 0x04,
+        WMI_START_SCAN_CMDID                    = 0x07,
+        WMI_SET_BSS_FILTER_CMDID                = 0x09,
+        WMI_SET_PROBED_SSID_CMDID               = 0x0A,
+        WMI_SET_LISTEN_INT_CMDID                = 0x0B,
+        WMI_BCON_CTRL_CMDID                     = 0x0F,
+        WMI_ADD_CIPHER_KEY_CMDID                = 0x16,
+        WMI_DELETE_CIPHER_KEY_CMDID             = 0x17,
+        WMI_PCP_CONF_CMDID                      = 0x18,
+        WMI_SET_APPIE_CMDID                     = 0x3F,
+        WMI_SET_WSC_STATUS_CMDID                = 0x41,
+        WMI_PXMT_RANGE_CFG_CMDID                = 0x42,
+        WMI_PXMT_SNR2_RANGE_CFG_CMDID           = 0x43,
+        WMI_MEM_READ_CMDID                      = 0x800,
+        WMI_MEM_WR_CMDID                        = 0x801,
+        WMI_ECHO_CMDID                          = 0x803,
+        WMI_DEEP_ECHO_CMDID                     = 0x804,
+        WMI_CONFIG_MAC_CMDID                    = 0x805,
+        WMI_CONFIG_PHY_DEBUG_CMDID              = 0x806,
+        WMI_ADD_DEBUG_TX_PCKT_CMDID             = 0x808,
+        WMI_PHY_GET_STATISTICS_CMDID            = 0x809,
+        WMI_FS_TUNE_CMDID                       = 0x80A,
+        WMI_CORR_MEASURE_CMDID                  = 0x80B,
+        WMI_READ_RSSI_CMDID                     = 0x80C,
+        WMI_TEMP_SENSE_CMDID                    = 0x80E,
+        WMI_DC_CALIB_CMDID                      = 0x80F,
+        WMI_SEND_TONE_CMDID                     = 0x810,
+        WMI_IQ_TX_CALIB_CMDID                   = 0x811,
+        WMI_IQ_RX_CALIB_CMDID                   = 0x812,
+        WMI_SET_UCODE_IDLE_CMDID                = 0x813,
+        WMI_SET_WORK_MODE_CMDID                 = 0x815,
+        WMI_LO_LEAKAGE_CALIB_CMDID              = 0x816,
+        WMI_MARLON_R_READ_CMDID                 = 0x818,
+        WMI_MARLON_R_WRITE_CMDID                = 0x819,
+        WMI_MARLON_R_TXRX_SEL_CMDID             = 0x81A,
+        MAC_IO_STATIC_PARAMS_CMDID              = 0x81B,
+        MAC_IO_DYNAMIC_PARAMS_CMDID             = 0x81C,
+        WMI_SILENT_RSSI_CALIB_CMDID             = 0x81D,
+        WMI_RF_RX_TEST_CMDID                    = 0x81E,
+        WMI_CFG_RX_CHAIN_CMDID                  = 0x820,
+        WMI_VRING_CFG_CMDID                     = 0x821,
+        WMI_BCAST_VRING_CFG_CMDID               = 0x822,
+        WMI_VRING_BA_EN_CMDID                   = 0x823,
+        WMI_VRING_BA_DIS_CMDID                  = 0x824,
+        WMI_RCP_ADDBA_RESP_CMDID                = 0x825,
+        WMI_RCP_DELBA_CMDID                     = 0x826,
+        WMI_SET_SSID_CMDID                      = 0x827,
+        WMI_GET_SSID_CMDID                      = 0x828,
+        WMI_SET_PCP_CHANNEL_CMDID               = 0x829,
+        WMI_GET_PCP_CHANNEL_CMDID               = 0x82A,
+        WMI_SW_TX_REQ_CMDID                     = 0x82B,
+        WMI_READ_MAC_RXQ_CMDID                  = 0x830,
+        WMI_READ_MAC_TXQ_CMDID                  = 0x831,
+        WMI_WRITE_MAC_RXQ_CMDID                 = 0x832,
+        WMI_WRITE_MAC_TXQ_CMDID                 = 0x833,
+        WMI_WRITE_MAC_XQ_FIELD_CMDID            = 0x834,
+        WMI_MLME_PUSH_CMDID                     = 0x835,
+        WMI_BEAMFORMING_MGMT_CMDID              = 0x836,
+        WMI_BF_TXSS_MGMT_CMDID                  = 0x837,
+        WMI_BF_SM_MGMT_CMDID                    = 0x838,
+        WMI_BF_RXSS_MGMT_CMDID                  = 0x839,
+        WMI_BF_TRIG_CMDID                       = 0x83A,
+        WMI_SET_SECTORS_CMDID                   = 0x849,
+        WMI_MAINTAIN_PAUSE_CMDID                = 0x850,
+        WMI_MAINTAIN_RESUME_CMDID               = 0x851,
+        WMI_RS_MGMT_CMDID                       = 0x852,
+        WMI_RF_MGMT_CMDID                       = 0x853,
+        WMI_THERMAL_THROTTLING_CTRL_CMDID       = 0x854,
+        WMI_THERMAL_THROTTLING_GET_STATUS_CMDID = 0x855,
+        WMI_OTP_READ_CMDID                      = 0x856,
+        WMI_OTP_WRITE_CMDID                     = 0x857,
         /* Performance monitoring commands */
-        WMI_BF_CTRL_CMDID               = 0x0862,
-        WMI_NOTIFY_REQ_CMDID            = 0x0863,
-        WMI_GET_STATUS_CMDID            = 0x0864,
-        WMI_UNIT_TEST_CMDID             = 0x0900,
-        WMI_HICCUP_CMDID                = 0x0901,
-        WMI_FLASH_READ_CMDID            = 0x0902,
-        WMI_FLASH_WRITE_CMDID           = 0x0903,
-        WMI_SECURITY_UNIT_TEST_CMDID    = 0x0904,
-        /*P2P*/
-        WMI_P2P_CFG_CMDID               = 0x0910,
-        WMI_PORT_ALLOCATE_CMDID         = 0x0911,
-        WMI_PORT_DELETE_CMDID           = 0x0912,
-        WMI_POWER_MGMT_CFG_CMDID        = 0x0913,
-        WMI_START_LISTEN_CMDID          = 0x0914,
-        WMI_START_SEARCH_CMDID          = 0x0915,
-        WMI_DISCOVERY_START_CMDID       = 0x0916,
-        WMI_DISCOVERY_STOP_CMDID        = 0x0917,
-        WMI_PCP_START_CMDID             = 0x0918,
-        WMI_PCP_STOP_CMDID              = 0x0919,
-        WMI_GET_PCP_FACTOR_CMDID        = 0x091b,
-
-        WMI_SET_MAC_ADDRESS_CMDID       = 0xf003,
-        WMI_ABORT_SCAN_CMDID            = 0xf007,
-        WMI_SET_PMK_CMDID               = 0xf028,
-
-        WMI_SET_PROMISCUOUS_MODE_CMDID  = 0xf041,
-        WMI_GET_PMK_CMDID               = 0xf048,
-        WMI_SET_PASSPHRASE_CMDID        = 0xf049,
-        WMI_SEND_ASSOC_RES_CMDID        = 0xf04a,
-        WMI_SET_ASSOC_REQ_RELAY_CMDID   = 0xf04b,
-        WMI_EAPOL_TX_CMDID              = 0xf04c,
-        WMI_MAC_ADDR_REQ_CMDID          = 0xf04d,
-        WMI_FW_VER_CMDID                = 0xf04e,
-        WMI_PMC_CMDID                   = 0xf04f,
+        WMI_BF_CTRL_CMDID                       = 0x862,
+        WMI_NOTIFY_REQ_CMDID                    = 0x863,
+        WMI_GET_STATUS_CMDID                    = 0x864,
+        WMI_UNIT_TEST_CMDID                     = 0x900,
+        WMI_HICCUP_CMDID                        = 0x901,
+        WMI_FLASH_READ_CMDID                    = 0x902,
+        WMI_FLASH_WRITE_CMDID                   = 0x903,
+        /* P2P */
+        WMI_P2P_CFG_CMDID                       = 0x910,
+        WMI_PORT_ALLOCATE_CMDID                 = 0x911,
+        WMI_PORT_DELETE_CMDID                   = 0x912,
+        WMI_POWER_MGMT_CFG_CMDID                = 0x913,
+        WMI_START_LISTEN_CMDID                  = 0x914,
+        WMI_START_SEARCH_CMDID                  = 0x915,
+        WMI_DISCOVERY_START_CMDID               = 0x916,
+        WMI_DISCOVERY_STOP_CMDID                = 0x917,
+        WMI_PCP_START_CMDID                     = 0x918,
+        WMI_PCP_STOP_CMDID                      = 0x919,
+        WMI_GET_PCP_FACTOR_CMDID                = 0x91B,
+        WMI_SET_MAC_ADDRESS_CMDID               = 0xF003,
+        WMI_ABORT_SCAN_CMDID                    = 0xF007,
+        WMI_SET_PROMISCUOUS_MODE_CMDID          = 0xF041,
+        WMI_GET_PMK_CMDID                       = 0xF048,
+        WMI_SET_PASSPHRASE_CMDID                = 0xF049,
+        WMI_SEND_ASSOC_RES_CMDID                = 0xF04A,
+        WMI_SET_ASSOC_REQ_RELAY_CMDID           = 0xF04B,
+        WMI_MAC_ADDR_REQ_CMDID                  = 0xF04D,
+        WMI_FW_VER_CMDID                        = 0xF04E,
+        WMI_PMC_CMDID                           = 0xF04F,
 };
 
-/*
- * Commands data structures
- */
-
-/*
- * WMI_CONNECT_CMDID
- */
+/* WMI_CONNECT_CMDID */
 enum wmi_network_type {
         WMI_NETTYPE_INFRA               = 0x01,
         WMI_NETTYPE_ADHOC               = 0x02,
         WMI_NETTYPE_ADHOC_CREATOR       = 0x04,
         WMI_NETTYPE_AP                  = 0x10,
         WMI_NETTYPE_P2P                 = 0x20,
-        WMI_NETTYPE_WBE                 = 0x40, /* PCIE over 60g */
+        /* PCIE over 60g */
+        WMI_NETTYPE_WBE                 = 0x40,
 };
 
 enum wmi_dot11_auth_mode {
-        WMI_AUTH11_OPEN                 = 0x01,
-        WMI_AUTH11_SHARED               = 0x02,
-        WMI_AUTH11_LEAP                 = 0x04,
-        WMI_AUTH11_WSC                  = 0x08,
+        WMI_AUTH11_OPEN         = 0x01,
+        WMI_AUTH11_SHARED       = 0x02,
+        WMI_AUTH11_LEAP         = 0x04,
+        WMI_AUTH11_WSC          = 0x08,
 };
 
 enum wmi_auth_mode {
-        WMI_AUTH_NONE                   = 0x01,
-        WMI_AUTH_WPA                    = 0x02,
-        WMI_AUTH_WPA2                   = 0x04,
-        WMI_AUTH_WPA_PSK                = 0x08,
-        WMI_AUTH_WPA2_PSK               = 0x10,
-        WMI_AUTH_WPA_CCKM               = 0x20,
-        WMI_AUTH_WPA2_CCKM              = 0x40,
+        WMI_AUTH_NONE           = 0x01,
+        WMI_AUTH_WPA            = 0x02,
+        WMI_AUTH_WPA2           = 0x04,
+        WMI_AUTH_WPA_PSK        = 0x08,
+        WMI_AUTH_WPA2_PSK       = 0x10,
+        WMI_AUTH_WPA_CCKM       = 0x20,
+        WMI_AUTH_WPA2_CCKM      = 0x40,
 };
 
 enum wmi_crypto_type {
-        WMI_CRYPT_NONE                  = 0x01,
-        WMI_CRYPT_WEP                   = 0x02,
-        WMI_CRYPT_TKIP                  = 0x04,
-        WMI_CRYPT_AES                   = 0x08,
-        WMI_CRYPT_AES_GCMP              = 0x20,
+        WMI_CRYPT_NONE          = 0x01,
+        WMI_CRYPT_AES_GCMP      = 0x20,
 };
 
 enum wmi_connect_ctrl_flag_bits {
-        WMI_CONNECT_ASSOC_POLICY_USER           = 0x0001,
-        WMI_CONNECT_SEND_REASSOC                = 0x0002,
-        WMI_CONNECT_IGNORE_WPA_GROUP_CIPHER     = 0x0004,
-        WMI_CONNECT_PROFILE_MATCH_DONE          = 0x0008,
-        WMI_CONNECT_IGNORE_AAC_BEACON           = 0x0010,
-        WMI_CONNECT_CSA_FOLLOW_BSS              = 0x0020,
-        WMI_CONNECT_DO_WPA_OFFLOAD              = 0x0040,
-        WMI_CONNECT_DO_NOT_DEAUTH               = 0x0080,
+        WMI_CONNECT_ASSOC_POLICY_USER           = 0x01,
+        WMI_CONNECT_SEND_REASSOC                = 0x02,
+        WMI_CONNECT_IGNORE_WPA_GROUP_CIPHER     = 0x04,
+        WMI_CONNECT_PROFILE_MATCH_DONE          = 0x08,
+        WMI_CONNECT_IGNORE_AAC_BEACON           = 0x10,
+        WMI_CONNECT_CSA_FOLLOW_BSS              = 0x20,
+        WMI_CONNECT_DO_WPA_OFFLOAD              = 0x40,
+        WMI_CONNECT_DO_NOT_DEAUTH               = 0x80,
 };
 
-#define WMI_MAX_SSID_LEN    (32)
+#define WMI_MAX_SSID_LEN        (32)
 
+/* WMI_CONNECT_CMDID */
 struct wmi_connect_cmd {
         u8 network_type;
         u8 dot11_auth_mode;
@@ -216,31 +226,17 @@ struct wmi_connect_cmd {
         u8 reserved1[2];
 } __packed;
 
-/*
- * WMI_DISCONNECT_STA_CMDID
- */
+/* WMI_DISCONNECT_STA_CMDID */
 struct wmi_disconnect_sta_cmd {
         u8 dst_mac[WMI_MAC_LEN];
         __le16 disconnect_reason;
 } __packed;
 
-/*
- * WMI_SET_PMK_CMDID
- */
-
-#define WMI_MIN_KEY_INDEX       (0)
 #define WMI_MAX_KEY_INDEX       (3)
 #define WMI_MAX_KEY_LEN         (32)
 #define WMI_PASSPHRASE_LEN      (64)
-#define WMI_PMK_LEN             (32)
-
-struct  wmi_set_pmk_cmd {
-        u8 pmk[WMI_PMK_LEN];
-} __packed;
 
-/*
- * WMI_SET_PASSPHRASE_CMDID
- */
+/* WMI_SET_PASSPHRASE_CMDID */
 struct wmi_set_passphrase_cmd {
         u8 ssid[WMI_MAX_SSID_LEN];
         u8 passphrase[WMI_PASSPHRASE_LEN];
@@ -248,36 +244,34 @@ struct wmi_set_passphrase_cmd {
         u8 passphrase_len;
 } __packed;
 
-/*
- * WMI_ADD_CIPHER_KEY_CMDID
- */
+/* WMI_ADD_CIPHER_KEY_CMDID */
 enum wmi_key_usage {
-        WMI_KEY_USE_PAIRWISE    = 0,
-        WMI_KEY_USE_RX_GROUP    = 1,
-        WMI_KEY_USE_TX_GROUP    = 2,
+        WMI_KEY_USE_PAIRWISE    = 0x00,
+        WMI_KEY_USE_RX_GROUP    = 0x01,
+        WMI_KEY_USE_TX_GROUP    = 0x02,
 };
 
 struct wmi_add_cipher_key_cmd {
         u8 key_index;
         u8 key_type;
-        u8 key_usage;           /* enum wmi_key_usage */
+        /* enum wmi_key_usage */
+        u8 key_usage;
         u8 key_len;
-        u8 key_rsc[8];          /* key replay sequence counter */
+        /* key replay sequence counter */
+        u8 key_rsc[8];
         u8 key[WMI_MAX_KEY_LEN];
-        u8 key_op_ctrl;         /* Additional Key Control information */
+        /* Additional Key Control information */
+        u8 key_op_ctrl;
         u8 mac[WMI_MAC_LEN];
 } __packed;
 
-/*
- * WMI_DELETE_CIPHER_KEY_CMDID
- */
+/* WMI_DELETE_CIPHER_KEY_CMDID */
 struct wmi_delete_cipher_key_cmd {
         u8 key_index;
         u8 mac[WMI_MAC_LEN];
 } __packed;
 
-/*
- * WMI_START_SCAN_CMDID
+/* WMI_START_SCAN_CMDID
  *
  * Start L1 scan operation
  *
@@ -286,146 +280,142 @@ struct wmi_delete_cipher_key_cmd {
  * - WMI_SCAN_COMPLETE_EVENTID
  */
 enum wmi_scan_type {
-        WMI_LONG_SCAN           = 0,
-        WMI_SHORT_SCAN          = 1,
-        WMI_PBC_SCAN            = 2,
-        WMI_DIRECT_SCAN         = 3,
-        WMI_ACTIVE_SCAN         = 4,
+        WMI_ACTIVE_SCAN         = 0x00,
+        WMI_SHORT_SCAN          = 0x01,
+        WMI_PASSIVE_SCAN        = 0x02,
+        WMI_DIRECT_SCAN         = 0x03,
+        WMI_LONG_SCAN           = 0x04,
 };
 
+/* WMI_START_SCAN_CMDID */
 struct wmi_start_scan_cmd {
-        u8 direct_scan_mac_addr[6];
-        u8 reserved[2];
-        __le32 home_dwell_time; /* Max duration in the home channel(ms) */
-        __le32 force_scan_interval;     /* Time interval between scans (ms)*/
-        u8 scan_type;           /* wmi_scan_type */
-        u8 num_channels;                /* how many channels follow */
+        u8 direct_scan_mac_addr[WMI_MAC_LEN];
+        /* DMG Beacon frame is transmitted during active scanning */
+        u8 discovery_mode;
+        /* reserved */
+        u8 reserved;
+        /* Max duration in the home channel(ms) */
+        __le32 dwell_time;
+        /* Time interval between scans (ms) */
+        __le32 force_scan_interval;
+        /* enum wmi_scan_type */
+        u8 scan_type;
+        /* how many channels follow */
+        u8 num_channels;
+        /* channels ID's:
+         * 0 - 58320 MHz
+         * 1 - 60480 MHz
+         * 2 - 62640 MHz
+         */
         struct {
                 u8 channel;
                 u8 reserved;
-        } channel_list[0];      /* channels ID's */
-                                /* 0 - 58320 MHz */
-                                /* 1 - 60480 MHz */
-                                /* 2 - 62640 MHz */
+        } channel_list[0];
 } __packed;
 
-/*
- * WMI_SET_PROBED_SSID_CMDID
- */
+/* WMI_SET_PROBED_SSID_CMDID */
 #define MAX_PROBED_SSID_INDEX   (3)
 
 enum wmi_ssid_flag {
-        WMI_SSID_FLAG_DISABLE   = 0,    /* disables entry */
-        WMI_SSID_FLAG_SPECIFIC  = 1,    /* probes specified ssid */
-        WMI_SSID_FLAG_ANY       = 2,    /* probes for any ssid */
+        /* disables entry */
+        WMI_SSID_FLAG_DISABLE   = 0x00,
+        /* probes specified ssid */
+        WMI_SSID_FLAG_SPECIFIC  = 0x01,
+        /* probes for any ssid */
+        WMI_SSID_FLAG_ANY       = 0x02,
 };
 
 struct wmi_probed_ssid_cmd {
-        u8 entry_index;                 /* 0 to MAX_PROBED_SSID_INDEX */
-        u8 flag;                        /* enum wmi_ssid_flag */
+        /* 0 to MAX_PROBED_SSID_INDEX */
+        u8 entry_index;
+        /* enum wmi_ssid_flag */
+        u8 flag;
         u8 ssid_len;
         u8 ssid[WMI_MAX_SSID_LEN];
 } __packed;
 
-/*
- * WMI_SET_APPIE_CMDID
+/* WMI_SET_APPIE_CMDID
  * Add Application specified IE to a management frame
  */
-#define WMI_MAX_IE_LEN          (1024)
+#define WMI_MAX_IE_LEN  (1024)
 
-/*
- * Frame Types
- */
+/* Frame Types */
 enum wmi_mgmt_frame_type {
-        WMI_FRAME_BEACON        = 0,
-        WMI_FRAME_PROBE_REQ     = 1,
-        WMI_FRAME_PROBE_RESP    = 2,
-        WMI_FRAME_ASSOC_REQ     = 3,
-        WMI_FRAME_ASSOC_RESP    = 4,
-        WMI_NUM_MGMT_FRAME,
+        WMI_FRAME_BEACON        = 0x00,
+        WMI_FRAME_PROBE_REQ     = 0x01,
+        WMI_FRAME_PROBE_RESP    = 0x02,
+        WMI_FRAME_ASSOC_REQ     = 0x03,
+        WMI_FRAME_ASSOC_RESP    = 0x04,
+        WMI_NUM_MGMT_FRAME      = 0x05,
 };
 
 struct wmi_set_appie_cmd {
-        u8 mgmt_frm_type;       /* enum wmi_mgmt_frame_type */
+        /* enum wmi_mgmt_frame_type */
+        u8 mgmt_frm_type;
         u8 reserved;
-        __le16 ie_len;  /* Length of the IE to be added to MGMT frame */
+        /* Length of the IE to be added to MGMT frame */
+        __le16 ie_len;
         u8 ie_info[0];
 } __packed;
 
-/*
- * WMI_PXMT_RANGE_CFG_CMDID
- */
+/* WMI_PXMT_RANGE_CFG_CMDID */
 struct wmi_pxmt_range_cfg_cmd {
         u8 dst_mac[WMI_MAC_LEN];
         __le16 range;
 } __packed;
 
-/*
- * WMI_PXMT_SNR2_RANGE_CFG_CMDID
- */
+/* WMI_PXMT_SNR2_RANGE_CFG_CMDID */
 struct wmi_pxmt_snr2_range_cfg_cmd {
-        s8 snr2range_arr[WMI_PROX_RANGE_NUM-1];
+        s8 snr2range_arr[2];
 } __packed;
 
-/*
- * WMI_RF_MGMT_CMDID
- */
+/* WMI_RF_MGMT_CMDID */
 enum wmi_rf_mgmt_type {
-        WMI_RF_MGMT_W_DISABLE   = 0,
-        WMI_RF_MGMT_W_ENABLE    = 1,
-        WMI_RF_MGMT_GET_STATUS  = 2,
+        WMI_RF_MGMT_W_DISABLE   = 0x00,
+        WMI_RF_MGMT_W_ENABLE    = 0x01,
+        WMI_RF_MGMT_GET_STATUS  = 0x02,
 };
 
+/* WMI_RF_MGMT_CMDID */
 struct wmi_rf_mgmt_cmd {
         __le32 rf_mgmt_type;
 } __packed;
 
-/*
- * WMI_THERMAL_THROTTLING_CTRL_CMDID
- */
+/* WMI_THERMAL_THROTTLING_CTRL_CMDID */
 #define THERMAL_THROTTLING_USE_DEFAULT_MAX_TXOP_LENGTH  (0xFFFFFFFF)
 
+/* WMI_THERMAL_THROTTLING_CTRL_CMDID */
 struct wmi_thermal_throttling_ctrl_cmd {
         __le32 time_on_usec;
         __le32 time_off_usec;
         __le32 max_txop_length_usec;
 } __packed;
 
-/*
- * WMI_RF_RX_TEST_CMDID
- */
+/* WMI_RF_RX_TEST_CMDID */
 struct wmi_rf_rx_test_cmd {
         __le32 sector;
 } __packed;
 
-/*
- * WMI_CORR_MEASURE_CMDID
- */
+/* WMI_CORR_MEASURE_CMDID */
 struct wmi_corr_measure_cmd {
-        s32 freq_mhz;
+        __le32 freq_mhz;
         __le32 length_samples;
         __le32 iterations;
 } __packed;
 
-/*
- * WMI_SET_SSID_CMDID
- */
+/* WMI_SET_SSID_CMDID */
 struct wmi_set_ssid_cmd {
         __le32 ssid_len;
         u8 ssid[WMI_MAX_SSID_LEN];
 } __packed;
 
-/*
- * WMI_SET_PCP_CHANNEL_CMDID
- */
+/* WMI_SET_PCP_CHANNEL_CMDID */
 struct wmi_set_pcp_channel_cmd {
         u8 channel;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_BCON_CTRL_CMDID
- */
+/* WMI_BCON_CTRL_CMDID */
 struct wmi_bcon_ctrl_cmd {
         __le16 bcon_interval;
         __le16 frag_num;
@@ -434,214 +424,192 @@ struct wmi_bcon_ctrl_cmd {
         u8 pcp_max_assoc_sta;
         u8 disable_sec_offload;
         u8 disable_sec;
+        u8 hidden_ssid;
+        u8 is_go;
+        u8 reserved[2];
 } __packed;
 
-/******* P2P ***********/
-
-/*
- * WMI_PORT_ALLOCATE_CMDID
- */
+/* WMI_PORT_ALLOCATE_CMDID */
 enum wmi_port_role {
-        WMI_PORT_STA            = 0,
-        WMI_PORT_PCP            = 1,
-        WMI_PORT_AP             = 2,
-        WMI_PORT_P2P_DEV        = 3,
-        WMI_PORT_P2P_CLIENT     = 4,
-        WMI_PORT_P2P_GO         = 5,
+        WMI_PORT_STA            = 0x00,
+        WMI_PORT_PCP            = 0x01,
+        WMI_PORT_AP             = 0x02,
+        WMI_PORT_P2P_DEV        = 0x03,
+        WMI_PORT_P2P_CLIENT     = 0x04,
+        WMI_PORT_P2P_GO         = 0x05,
 };
 
+/* WMI_PORT_ALLOCATE_CMDID */
 struct wmi_port_allocate_cmd {
         u8 mac[WMI_MAC_LEN];
         u8 port_role;
         u8 mid;
 } __packed;
 
-/*
- * WMI_PORT_DELETE_CMDID
- */
-struct wmi_delete_port_cmd {
+/* WMI_PORT_DELETE_CMDID */
+struct wmi_port_delete_cmd {
         u8 mid;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_P2P_CFG_CMDID
- */
+/* WMI_P2P_CFG_CMDID */
 enum wmi_discovery_mode {
-        WMI_DISCOVERY_MODE_NON_OFFLOAD  = 0,
-        WMI_DISCOVERY_MODE_OFFLOAD      = 1,
-        WMI_DISCOVERY_MODE_PEER2PEER    = 2,
+        WMI_DISCOVERY_MODE_NON_OFFLOAD  = 0x00,
+        WMI_DISCOVERY_MODE_OFFLOAD      = 0x01,
+        WMI_DISCOVERY_MODE_PEER2PEER    = 0x02,
 };
 
 struct wmi_p2p_cfg_cmd {
-        u8 discovery_mode;      /* wmi_discovery_mode */
+        /* enum wmi_discovery_mode */
+        u8 discovery_mode;
         u8 channel;
-        __le16 bcon_interval; /* base to listen/search duration calculation */
+        /* base to listen/search duration calculation */
+        __le16 bcon_interval;
 } __packed;
 
-/*
- * WMI_POWER_MGMT_CFG_CMDID
- */
+/* WMI_POWER_MGMT_CFG_CMDID */
 enum wmi_power_source_type {
-        WMI_POWER_SOURCE_BATTERY        = 0,
-        WMI_POWER_SOURCE_OTHER          = 1,
+        WMI_POWER_SOURCE_BATTERY        = 0x00,
+        WMI_POWER_SOURCE_OTHER          = 0x01,
 };
 
 struct wmi_power_mgmt_cfg_cmd {
-        u8 power_source;        /* wmi_power_source_type */
+        /* enum wmi_power_source_type */
+        u8 power_source;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_PCP_START_CMDID
- */
-
-enum wmi_hidden_ssid {
-        WMI_HIDDEN_SSID_DISABLED        = 0,
-        WMI_HIDDEN_SSID_SEND_EMPTY      = 1,
-        WMI_HIDDEN_SSID_CLEAR   = 2,
-};
-
+/* WMI_PCP_START_CMDID */
 struct wmi_pcp_start_cmd {
         __le16 bcon_interval;
         u8 pcp_max_assoc_sta;
         u8 hidden_ssid;
-        u8 reserved0[8];
+        u8 is_go;
+        u8 reserved0[7];
         u8 network_type;
         u8 channel;
         u8 disable_sec_offload;
         u8 disable_sec;
 } __packed;
 
-/*
- * WMI_SW_TX_REQ_CMDID
- */
+/* WMI_SW_TX_REQ_CMDID */
 struct wmi_sw_tx_req_cmd {
         u8 dst_mac[WMI_MAC_LEN];
         __le16 len;
         u8 payload[0];
 } __packed;
 
-/*
- * WMI_VRING_CFG_CMDID
- */
-
 struct wmi_sw_ring_cfg {
         __le64 ring_mem_base;
         __le16 ring_size;
         __le16 max_mpdu_size;
 } __packed;
 
+/* wmi_vring_cfg_schd */
 struct wmi_vring_cfg_schd {
         __le16 priority;
         __le16 timeslot_us;
 } __packed;
 
 enum wmi_vring_cfg_encap_trans_type {
-        WMI_VRING_ENC_TYPE_802_3                = 0,
-        WMI_VRING_ENC_TYPE_NATIVE_WIFI          = 1,
+        WMI_VRING_ENC_TYPE_802_3        = 0x00,
+        WMI_VRING_ENC_TYPE_NATIVE_WIFI  = 0x01,
 };
 
 enum wmi_vring_cfg_ds_cfg {
-        WMI_VRING_DS_PBSS                       = 0,
-        WMI_VRING_DS_STATION                    = 1,
-        WMI_VRING_DS_AP                         = 2,
-        WMI_VRING_DS_ADDR4                      = 3,
+        WMI_VRING_DS_PBSS       = 0x00,
+        WMI_VRING_DS_STATION    = 0x01,
+        WMI_VRING_DS_AP         = 0x02,
+        WMI_VRING_DS_ADDR4      = 0x03,
 };
 
 enum wmi_vring_cfg_nwifi_ds_trans_type {
-        WMI_NWIFI_TX_TRANS_MODE_NO              = 0,
-        WMI_NWIFI_TX_TRANS_MODE_AP2PBSS         = 1,
-        WMI_NWIFI_TX_TRANS_MODE_STA2PBSS        = 2,
+        WMI_NWIFI_TX_TRANS_MODE_NO              = 0x00,
+        WMI_NWIFI_TX_TRANS_MODE_AP2PBSS         = 0x01,
+        WMI_NWIFI_TX_TRANS_MODE_STA2PBSS        = 0x02,
 };
 
 enum wmi_vring_cfg_schd_params_priority {
-        WMI_SCH_PRIO_REGULAR                    = 0,
-        WMI_SCH_PRIO_HIGH                       = 1,
+        WMI_SCH_PRIO_REGULAR    = 0x00,
+        WMI_SCH_PRIO_HIGH       = 0x01,
 };
 
-#define CIDXTID_CID_POS (0)
-#define CIDXTID_CID_LEN (4)
-#define CIDXTID_CID_MSK (0xF)
-#define CIDXTID_TID_POS (4)
-#define CIDXTID_TID_LEN (4)
-#define CIDXTID_TID_MSK (0xF0)
+#define CIDXTID_CID_POS                         (0)
+#define CIDXTID_CID_LEN                         (4)
+#define CIDXTID_CID_MSK                         (0xF)
+#define CIDXTID_TID_POS                         (4)
+#define CIDXTID_TID_LEN                         (4)
+#define CIDXTID_TID_MSK                         (0xF0)
+#define VRING_CFG_MAC_CTRL_LIFETIME_EN_POS      (0)
+#define VRING_CFG_MAC_CTRL_LIFETIME_EN_LEN      (1)
+#define VRING_CFG_MAC_CTRL_LIFETIME_EN_MSK      (0x1)
+#define VRING_CFG_MAC_CTRL_AGGR_EN_POS          (1)
+#define VRING_CFG_MAC_CTRL_AGGR_EN_LEN          (1)
+#define VRING_CFG_MAC_CTRL_AGGR_EN_MSK          (0x2)
+#define VRING_CFG_TO_RESOLUTION_VALUE_POS       (0)
+#define VRING_CFG_TO_RESOLUTION_VALUE_LEN       (6)
+#define VRING_CFG_TO_RESOLUTION_VALUE_MSK       (0x3F)
 
 struct wmi_vring_cfg {
         struct wmi_sw_ring_cfg tx_sw_ring;
-        u8 ringid;                              /* 0-23 vrings */
-
+        /* 0-23 vrings */
+        u8 ringid;
         u8 cidxtid;
-
         u8 encap_trans_type;
-        u8 ds_cfg;                              /* 802.3 DS cfg */
+        /* 802.3 DS cfg */
+        u8 ds_cfg;
         u8 nwifi_ds_trans_type;
-
-        #define VRING_CFG_MAC_CTRL_LIFETIME_EN_POS (0)
-        #define VRING_CFG_MAC_CTRL_LIFETIME_EN_LEN (1)
-        #define VRING_CFG_MAC_CTRL_LIFETIME_EN_MSK (0x1)
-        #define VRING_CFG_MAC_CTRL_AGGR_EN_POS (1)
-        #define VRING_CFG_MAC_CTRL_AGGR_EN_LEN (1)
-        #define VRING_CFG_MAC_CTRL_AGGR_EN_MSK (0x2)
         u8 mac_ctrl;
-
-        #define VRING_CFG_TO_RESOLUTION_VALUE_POS (0)
-        #define VRING_CFG_TO_RESOLUTION_VALUE_LEN (6)
-        #define VRING_CFG_TO_RESOLUTION_VALUE_MSK (0x3F)
         u8 to_resolution;
         u8 agg_max_wsize;
         struct wmi_vring_cfg_schd schd_params;
 } __packed;
 
 enum wmi_vring_cfg_cmd_action {
-        WMI_VRING_CMD_ADD                       = 0,
-        WMI_VRING_CMD_MODIFY                    = 1,
-        WMI_VRING_CMD_DELETE                    = 2,
+        WMI_VRING_CMD_ADD       = 0x00,
+        WMI_VRING_CMD_MODIFY    = 0x01,
+        WMI_VRING_CMD_DELETE    = 0x02,
 };
 
+/* WMI_VRING_CFG_CMDID */
 struct wmi_vring_cfg_cmd {
         __le32 action;
         struct wmi_vring_cfg vring_cfg;
 } __packed;
 
-/*
- * WMI_BCAST_VRING_CFG_CMDID
- */
 struct wmi_bcast_vring_cfg {
         struct wmi_sw_ring_cfg tx_sw_ring;
-        u8 ringid;                              /* 0-23 vrings */
+        /* 0-23 vrings */
+        u8 ringid;
         u8 encap_trans_type;
-        u8 ds_cfg;                              /* 802.3 DS cfg */
+        /* 802.3 DS cfg */
+        u8 ds_cfg;
         u8 nwifi_ds_trans_type;
 } __packed;
 
+/* WMI_BCAST_VRING_CFG_CMDID */
 struct wmi_bcast_vring_cfg_cmd {
         __le32 action;
         struct wmi_bcast_vring_cfg vring_cfg;
 } __packed;
 
-/*
- * WMI_VRING_BA_EN_CMDID
- */
+/* WMI_VRING_BA_EN_CMDID */
 struct wmi_vring_ba_en_cmd {
         u8 ringid;
         u8 agg_max_wsize;
         __le16 ba_timeout;
         u8 amsdu;
+        u8 reserved[3];
 } __packed;
 
-/*
- * WMI_VRING_BA_DIS_CMDID
- */
+/* WMI_VRING_BA_DIS_CMDID */
 struct wmi_vring_ba_dis_cmd {
         u8 ringid;
         u8 reserved;
         __le16 reason;
 } __packed;
 
-/*
- * WMI_NOTIFY_REQ_CMDID
- */
+/* WMI_NOTIFY_REQ_CMDID */
 struct wmi_notify_req_cmd {
         u8 cid;
         u8 year;
@@ -654,102 +622,100 @@ struct wmi_notify_req_cmd {
         u8 miliseconds;
 } __packed;
 
-/*
- * WMI_CFG_RX_CHAIN_CMDID
- */
+/* WMI_CFG_RX_CHAIN_CMDID */
 enum wmi_sniffer_cfg_mode {
-        WMI_SNIFFER_OFF                         = 0,
-        WMI_SNIFFER_ON                          = 1,
+        WMI_SNIFFER_OFF = 0x00,
+        WMI_SNIFFER_ON  = 0x01,
 };
 
 enum wmi_sniffer_cfg_phy_info_mode {
-        WMI_SNIFFER_PHY_INFO_DISABLED           = 0,
-        WMI_SNIFFER_PHY_INFO_ENABLED            = 1,
+        WMI_SNIFFER_PHY_INFO_DISABLED   = 0x00,
+        WMI_SNIFFER_PHY_INFO_ENABLED    = 0x01,
 };
 
 enum wmi_sniffer_cfg_phy_support {
-        WMI_SNIFFER_CP                          = 0,
-        WMI_SNIFFER_DP                          = 1,
-        WMI_SNIFFER_BOTH_PHYS                   = 2,
+        WMI_SNIFFER_CP          = 0x00,
+        WMI_SNIFFER_DP          = 0x01,
+        WMI_SNIFFER_BOTH_PHYS   = 0x02,
 };
 
+/* wmi_sniffer_cfg */
 struct wmi_sniffer_cfg {
-        __le32 mode;            /* enum wmi_sniffer_cfg_mode */
-        __le32 phy_info_mode;   /* enum wmi_sniffer_cfg_phy_info_mode */
-        __le32 phy_support;     /* enum wmi_sniffer_cfg_phy_support */
+        /* enum wmi_sniffer_cfg_mode */
+        __le32 mode;
+        /* enum wmi_sniffer_cfg_phy_info_mode */
+        __le32 phy_info_mode;
+        /* enum wmi_sniffer_cfg_phy_support */
+        __le32 phy_support;
         u8 channel;
         u8 reserved[3];
 } __packed;
 
 enum wmi_cfg_rx_chain_cmd_action {
-        WMI_RX_CHAIN_ADD                        = 0,
-        WMI_RX_CHAIN_DEL                        = 1,
+        WMI_RX_CHAIN_ADD        = 0x00,
+        WMI_RX_CHAIN_DEL        = 0x01,
 };
 
 enum wmi_cfg_rx_chain_cmd_decap_trans_type {
-        WMI_DECAP_TYPE_802_3                    = 0,
-        WMI_DECAP_TYPE_NATIVE_WIFI              = 1,
-        WMI_DECAP_TYPE_NONE                     = 2,
+        WMI_DECAP_TYPE_802_3            = 0x00,
+        WMI_DECAP_TYPE_NATIVE_WIFI      = 0x01,
+        WMI_DECAP_TYPE_NONE             = 0x02,
 };
 
 enum wmi_cfg_rx_chain_cmd_nwifi_ds_trans_type {
-        WMI_NWIFI_RX_TRANS_MODE_NO              = 0,
-        WMI_NWIFI_RX_TRANS_MODE_PBSS2AP         = 1,
-        WMI_NWIFI_RX_TRANS_MODE_PBSS2STA        = 2,
+        WMI_NWIFI_RX_TRANS_MODE_NO              = 0x00,
+        WMI_NWIFI_RX_TRANS_MODE_PBSS2AP         = 0x01,
+        WMI_NWIFI_RX_TRANS_MODE_PBSS2STA        = 0x02,
 };
 
 enum wmi_cfg_rx_chain_cmd_reorder_type {
-        WMI_RX_HW_REORDER = 0,
-        WMI_RX_SW_REORDER = 1,
+        WMI_RX_HW_REORDER       = 0x00,
+        WMI_RX_SW_REORDER       = 0x01,
 };
 
+#define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_POS    (0)
+#define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_LEN    (1)
+#define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_MSK    (0x1)
+#define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_POS             (1)
+#define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_LEN             (1)
+#define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_MSK             (0x2)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_POS            (0)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_LEN            (1)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_MSK            (0x1)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_POS             (1)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_LEN             (1)
+#define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_MSK             (0x2)
+#define L3_L4_CTRL_IPV4_CHECKSUM_EN_POS                 (0)
+#define L3_L4_CTRL_IPV4_CHECKSUM_EN_LEN                 (1)
+#define L3_L4_CTRL_IPV4_CHECKSUM_EN_MSK                 (0x1)
+#define L3_L4_CTRL_TCPIP_CHECKSUM_EN_POS                (1)
+#define L3_L4_CTRL_TCPIP_CHECKSUM_EN_LEN                (1)
+#define L3_L4_CTRL_TCPIP_CHECKSUM_EN_MSK                (0x2)
+#define RING_CTRL_OVERRIDE_PREFETCH_THRSH_POS           (0)
+#define RING_CTRL_OVERRIDE_PREFETCH_THRSH_LEN           (1)
+#define RING_CTRL_OVERRIDE_PREFETCH_THRSH_MSK           (0x1)
+#define RING_CTRL_OVERRIDE_WB_THRSH_POS                 (1)
+#define RING_CTRL_OVERRIDE_WB_THRSH_LEN                 (1)
+#define RING_CTRL_OVERRIDE_WB_THRSH_MSK                 (0x2)
+#define RING_CTRL_OVERRIDE_ITR_THRSH_POS                (2)
+#define RING_CTRL_OVERRIDE_ITR_THRSH_LEN                (1)
+#define RING_CTRL_OVERRIDE_ITR_THRSH_MSK                (0x4)
+#define RING_CTRL_OVERRIDE_HOST_THRSH_POS               (3)
+#define RING_CTRL_OVERRIDE_HOST_THRSH_LEN               (1)
+#define RING_CTRL_OVERRIDE_HOST_THRSH_MSK               (0x8)
+
+/* WMI_CFG_RX_CHAIN_CMDID */
 struct wmi_cfg_rx_chain_cmd {
         __le32 action;
         struct wmi_sw_ring_cfg rx_sw_ring;
         u8 mid;
         u8 decap_trans_type;
-
-        #define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_POS (0)
-        #define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_LEN (1)
-        #define L2_802_3_OFFLOAD_CTRL_VLAN_TAG_INSERTION_MSK (0x1)
-        #define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_POS (1)
-        #define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_LEN (1)
-        #define L2_802_3_OFFLOAD_CTRL_SNAP_KEEP_MSK (0x2)
         u8 l2_802_3_offload_ctrl;
-
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_POS (0)
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_LEN (1)
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_QOS_MSK (0x1)
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_POS (1)
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_LEN (1)
-        #define L2_NWIFI_OFFLOAD_CTRL_REMOVE_PN_MSK (0x2)
         u8 l2_nwifi_offload_ctrl;
-
         u8 vlan_id;
         u8 nwifi_ds_trans_type;
-
-        #define L3_L4_CTRL_IPV4_CHECKSUM_EN_POS (0)
-        #define L3_L4_CTRL_IPV4_CHECKSUM_EN_LEN (1)
-        #define L3_L4_CTRL_IPV4_CHECKSUM_EN_MSK (0x1)
-        #define L3_L4_CTRL_TCPIP_CHECKSUM_EN_POS (1)
-        #define L3_L4_CTRL_TCPIP_CHECKSUM_EN_LEN (1)
-        #define L3_L4_CTRL_TCPIP_CHECKSUM_EN_MSK (0x2)
         u8 l3_l4_ctrl;
-
-        #define RING_CTRL_OVERRIDE_PREFETCH_THRSH_POS (0)
-        #define RING_CTRL_OVERRIDE_PREFETCH_THRSH_LEN (1)
-        #define RING_CTRL_OVERRIDE_PREFETCH_THRSH_MSK (0x1)
-        #define RING_CTRL_OVERRIDE_WB_THRSH_POS (1)
-        #define RING_CTRL_OVERRIDE_WB_THRSH_LEN (1)
-        #define RING_CTRL_OVERRIDE_WB_THRSH_MSK (0x2)
-        #define RING_CTRL_OVERRIDE_ITR_THRSH_POS (2)
-        #define RING_CTRL_OVERRIDE_ITR_THRSH_LEN (1)
-        #define RING_CTRL_OVERRIDE_ITR_THRSH_MSK (0x4)
-        #define RING_CTRL_OVERRIDE_HOST_THRSH_POS (3)
-        #define RING_CTRL_OVERRIDE_HOST_THRSH_LEN (1)
-        #define RING_CTRL_OVERRIDE_HOST_THRSH_MSK (0x8)
         u8 ring_ctrl;
-
         __le16 prefetch_thrsh;
         __le16 wb_thrsh;
         __le32 itr_value;
@@ -757,31 +723,27 @@ struct wmi_cfg_rx_chain_cmd {
         u8 reorder_type;
         u8 reserved;
         struct wmi_sniffer_cfg sniffer_cfg;
+        __le16 max_rx_pl_per_desc;
 } __packed;
 
-/*
- * WMI_RCP_ADDBA_RESP_CMDID
- */
+/* WMI_RCP_ADDBA_RESP_CMDID */
 struct wmi_rcp_addba_resp_cmd {
         u8 cidxtid;
         u8 dialog_token;
         __le16 status_code;
-        __le16 ba_param_set;    /* ieee80211_ba_parameterset field to send */
+        /* ieee80211_ba_parameterset field to send */
+        __le16 ba_param_set;
         __le16 ba_timeout;
 } __packed;
 
-/*
- * WMI_RCP_DELBA_CMDID
- */
+/* WMI_RCP_DELBA_CMDID */
 struct wmi_rcp_delba_cmd {
         u8 cidxtid;
         u8 reserved;
         __le16 reason;
 } __packed;
 
-/*
- * WMI_RCP_ADDBA_REQ_CMDID
- */
+/* WMI_RCP_ADDBA_REQ_CMDID */
 struct wmi_rcp_addba_req_cmd {
         u8 cidxtid;
         u8 dialog_token;
@@ -792,32 +754,16 @@ struct wmi_rcp_addba_req_cmd {
         __le16 ba_seq_ctrl;
 } __packed;
 
-/*
- * WMI_SET_MAC_ADDRESS_CMDID
- */
+/* WMI_SET_MAC_ADDRESS_CMDID */
 struct wmi_set_mac_address_cmd {
         u8 mac[WMI_MAC_LEN];
         u8 reserved[2];
 } __packed;
 
-/*
-* WMI_EAPOL_TX_CMDID
-*/
-struct wmi_eapol_tx_cmd {
-        u8 dst_mac[WMI_MAC_LEN];
-        __le16 eapol_len;
-        u8 eapol[0];
-} __packed;
-
-/*
- * WMI_ECHO_CMDID
- *
+/* WMI_ECHO_CMDID
  * Check FW is alive
- *
  * WMI_DEEP_ECHO_CMDID
- *
  * Check FW and ucode are alive
- *
  * Returned event: WMI_ECHO_RSP_EVENTID
  * same event for both commands
  */
@@ -825,70 +771,79 @@ struct wmi_echo_cmd {
         __le32 value;
 } __packed;
 
-/*
- * WMI_TEMP_SENSE_CMDID
+/* WMI_OTP_READ_CMDID */
+struct wmi_otp_read_cmd {
+        __le32 addr;
+        __le32 size;
+        __le32 values;
+} __packed;
+
+/* WMI_OTP_WRITE_CMDID */
+struct wmi_otp_write_cmd {
+        __le32 addr;
+        __le32 size;
+        __le32 values;
+} __packed;
+
+/* WMI_TEMP_SENSE_CMDID
  *
  * Measure MAC and radio temperatures
+ *
+ * Possible modes for temperature measurement
  */
-
-/* Possible modes for temperature measurement */
 enum wmi_temperature_measure_mode {
-        TEMPERATURE_USE_OLD_VALUE       = 0x1,
-        TEMPERATURE_MEASURE_NOW         = 0x2,
+        TEMPERATURE_USE_OLD_VALUE       = 0x01,
+        TEMPERATURE_MEASURE_NOW         = 0x02,
 };
 
+/* WMI_TEMP_SENSE_CMDID */
 struct wmi_temp_sense_cmd {
         __le32 measure_baseband_en;
         __le32 measure_rf_en;
         __le32 measure_mode;
 } __packed;
 
-/*
- * WMI_PMC_CMDID
- */
-enum wmi_pmc_op_e {
-        WMI_PMC_ALLOCATE = 0,
-        WMI_PMC_RELEASE = 1,
+enum wmi_pmc_op {
+        WMI_PMC_ALLOCATE        = 0x00,
+        WMI_PMC_RELEASE         = 0x01,
 };
 
+/* WMI_PMC_CMDID */
 struct wmi_pmc_cmd {
-        u8 op;          /* enum wmi_pmc_cmd_op_type */
+        /* enum wmi_pmc_cmd_op_type */
+        u8 op;
         u8 reserved;
         __le16 ring_size;
         __le64 mem_base;
 } __packed;
 
-/*
- * WMI Events
- */
-
-/*
+/* WMI Events
  * List of Events (target to host)
  */
 enum wmi_event_id {
         WMI_READY_EVENTID                       = 0x1001,
         WMI_CONNECT_EVENTID                     = 0x1002,
         WMI_DISCONNECT_EVENTID                  = 0x1003,
-        WMI_SCAN_COMPLETE_EVENTID               = 0x100a,
-        WMI_REPORT_STATISTICS_EVENTID           = 0x100b,
+        WMI_SCAN_COMPLETE_EVENTID               = 0x100A,
+        WMI_REPORT_STATISTICS_EVENTID           = 0x100B,
         WMI_RD_MEM_RSP_EVENTID                  = 0x1800,
         WMI_FW_READY_EVENTID                    = 0x1801,
-        WMI_EXIT_FAST_MEM_ACC_MODE_EVENTID      = 0x0200,
+        WMI_EXIT_FAST_MEM_ACC_MODE_EVENTID      = 0x200,
         WMI_ECHO_RSP_EVENTID                    = 0x1803,
-        WMI_FS_TUNE_DONE_EVENTID                = 0x180a,
-        WMI_CORR_MEASURE_EVENTID                = 0x180b,
-        WMI_READ_RSSI_EVENTID                   = 0x180c,
-        WMI_TEMP_SENSE_DONE_EVENTID             = 0x180e,
-        WMI_DC_CALIB_DONE_EVENTID               = 0x180f,
+        WMI_FS_TUNE_DONE_EVENTID                = 0x180A,
+        WMI_CORR_MEASURE_EVENTID                = 0x180B,
+        WMI_READ_RSSI_EVENTID                   = 0x180C,
+        WMI_TEMP_SENSE_DONE_EVENTID             = 0x180E,
+        WMI_DC_CALIB_DONE_EVENTID               = 0x180F,
         WMI_IQ_TX_CALIB_DONE_EVENTID            = 0x1811,
         WMI_IQ_RX_CALIB_DONE_EVENTID            = 0x1812,
         WMI_SET_WORK_MODE_DONE_EVENTID          = 0x1815,
         WMI_LO_LEAKAGE_CALIB_DONE_EVENTID       = 0x1816,
         WMI_MARLON_R_READ_DONE_EVENTID          = 0x1818,
         WMI_MARLON_R_WRITE_DONE_EVENTID         = 0x1819,
-        WMI_MARLON_R_TXRX_SEL_DONE_EVENTID      = 0x181a,
-        WMI_SILENT_RSSI_CALIB_DONE_EVENTID      = 0x181d,
-        WMI_RF_RX_TEST_DONE_EVENTID             = 0x181e,
+        WMI_MARLON_R_TXRX_SEL_DONE_EVENTID      = 0x181A,
+        WMI_SILENT_RSSI_CALIB_DONE_EVENTID      = 0x181D,
+        WMI_RF_RX_TEST_DONE_EVENTID             = 0x181E,
         WMI_CFG_RX_CHAIN_DONE_EVENTID           = 0x1820,
         WMI_VRING_CFG_DONE_EVENTID              = 0x1821,
         WMI_BA_STATUS_EVENTID                   = 0x1823,
@@ -896,15 +851,13 @@ enum wmi_event_id {
         WMI_RCP_ADDBA_RESP_SENT_EVENTID         = 0x1825,
         WMI_DELBA_EVENTID                       = 0x1826,
         WMI_GET_SSID_EVENTID                    = 0x1828,
-        WMI_GET_PCP_CHANNEL_EVENTID             = 0x182a,
-        WMI_SW_TX_COMPLETE_EVENTID              = 0x182b,
-
+        WMI_GET_PCP_CHANNEL_EVENTID             = 0x182A,
+        WMI_SW_TX_COMPLETE_EVENTID              = 0x182B,
         WMI_READ_MAC_RXQ_EVENTID                = 0x1830,
         WMI_READ_MAC_TXQ_EVENTID                = 0x1831,
         WMI_WRITE_MAC_RXQ_EVENTID               = 0x1832,
         WMI_WRITE_MAC_TXQ_EVENTID               = 0x1833,
         WMI_WRITE_MAC_XQ_FIELD_EVENTID          = 0x1834,
-
         WMI_BEAMFORMING_MGMT_DONE_EVENTID       = 0x1836,
         WMI_BF_TXSS_MGMT_DONE_EVENTID           = 0x1837,
         WMI_BF_RXSS_MGMT_DONE_EVENTID           = 0x1839,
@@ -914,20 +867,18 @@ enum wmi_event_id {
         WMI_BF_SM_MGMT_DONE_EVENTID             = 0x1838,
         WMI_RX_MGMT_PACKET_EVENTID              = 0x1840,
         WMI_TX_MGMT_PACKET_EVENTID              = 0x1841,
-
+        WMI_OTP_READ_RESULT_EVENTID             = 0x1856,
         /* Performance monitoring events */
         WMI_DATA_PORT_OPEN_EVENTID              = 0x1860,
         WMI_WBE_LINK_DOWN_EVENTID               = 0x1861,
-
         WMI_BF_CTRL_DONE_EVENTID                = 0x1862,
         WMI_NOTIFY_REQ_DONE_EVENTID             = 0x1863,
         WMI_GET_STATUS_DONE_EVENTID             = 0x1864,
         WMI_VRING_EN_EVENTID                    = 0x1865,
-
         WMI_UNIT_TEST_EVENTID                   = 0x1900,
         WMI_FLASH_READ_DONE_EVENTID             = 0x1902,
         WMI_FLASH_WRITE_DONE_EVENTID            = 0x1903,
-        /*P2P*/
+        /* P2P */
         WMI_P2P_CFG_DONE_EVENTID                = 0x1910,
         WMI_PORT_ALLOCATED_EVENTID              = 0x1911,
         WMI_PORT_DELETED_EVENTID                = 0x1912,
@@ -937,49 +888,42 @@ enum wmi_event_id {
         WMI_DISCOVERY_STOPPED_EVENTID           = 0x1917,
         WMI_PCP_STARTED_EVENTID                 = 0x1918,
         WMI_PCP_STOPPED_EVENTID                 = 0x1919,
-        WMI_PCP_FACTOR_EVENTID                  = 0x191a,
+        WMI_PCP_FACTOR_EVENTID                  = 0x191A,
         WMI_SET_CHANNEL_EVENTID                 = 0x9000,
         WMI_ASSOC_REQ_EVENTID                   = 0x9001,
         WMI_EAPOL_RX_EVENTID                    = 0x9002,
         WMI_MAC_ADDR_RESP_EVENTID               = 0x9003,
         WMI_FW_VER_EVENTID                      = 0x9004,
+        WMI_ACS_PASSIVE_SCAN_COMPLETE_EVENTID   = 0x9005,
 };
 
-/*
- * Events data structures
- */
-
+/* Events data structures */
 enum wmi_fw_status {
-        WMI_FW_STATUS_SUCCESS,
-        WMI_FW_STATUS_FAILURE,
+        WMI_FW_STATUS_SUCCESS   = 0x00,
+        WMI_FW_STATUS_FAILURE   = 0x01,
 };
 
-/*
- * WMI_RF_MGMT_STATUS_EVENTID
- */
+/* WMI_RF_MGMT_STATUS_EVENTID */
 enum wmi_rf_status {
-        WMI_RF_ENABLED                  = 0,
-        WMI_RF_DISABLED_HW              = 1,
-        WMI_RF_DISABLED_SW              = 2,
-        WMI_RF_DISABLED_HW_SW           = 3,
+        WMI_RF_ENABLED          = 0x00,
+        WMI_RF_DISABLED_HW      = 0x01,
+        WMI_RF_DISABLED_SW      = 0x02,
+        WMI_RF_DISABLED_HW_SW   = 0x03,
 };
 
+/* WMI_RF_MGMT_STATUS_EVENTID */
 struct wmi_rf_mgmt_status_event {
         __le32 rf_status;
 } __packed;
 
-/*
- * WMI_THERMAL_THROTTLING_STATUS_EVENTID
- */
+/* WMI_THERMAL_THROTTLING_STATUS_EVENTID */
 struct wmi_thermal_throttling_status_event {
         __le32 time_on_usec;
         __le32 time_off_usec;
         __le32 max_txop_length_usec;
 } __packed;
 
-/*
- * WMI_GET_STATUS_DONE_EVENTID
- */
+/* WMI_GET_STATUS_DONE_EVENTID */
 struct wmi_get_status_done_event {
         __le32 is_associated;
         u8 cid;
@@ -995,9 +939,7 @@ struct wmi_get_status_done_event {
         __le32 is_secured;
 } __packed;
 
-/*
- * WMI_FW_VER_EVENTID
- */
+/* WMI_FW_VER_EVENTID */
 struct wmi_fw_ver_event {
         u8 major;
         u8 minor;
@@ -1005,9 +947,7 @@ struct wmi_fw_ver_event {
         __le16 build;
 } __packed;
 
-/*
-* WMI_MAC_ADDR_RESP_EVENTID
-*/
+/* WMI_MAC_ADDR_RESP_EVENTID */
 struct wmi_mac_addr_resp_event {
         u8 mac[WMI_MAC_LEN];
         u8 auth_mode;
@@ -1015,42 +955,38 @@ struct wmi_mac_addr_resp_event {
         __le32 offload_mode;
 } __packed;
 
-/*
-* WMI_EAPOL_RX_EVENTID
-*/
+/* WMI_EAPOL_RX_EVENTID */
 struct wmi_eapol_rx_event {
         u8 src_mac[WMI_MAC_LEN];
         __le16 eapol_len;
         u8 eapol[0];
 } __packed;
 
-/*
-* WMI_READY_EVENTID
-*/
+/* WMI_READY_EVENTID */
 enum wmi_phy_capability {
-        WMI_11A_CAPABILITY              = 1,
-        WMI_11G_CAPABILITY              = 2,
-        WMI_11AG_CAPABILITY             = 3,
-        WMI_11NA_CAPABILITY             = 4,
-        WMI_11NG_CAPABILITY             = 5,
-        WMI_11NAG_CAPABILITY            = 6,
-        WMI_11AD_CAPABILITY             = 7,
-        WMI_11N_CAPABILITY_OFFSET = WMI_11NA_CAPABILITY - WMI_11A_CAPABILITY,
+        WMI_11A_CAPABILITY              = 0x01,
+        WMI_11G_CAPABILITY              = 0x02,
+        WMI_11AG_CAPABILITY             = 0x03,
+        WMI_11NA_CAPABILITY             = 0x04,
+        WMI_11NG_CAPABILITY             = 0x05,
+        WMI_11NAG_CAPABILITY            = 0x06,
+        WMI_11AD_CAPABILITY             = 0x07,
+        WMI_11N_CAPABILITY_OFFSET       = 0x03,
 };
 
 struct wmi_ready_event {
         __le32 sw_version;
         __le32 abi_version;
         u8 mac[WMI_MAC_LEN];
-        u8 phy_capability;              /* enum wmi_phy_capability */
+        /* enum wmi_phy_capability */
+        u8 phy_capability;
         u8 numof_additional_mids;
 } __packed;
 
-/*
- * WMI_NOTIFY_REQ_DONE_EVENTID
- */
+/* WMI_NOTIFY_REQ_DONE_EVENTID */
 struct wmi_notify_req_done_event {
-        __le32 status; /* beamforming status, 0: fail; 1: OK; 2: retrying */
+        /* beamforming status, 0: fail; 1: OK; 2: retrying */
+        __le32 status;
         __le64 tsf;
         __le32 snr_val;
         __le32 tx_tpt;
@@ -1066,9 +1002,7 @@ struct wmi_notify_req_done_event {
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_CONNECT_EVENTID
- */
+/* WMI_CONNECT_EVENTID */
 struct wmi_connect_event {
         u8 channel;
         u8 reserved0;
@@ -1082,68 +1016,103 @@ struct wmi_connect_event {
         u8 assoc_resp_len;
         u8 cid;
         u8 reserved2[3];
+        /* not in use */
         u8 assoc_info[0];
 } __packed;
 
-/*
- * WMI_DISCONNECT_EVENTID
- */
+/* WMI_DISCONNECT_EVENTID */
 enum wmi_disconnect_reason {
-        WMI_DIS_REASON_NO_NETWORK_AVAIL         = 1,
-        WMI_DIS_REASON_LOST_LINK                = 2, /* bmiss */
-        WMI_DIS_REASON_DISCONNECT_CMD           = 3,
-        WMI_DIS_REASON_BSS_DISCONNECTED         = 4,
-        WMI_DIS_REASON_AUTH_FAILED              = 5,
-        WMI_DIS_REASON_ASSOC_FAILED             = 6,
-        WMI_DIS_REASON_NO_RESOURCES_AVAIL       = 7,
-        WMI_DIS_REASON_CSERV_DISCONNECT         = 8,
-        WMI_DIS_REASON_INVALID_PROFILE          = 10,
-        WMI_DIS_REASON_DOT11H_CHANNEL_SWITCH    = 11,
-        WMI_DIS_REASON_PROFILE_MISMATCH         = 12,
-        WMI_DIS_REASON_CONNECTION_EVICTED       = 13,
-        WMI_DIS_REASON_IBSS_MERGE               = 14,
+        WMI_DIS_REASON_NO_NETWORK_AVAIL         = 0x01,
+        /* bmiss */
+        WMI_DIS_REASON_LOST_LINK                = 0x02,
+        WMI_DIS_REASON_DISCONNECT_CMD           = 0x03,
+        WMI_DIS_REASON_BSS_DISCONNECTED         = 0x04,
+        WMI_DIS_REASON_AUTH_FAILED              = 0x05,
+        WMI_DIS_REASON_ASSOC_FAILED             = 0x06,
+        WMI_DIS_REASON_NO_RESOURCES_AVAIL       = 0x07,
+        WMI_DIS_REASON_CSERV_DISCONNECT         = 0x08,
+        WMI_DIS_REASON_INVALID_PROFILE          = 0x0A,
+        WMI_DIS_REASON_DOT11H_CHANNEL_SWITCH    = 0x0B,
+        WMI_DIS_REASON_PROFILE_MISMATCH         = 0x0C,
+        WMI_DIS_REASON_CONNECTION_EVICTED       = 0x0D,
+        WMI_DIS_REASON_IBSS_MERGE               = 0x0E,
 };
 
 struct wmi_disconnect_event {
-        __le16 protocol_reason_status;  /* reason code, see 802.11 spec. */
-        u8 bssid[WMI_MAC_LEN];          /* set if known */
-        u8 disconnect_reason;           /* see wmi_disconnect_reason */
-        u8 assoc_resp_len;      /* not used */
-        u8 assoc_info[0];       /* not used */
+        /* reason code, see 802.11 spec. */
+        __le16 protocol_reason_status;
+        /* set if known */
+        u8 bssid[WMI_MAC_LEN];
+        /* see enum wmi_disconnect_reason */
+        u8 disconnect_reason;
+        /* last assoc req may passed to host - not in used */
+        u8 assoc_resp_len;
+        /* last assoc req may passed to host - not in used */
+        u8 assoc_info[0];
 } __packed;
 
-/*
- * WMI_SCAN_COMPLETE_EVENTID
- */
+/* WMI_SCAN_COMPLETE_EVENTID */
 enum scan_status {
-        WMI_SCAN_SUCCESS        = 0,
-        WMI_SCAN_FAILED         = 1,
-        WMI_SCAN_ABORTED        = 2,
-        WMI_SCAN_REJECTED       = 3,
+        WMI_SCAN_SUCCESS        = 0x00,
+        WMI_SCAN_FAILED         = 0x01,
+        WMI_SCAN_ABORTED        = 0x02,
+        WMI_SCAN_REJECTED       = 0x03,
+        WMI_SCAN_ABORT_REJECTED = 0x04,
 };
 
 struct wmi_scan_complete_event {
-        __le32 status;  /* scan_status */
+        /* enum scan_status */
+        __le32 status;
 } __packed;
 
-/*
- * WMI_BA_STATUS_EVENTID
- */
+/* WMI_ACS_PASSIVE_SCAN_COMPLETE_EVENT */
+enum wmi_acs_info_bitmask {
+        WMI_ACS_INFO_BITMASK_BEACON_FOUND       = 0x01,
+        WMI_ACS_INFO_BITMASK_BUSY_TIME          = 0x02,
+        WMI_ACS_INFO_BITMASK_TX_TIME            = 0x04,
+        WMI_ACS_INFO_BITMASK_RX_TIME            = 0x08,
+        WMI_ACS_INFO_BITMASK_NOISE              = 0x10,
+};
+
+struct scan_acs_info {
+        u8 channel;
+        u8 beacon_found;
+        /* msec */
+        __le16 busy_time;
+        __le16 tx_time;
+        __le16 rx_time;
+        u8 noise;
+        u8 reserved[3];
+} __packed;
+
+struct wmi_acs_passive_scan_complete_event {
+        __le32 dwell_time;
+        /* valid fields within channel info according to
+         * their appearance in struct order
+         */
+        __le16 filled;
+        u8 num_scanned_channels;
+        u8 reserved;
+        struct scan_acs_info scan_info_list[0];
+} __packed;
+
+/* WMI_BA_STATUS_EVENTID */
 enum wmi_vring_ba_status {
-        WMI_BA_AGREED                   = 0,
-        WMI_BA_NON_AGREED               = 1,
+        WMI_BA_AGREED                   = 0x00,
+        WMI_BA_NON_AGREED               = 0x01,
         /* BA_EN in middle of teardown flow */
-        WMI_BA_TD_WIP                   = 2,
+        WMI_BA_TD_WIP                   = 0x02,
         /* BA_DIS or BA_EN in middle of BA SETUP flow */
-        WMI_BA_SETUP_WIP                = 3,
+        WMI_BA_SETUP_WIP                = 0x03,
         /* BA_EN when the BA session is already active */
-        WMI_BA_SESSION_ACTIVE           = 4,
+        WMI_BA_SESSION_ACTIVE           = 0x04,
         /* BA_DIS when the BA session is not active */
-        WMI_BA_SESSION_NOT_ACTIVE       = 5,
+        WMI_BA_SESSION_NOT_ACTIVE       = 0x05,
 };
 
-struct wmi_vring_ba_status_event {
-        __le16 status; /* enum wmi_vring_ba_status */
+struct wmi_ba_status_event {
+        /* enum wmi_vring_ba_status */
+        __le16 status;
         u8 reserved[2];
         u8 ringid;
         u8 agg_wsize;
@@ -1151,18 +1120,14 @@ struct wmi_vring_ba_status_event {
         u8 amsdu;
 } __packed;
 
-/*
- * WMI_DELBA_EVENTID
- */
+/* WMI_DELBA_EVENTID */
 struct wmi_delba_event {
         u8 cidxtid;
         u8 from_initiator;
         __le16 reason;
 } __packed;
 
-/*
- * WMI_VRING_CFG_DONE_EVENTID
- */
+/* WMI_VRING_CFG_DONE_EVENTID */
 struct wmi_vring_cfg_done_event {
         u8 ringid;
         u8 status;
@@ -1170,174 +1135,151 @@ struct wmi_vring_cfg_done_event {
         __le32 tx_vring_tail_ptr;
 } __packed;
 
-/*
- * WMI_RCP_ADDBA_RESP_SENT_EVENTID
- */
+/* WMI_RCP_ADDBA_RESP_SENT_EVENTID */
 struct wmi_rcp_addba_resp_sent_event {
         u8 cidxtid;
         u8 reserved;
         __le16 status;
 } __packed;
 
-/*
- * WMI_RCP_ADDBA_REQ_EVENTID
- */
+/* WMI_RCP_ADDBA_REQ_EVENTID */
 struct wmi_rcp_addba_req_event {
         u8 cidxtid;
         u8 dialog_token;
-        __le16 ba_param_set;    /* ieee80211_ba_parameterset as it received */
+        /* ieee80211_ba_parameterset as it received */
+        __le16 ba_param_set;
         __le16 ba_timeout;
-        __le16 ba_seq_ctrl;     /* ieee80211_ba_seqstrl field as it received */
+        /* ieee80211_ba_seqstrl field as it received */
+        __le16 ba_seq_ctrl;
 } __packed;
 
-/*
- * WMI_CFG_RX_CHAIN_DONE_EVENTID
- */
+/* WMI_CFG_RX_CHAIN_DONE_EVENTID */
 enum wmi_cfg_rx_chain_done_event_status {
-        WMI_CFG_RX_CHAIN_SUCCESS        = 1,
+        WMI_CFG_RX_CHAIN_SUCCESS        = 0x01,
 };
 
 struct wmi_cfg_rx_chain_done_event {
-        __le32 rx_ring_tail_ptr;        /* Rx V-Ring Tail pointer */
+        /* V-Ring Tail pointer */
+        __le32 rx_ring_tail_ptr;
         __le32 status;
 } __packed;
 
-/*
- * WMI_WBE_LINK_DOWN_EVENTID
- */
+/* WMI_WBE_LINK_DOWN_EVENTID */
 enum wmi_wbe_link_down_event_reason {
-        WMI_WBE_REASON_USER_REQUEST     = 0,
-        WMI_WBE_REASON_RX_DISASSOC      = 1,
-        WMI_WBE_REASON_BAD_PHY_LINK     = 2,
+        WMI_WBE_REASON_USER_REQUEST     = 0x00,
+        WMI_WBE_REASON_RX_DISASSOC      = 0x01,
+        WMI_WBE_REASON_BAD_PHY_LINK     = 0x02,
 };
 
+/* WMI_WBE_LINK_DOWN_EVENTID */
 struct wmi_wbe_link_down_event {
         u8 cid;
         u8 reserved[3];
         __le32 reason;
 } __packed;
 
-/*
- * WMI_DATA_PORT_OPEN_EVENTID
- */
+/* WMI_DATA_PORT_OPEN_EVENTID */
 struct wmi_data_port_open_event {
         u8 cid;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_VRING_EN_EVENTID
- */
+/* WMI_VRING_EN_EVENTID */
 struct wmi_vring_en_event {
         u8 vring_index;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_GET_PCP_CHANNEL_EVENTID
- */
+/* WMI_GET_PCP_CHANNEL_EVENTID */
 struct wmi_get_pcp_channel_event {
         u8 channel;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_P2P_CFG_DONE_EVENTID
- */
+/* WMI_P2P_CFG_DONE_EVENTID */
 struct wmi_p2p_cfg_done_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
-* WMI_PORT_ALLOCATED_EVENTID
-*/
+/* WMI_PORT_ALLOCATED_EVENTID */
 struct wmi_port_allocated_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
-* WMI_PORT_DELETED_EVENTID
-*/
+/* WMI_PORT_DELETED_EVENTID */
 struct wmi_port_deleted_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_LISTEN_STARTED_EVENTID
- */
+/* WMI_LISTEN_STARTED_EVENTID */
 struct wmi_listen_started_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_SEARCH_STARTED_EVENTID
- */
+/* WMI_SEARCH_STARTED_EVENTID */
 struct wmi_search_started_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_PCP_STARTED_EVENTID
- */
+/* WMI_PCP_STARTED_EVENTID */
 struct wmi_pcp_started_event {
-        u8 status;      /* wmi_fw_status */
+        /* wmi_fw_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_PCP_FACTOR_EVENTID
- */
+/* WMI_PCP_FACTOR_EVENTID */
 struct wmi_pcp_factor_event {
         __le32 pcp_factor;
 } __packed;
 
-/*
- * WMI_SW_TX_COMPLETE_EVENTID
- */
 enum wmi_sw_tx_status {
-        WMI_TX_SW_STATUS_SUCCESS                = 0,
-        WMI_TX_SW_STATUS_FAILED_NO_RESOURCES    = 1,
-        WMI_TX_SW_STATUS_FAILED_TX              = 2,
+        WMI_TX_SW_STATUS_SUCCESS                = 0x00,
+        WMI_TX_SW_STATUS_FAILED_NO_RESOURCES    = 0x01,
+        WMI_TX_SW_STATUS_FAILED_TX              = 0x02,
 };
 
+/* WMI_SW_TX_COMPLETE_EVENTID */
 struct wmi_sw_tx_complete_event {
-        u8 status;      /* enum wmi_sw_tx_status */
+        /* enum wmi_sw_tx_status */
+        u8 status;
         u8 reserved[3];
 } __packed;
 
-/*
- * WMI_CORR_MEASURE_EVENTID
- */
+/* WMI_CORR_MEASURE_EVENTID */
 struct wmi_corr_measure_event {
-        s32 i;
-        s32 q;
-        s32 image_i;
-        s32 image_q;
+        /* signed */
+        __le32 i;
+        /* signed */
+        __le32 q;
+        /* signed */
+        __le32 image_i;
+        /* signed */
+        __le32 image_q;
 } __packed;
 
-/*
- * WMI_READ_RSSI_EVENTID
- */
+/* WMI_READ_RSSI_EVENTID */
 struct wmi_read_rssi_event {
         __le32 ina_rssi_adc_dbm;
 } __packed;
 
-/*
- * WMI_GET_SSID_EVENTID
- */
+/* WMI_GET_SSID_EVENTID */
 struct wmi_get_ssid_event {
         __le32 ssid_len;
         u8 ssid[WMI_MAX_SSID_LEN];
 } __packed;
 
-/*
- * WMI_RX_MGMT_PACKET_EVENTID
- */
+/* wmi_rx_mgmt_info */
 struct wmi_rx_mgmt_info {
         u8 mcs;
         s8 snr;
@@ -1346,39 +1288,65 @@ struct wmi_rx_mgmt_info {
         __le16 stype;
         __le16 status;
         __le32 len;
+        /* Not resolved when == 0xFFFFFFFF  ==> Broadcast to all MIDS */
         u8 qid;
+        /* Not resolved when == 0xFFFFFFFF  ==> Broadcast to all MIDS */
         u8 mid;
         u8 cid;
-        u8 channel;     /* From Radio MNGR */
+        /* From Radio MNGR */
+        u8 channel;
 } __packed;
 
-/*
- * WMI_TX_MGMT_PACKET_EVENTID
- */
+/* wmi_otp_read_write_cmd */
+struct wmi_otp_read_write_cmd {
+        __le32 addr;
+        __le32 size;
+        u8 values[0];
+} __packed;
+
+/* WMI_OTP_READ_RESULT_EVENTID */
+struct wmi_otp_read_result_event {
+        u8 payload[0];
+} __packed;
+
+/* WMI_TX_MGMT_PACKET_EVENTID */
 struct wmi_tx_mgmt_packet_event {
         u8 payload[0];
 } __packed;
 
+/* WMI_RX_MGMT_PACKET_EVENTID */
 struct wmi_rx_mgmt_packet_event {
         struct wmi_rx_mgmt_info info;
         u8 payload[0];
 } __packed;
 
-/*
- * WMI_ECHO_RSP_EVENTID
- */
-struct wmi_echo_event {
+/* WMI_ECHO_RSP_EVENTID */
+struct wmi_echo_rsp_event {
         __le32 echoed_value;
 } __packed;
 
-/*
- * WMI_TEMP_SENSE_DONE_EVENTID
+/* WMI_TEMP_SENSE_DONE_EVENTID
  *
  * Measure MAC and radio temperatures
  */
 struct wmi_temp_sense_done_event {
+        /* Temperature times 1000 (actual temperature will be achieved by
+         * dividing the value by 1000)
+         */
         __le32 baseband_t1000;
+        /* Temperature times 1000 (actual temperature will be achieved by
+         * dividing the value by 1000)
+         */
         __le32 rf_t1000;
 } __packed;
 
+#define WMI_SCAN_DWELL_TIME_MS  (100)
+#define WMI_SURVEY_TIMEOUT_MS   (10000)
+
+enum wmi_hidden_ssid {
+        WMI_HIDDEN_SSID_DISABLED        = 0x00,
+        WMI_HIDDEN_SSID_SEND_EMPTY      = 0x10,
+        WMI_HIDDEN_SSID_CLEAR           = 0xFE,
+};
+
 #endif /* __WILOCITY_WMI_H__ */
diff --git a/drivers/net/wireless/atmel/at76c50x-usb.c b/drivers/net/wireless/atmel/at76c50x-usb.c
index 1efb1d66e0b7..7c108047fb46 100644
--- a/drivers/net/wireless/atmel/at76c50x-usb.c
+++ b/drivers/net/wireless/atmel/at76c50x-usb.c
@@ -1547,7 +1547,7 @@ static inline int at76_guess_freq(struct at76_priv *priv)
                 channel = el[2];
 
 exit:
-        return ieee80211_channel_to_frequency(channel, IEEE80211_BAND_2GHZ);
+        return ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
 }
 
 static void at76_rx_tasklet(unsigned long param)
@@ -1590,7 +1590,7 @@ static void at76_rx_tasklet(unsigned long param)
         rx_status.signal = buf->rssi;
         rx_status.flag |= RX_FLAG_DECRYPTED;
         rx_status.flag |= RX_FLAG_IV_STRIPPED;
-        rx_status.band = IEEE80211_BAND_2GHZ;
+        rx_status.band = NL80211_BAND_2GHZ;
         rx_status.freq = at76_guess_freq(priv);
 
         at76_dbg(DBG_MAC80211, "calling ieee80211_rx_irqsafe(): %d/%d",
@@ -2359,7 +2359,7 @@ static int at76_init_new_device(struct at76_priv *priv,
         priv->hw->wiphy->max_scan_ssids = 1;
         priv->hw->wiphy->max_scan_ie_len = 0;
         priv->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
-        priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &at76_supported_band;
+        priv->hw->wiphy->bands[NL80211_BAND_2GHZ] = &at76_supported_band;
         ieee80211_hw_set(priv->hw, RX_INCLUDES_FCS);
         ieee80211_hw_set(priv->hw, SIGNAL_UNSPEC);
         priv->hw->max_signal = 100;
diff --git a/drivers/net/wireless/atmel/atmel.c b/drivers/net/wireless/atmel/atmel.c
index 6a1f03c271c1..8f8f37f3a00c 100644
--- a/drivers/net/wireless/atmel/atmel.c
+++ b/drivers/net/wireless/atmel/atmel.c
@@ -2434,7 +2434,7 @@ static int atmel_get_range(struct net_device *dev,
 
                         /* Values in MHz -> * 10^5 * 10 */
                         range->freq[k].m = 100000 *
-                         ieee80211_channel_to_frequency(i, IEEE80211_BAND_2GHZ);
+                         ieee80211_channel_to_frequency(i, NL80211_BAND_2GHZ);
                         range->freq[k++].e = 1;
                 }
                 range->num_frequency = k;
diff --git a/drivers/net/wireless/broadcom/b43/b43.h b/drivers/net/wireless/broadcom/b43/b43.h
index 036552439816..d7d42f0b80c3 100644
--- a/drivers/net/wireless/broadcom/b43/b43.h
+++ b/drivers/net/wireless/broadcom/b43/b43.h
@@ -992,9 +992,9 @@ static inline int b43_is_mode(struct b43_wl *wl, int type)
 
 /**
  * b43_current_band - Returns the currently used band.
- * Returns one of IEEE80211_BAND_2GHZ and IEEE80211_BAND_5GHZ.
+ * Returns one of NL80211_BAND_2GHZ and NL80211_BAND_5GHZ.
  */
-static inline enum ieee80211_band b43_current_band(struct b43_wl *wl)
+static inline enum nl80211_band b43_current_band(struct b43_wl *wl)
 {
         return wl->hw->conf.chandef.chan->band;
 }
diff --git a/drivers/net/wireless/broadcom/b43/main.c b/drivers/net/wireless/broadcom/b43/main.c
index 72380af9dc52..4ee5c5853f9f 100644
--- a/drivers/net/wireless/broadcom/b43/main.c
+++ b/drivers/net/wireless/broadcom/b43/main.c
@@ -187,7 +187,7 @@ static struct ieee80211_rate __b43_ratetable[] = {
 #define b43_g_ratetable_size    12
 
 #define CHAN2G(_channel, _freq, _flags) {                       \
-        .band                   = IEEE80211_BAND_2GHZ,          \
+        .band                   = NL80211_BAND_2GHZ,            \
         .center_freq            = (_freq),                      \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -216,7 +216,7 @@ static struct ieee80211_channel b43_2ghz_chantable[] = {
 #undef CHAN2G
 
 #define CHAN4G(_channel, _flags) {                              \
-        .band                   = IEEE80211_BAND_5GHZ,          \
+        .band                   = NL80211_BAND_5GHZ,            \
         .center_freq            = 4000 + (5 * (_channel)),      \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -224,7 +224,7 @@ static struct ieee80211_channel b43_2ghz_chantable[] = {
         .max_power              = 30,                           \
 }
 #define CHAN5G(_channel, _flags) {                              \
-        .band                   = IEEE80211_BAND_5GHZ,          \
+        .band                   = NL80211_BAND_5GHZ,            \
         .center_freq            = 5000 + (5 * (_channel)),      \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -323,7 +323,7 @@ static struct ieee80211_channel b43_5ghz_aphy_chantable[] = {
 #undef CHAN5G
 
 static struct ieee80211_supported_band b43_band_5GHz_nphy = {
-        .band           = IEEE80211_BAND_5GHZ,
+        .band           = NL80211_BAND_5GHZ,
         .channels       = b43_5ghz_nphy_chantable,
         .n_channels     = ARRAY_SIZE(b43_5ghz_nphy_chantable),
         .bitrates       = b43_a_ratetable,
@@ -331,7 +331,7 @@ static struct ieee80211_supported_band b43_band_5GHz_nphy = {
 };
 
 static struct ieee80211_supported_band b43_band_5GHz_nphy_limited = {
-        .band           = IEEE80211_BAND_5GHZ,
+        .band           = NL80211_BAND_5GHZ,
         .channels       = b43_5ghz_nphy_chantable_limited,
         .n_channels     = ARRAY_SIZE(b43_5ghz_nphy_chantable_limited),
         .bitrates       = b43_a_ratetable,
@@ -339,7 +339,7 @@ static struct ieee80211_supported_band b43_band_5GHz_nphy_limited = {
 };
 
 static struct ieee80211_supported_band b43_band_5GHz_aphy = {
-        .band           = IEEE80211_BAND_5GHZ,
+        .band           = NL80211_BAND_5GHZ,
         .channels       = b43_5ghz_aphy_chantable,
         .n_channels     = ARRAY_SIZE(b43_5ghz_aphy_chantable),
         .bitrates       = b43_a_ratetable,
@@ -347,7 +347,7 @@ static struct ieee80211_supported_band b43_band_5GHz_aphy = {
 };
 
 static struct ieee80211_supported_band b43_band_2GHz = {
-        .band           = IEEE80211_BAND_2GHZ,
+        .band           = NL80211_BAND_2GHZ,
         .channels       = b43_2ghz_chantable,
         .n_channels     = ARRAY_SIZE(b43_2ghz_chantable),
         .bitrates       = b43_g_ratetable,
@@ -355,7 +355,7 @@ static struct ieee80211_supported_band b43_band_2GHz = {
 };
 
 static struct ieee80211_supported_band b43_band_2ghz_limited = {
-        .band           = IEEE80211_BAND_2GHZ,
+        .band           = NL80211_BAND_2GHZ,
         .channels       = b43_2ghz_chantable,
         .n_channels     = b43_2ghz_chantable_limited_size,
         .bitrates       = b43_g_ratetable,
@@ -717,7 +717,7 @@ static void b43_set_slot_time(struct b43_wldev *dev, u16 slot_time)
 {
         /* slot_time is in usec. */
         /* This test used to exit for all but a G PHY. */
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 return;
         b43_write16(dev, B43_MMIO_IFSSLOT, 510 + slot_time);
         /* Shared memory location 0x0010 is the slot time and should be
@@ -3880,12 +3880,12 @@ static void b43_op_set_tsf(struct ieee80211_hw *hw,
         mutex_unlock(&wl->mutex);
 }
 
-static const char *band_to_string(enum ieee80211_band band)
+static const char *band_to_string(enum nl80211_band band)
 {
         switch (band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 return "5";
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 return "2.4";
         default:
                 break;
@@ -3903,10 +3903,10 @@ static int b43_switch_band(struct b43_wldev *dev,
         u32 tmp;
 
         switch (chan->band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 gmode = false;
                 break;
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 gmode = true;
                 break;
         default:
@@ -5294,16 +5294,16 @@ static int b43_setup_bands(struct b43_wldev *dev,
                      phy->radio_rev == 9;
 
         if (have_2ghz_phy)
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = limited_2g ?
+                hw->wiphy->bands[NL80211_BAND_2GHZ] = limited_2g ?
                         &b43_band_2ghz_limited : &b43_band_2GHz;
         if (dev->phy.type == B43_PHYTYPE_N) {
                 if (have_5ghz_phy)
-                        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = limited_5g ?
+                        hw->wiphy->bands[NL80211_BAND_5GHZ] = limited_5g ?
                                 &b43_band_5GHz_nphy_limited :
                                 &b43_band_5GHz_nphy;
         } else {
                 if (have_5ghz_phy)
-                        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &b43_band_5GHz_aphy;
+                        hw->wiphy->bands[NL80211_BAND_5GHZ] = &b43_band_5GHz_aphy;
         }
 
         dev->phy.supports_2ghz = have_2ghz_phy;
@@ -5680,11 +5680,12 @@ static int b43_bcma_probe(struct bcma_device *core)
         INIT_WORK(&wl->firmware_load, b43_request_firmware);
         schedule_work(&wl->firmware_load);
 
-bcma_out:
         return err;
 
 bcma_err_wireless_exit:
         ieee80211_free_hw(wl->hw);
+bcma_out:
+        kfree(dev);
         return err;
 }
 
@@ -5712,8 +5713,8 @@ static void b43_bcma_remove(struct bcma_device *core)
         b43_rng_exit(wl);
 
         b43_leds_unregister(wl);
-
         ieee80211_free_hw(wl->hw);
+        kfree(wldev->dev);
 }
 
 static struct bcma_driver b43_bcma_driver = {
@@ -5796,6 +5797,7 @@ static void b43_ssb_remove(struct ssb_device *sdev)
 
         b43_leds_unregister(wl);
         b43_wireless_exit(dev, wl);
+        kfree(dev);
 }
 
 static struct ssb_driver b43_ssb_driver = {
diff --git a/drivers/net/wireless/broadcom/b43/phy_ac.c b/drivers/net/wireless/broadcom/b43/phy_ac.c
index e75633d67938..52f8abad8831 100644
--- a/drivers/net/wireless/broadcom/b43/phy_ac.c
+++ b/drivers/net/wireless/broadcom/b43/phy_ac.c
@@ -61,7 +61,7 @@ static void b43_phy_ac_op_radio_write(struct b43_wldev *dev, u16 reg,
 
 static unsigned int b43_phy_ac_op_get_default_chan(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 return 11;
         return 36;
 }
diff --git a/drivers/net/wireless/broadcom/b43/phy_common.c b/drivers/net/wireless/broadcom/b43/phy_common.c
index ec2b9c577b90..85f2ca989565 100644
--- a/drivers/net/wireless/broadcom/b43/phy_common.c
+++ b/drivers/net/wireless/broadcom/b43/phy_common.c
@@ -436,7 +436,7 @@ int b43_switch_channel(struct b43_wldev *dev, unsigned int new_channel)
          * firmware from sending ghost packets.
          */
         channelcookie = new_channel;
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 channelcookie |= B43_SHM_SH_CHAN_5GHZ;
         /* FIXME: set 40Mhz flag if required */
         if (0)
diff --git a/drivers/net/wireless/broadcom/b43/phy_ht.c b/drivers/net/wireless/broadcom/b43/phy_ht.c
index bd68945965d6..718c90e81696 100644
--- a/drivers/net/wireless/broadcom/b43/phy_ht.c
+++ b/drivers/net/wireless/broadcom/b43/phy_ht.c
@@ -568,7 +568,7 @@ static void b43_phy_ht_tx_power_ctl(struct b43_wldev *dev, bool enable)
         } else {
                 b43_phy_set(dev, B43_PHY_HT_TXPCTL_CMD_C1, en_bits);
 
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         for (i = 0; i < 3; i++)
                                 b43_phy_write(dev, cmd_regs[i], 0x32);
                 }
@@ -643,7 +643,7 @@ static void b43_phy_ht_tx_power_ctl_setup(struct b43_wldev *dev)
         u16 freq = dev->phy.chandef->chan->center_freq;
         int i, c;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 for (c = 0; c < 3; c++) {
                         target[c] = sprom->core_pwr_info[c].maxpwr_2g;
                         a1[c] = sprom->core_pwr_info[c].pa_2g[0];
@@ -777,7 +777,7 @@ static void b43_phy_ht_channel_setup(struct b43_wldev *dev,
                                 const struct b43_phy_ht_channeltab_e_phy *e,
                                 struct ieee80211_channel *new_channel)
 {
-        if (new_channel->band == IEEE80211_BAND_5GHZ) {
+        if (new_channel->band == NL80211_BAND_5GHZ) {
                 /* Switch to 2 GHz for a moment to access B-PHY regs */
                 b43_phy_mask(dev, B43_PHY_HT_BANDCTL, ~B43_PHY_HT_BANDCTL_5GHZ);
 
@@ -805,7 +805,7 @@ static void b43_phy_ht_channel_setup(struct b43_wldev *dev,
         } else {
                 b43_phy_ht_classifier(dev, B43_PHY_HT_CLASS_CTL_OFDM_EN,
                                       B43_PHY_HT_CLASS_CTL_OFDM_EN);
-                if (new_channel->band == IEEE80211_BAND_2GHZ)
+                if (new_channel->band == NL80211_BAND_2GHZ)
                         b43_phy_mask(dev, B43_PHY_HT_TEST, ~0x840);
         }
 
@@ -916,7 +916,7 @@ static int b43_phy_ht_op_init(struct b43_wldev *dev)
         if (0) /* TODO: condition */
                 ; /* TODO: PHY op on reg 0x217 */
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 b43_phy_ht_classifier(dev, B43_PHY_HT_CLASS_CTL_CCK_EN, 0);
         else
                 b43_phy_ht_classifier(dev, B43_PHY_HT_CLASS_CTL_CCK_EN,
@@ -1005,7 +1005,7 @@ static int b43_phy_ht_op_init(struct b43_wldev *dev)
         b43_phy_ht_classifier(dev, 0, 0);
         b43_phy_ht_read_clip_detection(dev, clip_state);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 b43_phy_ht_bphy_init(dev);
 
         b43_httab_write_bulk(dev, B43_HTTAB32(0x1a, 0xc0),
@@ -1077,7 +1077,7 @@ static int b43_phy_ht_op_switch_channel(struct b43_wldev *dev,
         enum nl80211_channel_type channel_type =
                 cfg80211_get_chandef_type(&dev->wl->hw->conf.chandef);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if ((new_channel < 1) || (new_channel > 14))
                         return -EINVAL;
         } else {
@@ -1089,7 +1089,7 @@ static int b43_phy_ht_op_switch_channel(struct b43_wldev *dev,
 
 static unsigned int b43_phy_ht_op_get_default_chan(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 return 11;
         return 36;
 }
diff --git a/drivers/net/wireless/broadcom/b43/phy_lcn.c b/drivers/net/wireless/broadcom/b43/phy_lcn.c
index 97461ccf3e1e..63bd29f070f7 100644
--- a/drivers/net/wireless/broadcom/b43/phy_lcn.c
+++ b/drivers/net/wireless/broadcom/b43/phy_lcn.c
@@ -108,7 +108,7 @@ static void b43_radio_2064_channel_setup(struct b43_wldev *dev)
 /* wlc_radio_2064_init */
 static void b43_radio_2064_init(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_radio_write(dev, 0x09c, 0x0020);
                 b43_radio_write(dev, 0x105, 0x0008);
         } else {
@@ -535,7 +535,7 @@ static void b43_phy_lcn_tx_pwr_ctl_init(struct b43_wldev *dev)
         b43_mac_suspend(dev);
 
         if (!dev->phy.lcn->hw_pwr_ctl_capable) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         tx_gains.gm_gain = 4;
                         tx_gains.pga_gain = 12;
                         tx_gains.pad_gain = 12;
@@ -720,7 +720,7 @@ static int b43_phy_lcn_op_init(struct b43_wldev *dev)
         else
                 B43_WARN_ON(1);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 b43_phy_lcn_tx_pwr_ctl_init(dev);
 
         b43_switch_channel(dev, dev->phy.channel);
@@ -779,7 +779,7 @@ static int b43_phy_lcn_op_switch_channel(struct b43_wldev *dev,
         enum nl80211_channel_type channel_type =
                 cfg80211_get_chandef_type(&dev->wl->hw->conf.chandef);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if ((new_channel < 1) || (new_channel > 14))
                         return -EINVAL;
         } else {
@@ -791,7 +791,7 @@ static int b43_phy_lcn_op_switch_channel(struct b43_wldev *dev,
 
 static unsigned int b43_phy_lcn_op_get_default_chan(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 return 1;
         return 36;
 }
diff --git a/drivers/net/wireless/broadcom/b43/phy_lp.c b/drivers/net/wireless/broadcom/b43/phy_lp.c
index 058a9f232050..6922cbb99a04 100644
--- a/drivers/net/wireless/broadcom/b43/phy_lp.c
+++ b/drivers/net/wireless/broadcom/b43/phy_lp.c
@@ -46,7 +46,7 @@ static inline u16 channel2freq_lp(u8 channel)
 
 static unsigned int b43_lpphy_op_get_default_chan(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 return 1;
         return 36;
 }
@@ -91,7 +91,7 @@ static void lpphy_read_band_sprom(struct b43_wldev *dev)
         u32 ofdmpo;
         int i;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 lpphy->tx_isolation_med_band = sprom->tri2g;
                 lpphy->bx_arch = sprom->bxa2g;
                 lpphy->rx_pwr_offset = sprom->rxpo2g;
@@ -174,7 +174,7 @@ static void lpphy_adjust_gain_table(struct b43_wldev *dev, u32 freq)
 
         B43_WARN_ON(dev->phy.rev >= 2);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 isolation = lpphy->tx_isolation_med_band;
         else if (freq <= 5320)
                 isolation = lpphy->tx_isolation_low_band;
@@ -238,7 +238,7 @@ static void lpphy_baseband_rev0_1_init(struct b43_wldev *dev)
         b43_phy_maskset(dev, B43_LPPHY_INPUT_PWRDB,
                         0xFF00, lpphy->rx_pwr_offset);
         if ((sprom->boardflags_lo & B43_BFL_FEM) &&
-           ((b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ||
+           ((b43_current_band(dev->wl) == NL80211_BAND_5GHZ) ||
            (sprom->boardflags_hi & B43_BFH_PAREF))) {
                 ssb_pmu_set_ldo_voltage(&bus->chipco, LDO_PAREF, 0x28);
                 ssb_pmu_set_ldo_paref(&bus->chipco, true);
@@ -280,7 +280,7 @@ static void lpphy_baseband_rev0_1_init(struct b43_wldev *dev)
                 b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_7, 0xC0FF, 0x0900);
                 b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_8, 0xFFC0, 0x000A);
                 b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_8, 0xC0FF, 0x0B00);
-        } else if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ ||
+        } else if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ ||
                    (dev->dev->board_type == SSB_BOARD_BU4312) ||
                    (dev->phy.rev == 0 && (sprom->boardflags_lo & B43_BFL_FEM))) {
                 b43_phy_maskset(dev, B43_LPPHY_TR_LOOKUP_1, 0xFFC0, 0x0001);
@@ -326,7 +326,7 @@ static void lpphy_baseband_rev0_1_init(struct b43_wldev *dev)
                 //FIXME the Broadcom driver caches & delays this HF write!
                 b43_hf_write(dev, b43_hf_read(dev) | B43_HF_PR45960W);
         }
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_phy_set(dev, B43_LPPHY_LP_PHY_CTL, 0x8000);
                 b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x0040);
                 b43_phy_maskset(dev, B43_LPPHY_MINPWR_LEVEL, 0x00FF, 0xA400);
@@ -466,7 +466,7 @@ static void lpphy_baseband_rev2plus_init(struct b43_wldev *dev)
                 b43_lptab_write(dev, B43_LPTAB16(0x08, 0x12), 0x40);
         }
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_phy_set(dev, B43_LPPHY_CRSGAIN_CTL, 0x40);
                 b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL, 0xF0FF, 0xB00);
                 b43_phy_maskset(dev, B43_LPPHY_SYNCPEAKCNT, 0xFFF8, 0x6);
@@ -547,7 +547,7 @@ static void lpphy_2062_init(struct b43_wldev *dev)
                 b43_radio_write(dev, B2062_S_BG_CTL1,
                         (b43_radio_read(dev, B2062_N_COMM2) >> 1) | 0x80);
         }
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 b43_radio_set(dev, B2062_N_TSSI_CTL0, 0x1);
         else
                 b43_radio_mask(dev, B2062_N_TSSI_CTL0, ~0x1);
@@ -746,7 +746,7 @@ static void lpphy_clear_deaf(struct b43_wldev *dev, bool user)
                 lpphy->crs_sys_disable = false;
 
         if (!lpphy->crs_usr_disable && !lpphy->crs_sys_disable) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         b43_phy_maskset(dev, B43_LPPHY_CRSGAIN_CTL,
                                         0xFF1F, 0x60);
                 else
@@ -807,7 +807,7 @@ static void lpphy_disable_rx_gain_override(struct b43_wldev *dev)
         b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_0, 0xFFBF);
         if (dev->phy.rev >= 2) {
                 b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFEFF);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         b43_phy_mask(dev, B43_LPPHY_RF_OVERRIDE_2, 0xFBFF);
                         b43_phy_mask(dev, B43_PHY_OFDM(0xE5), 0xFFF7);
                 }
@@ -823,7 +823,7 @@ static void lpphy_enable_rx_gain_override(struct b43_wldev *dev)
         b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x40);
         if (dev->phy.rev >= 2) {
                 b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x100);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_2, 0x400);
                         b43_phy_set(dev, B43_PHY_OFDM(0xE5), 0x8);
                 }
@@ -951,7 +951,7 @@ static void lpphy_rev2plus_set_rx_gain(struct b43_wldev *dev, u32 gain)
                         0xFBFF, ext_lna << 10);
         b43_phy_write(dev, B43_LPPHY_RX_GAIN_CTL_OVERRIDE_VAL, low_gain);
         b43_phy_maskset(dev, B43_LPPHY_AFE_DDFS, 0xFFF0, high_gain);
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 tmp = (gain >> 2) & 0x3;
                 b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_2_VAL,
                                 0xE7FF, tmp<<11);
@@ -1344,7 +1344,7 @@ static void lpphy_calibrate_rc(struct b43_wldev *dev)
         if (dev->phy.rev >= 2) {
                 lpphy_rev2plus_rc_calib(dev);
         } else if (!lpphy->rc_cap) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         lpphy_rev0_1_rc_calib(dev);
         } else {
                 lpphy_set_rc_cap(dev);
@@ -1548,7 +1548,7 @@ static void lpphy_tx_pctl_init_sw(struct b43_wldev *dev)
 {
         struct lpphy_tx_gains gains;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 gains.gm = 4;
                 gains.pad = 12;
                 gains.pga = 12;
@@ -1902,7 +1902,7 @@ static int lpphy_rx_iq_cal(struct b43_wldev *dev, bool noise, bool tx,
 
         lpphy_set_trsw_over(dev, tx, rx);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_phy_set(dev, B43_LPPHY_RF_OVERRIDE_0, 0x8);
                 b43_phy_maskset(dev, B43_LPPHY_RF_OVERRIDE_VAL_0,
                                 0xFFF7, pa << 3);
diff --git a/drivers/net/wireless/broadcom/b43/phy_n.c b/drivers/net/wireless/broadcom/b43/phy_n.c
index 9f0bcf3b8414..a5557d70689f 100644
--- a/drivers/net/wireless/broadcom/b43/phy_n.c
+++ b/drivers/net/wireless/broadcom/b43/phy_n.c
@@ -105,9 +105,9 @@ enum n_rail_type {
 
 static inline bool b43_nphy_ipa(struct b43_wldev *dev)
 {
-        enum ieee80211_band band = b43_current_band(dev->wl);
-        return ((dev->phy.n->ipa2g_on && band == IEEE80211_BAND_2GHZ) ||
-                (dev->phy.n->ipa5g_on && band == IEEE80211_BAND_5GHZ));
+        enum nl80211_band band = b43_current_band(dev->wl);
+        return ((dev->phy.n->ipa2g_on && band == NL80211_BAND_2GHZ) ||
+                (dev->phy.n->ipa5g_on && band == NL80211_BAND_5GHZ));
 }
 
 /* http://bcm-v4.sipsolutions.net/802.11/PHY/N/RxCoreGetState */
@@ -357,7 +357,7 @@ static void b43_nphy_rf_ctl_intc_override_rev7(struct b43_wldev *dev,
                         break;
                 case N_INTC_OVERRIDE_PA:
                         tmp = 0x0030;
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                                 val = value << 5;
                         else
                                 val = value << 4;
@@ -365,7 +365,7 @@ static void b43_nphy_rf_ctl_intc_override_rev7(struct b43_wldev *dev,
                         b43_phy_set(dev, reg, 0x1000);
                         break;
                 case N_INTC_OVERRIDE_EXT_LNA_PU:
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                                 tmp = 0x0001;
                                 tmp2 = 0x0004;
                                 val = value;
@@ -378,7 +378,7 @@ static void b43_nphy_rf_ctl_intc_override_rev7(struct b43_wldev *dev,
                         b43_phy_mask(dev, reg, ~tmp2);
                         break;
                 case N_INTC_OVERRIDE_EXT_LNA_GAIN:
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                                 tmp = 0x0002;
                                 tmp2 = 0x0008;
                                 val = value << 1;
@@ -465,7 +465,7 @@ static void b43_nphy_rf_ctl_intc_override(struct b43_wldev *dev,
                         }
                         break;
                 case N_INTC_OVERRIDE_PA:
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                                 tmp = 0x0020;
                                 val = value << 5;
                         } else {
@@ -475,7 +475,7 @@ static void b43_nphy_rf_ctl_intc_override(struct b43_wldev *dev,
                         b43_phy_maskset(dev, reg, ~tmp, val);
                         break;
                 case N_INTC_OVERRIDE_EXT_LNA_PU:
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                                 tmp = 0x0001;
                                 val = value;
                         } else {
@@ -485,7 +485,7 @@ static void b43_nphy_rf_ctl_intc_override(struct b43_wldev *dev,
                         b43_phy_maskset(dev, reg, ~tmp, val);
                         break;
                 case N_INTC_OVERRIDE_EXT_LNA_GAIN:
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                                 tmp = 0x0002;
                                 val = value << 1;
                         } else {
@@ -600,7 +600,7 @@ static void b43_nphy_adjust_lna_gain_table(struct b43_wldev *dev)
                 b43_nphy_stay_in_carrier_search(dev, 1);
 
         if (nphy->gain_boost) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         gain[0] = 6;
                         gain[1] = 6;
                 } else {
@@ -736,7 +736,7 @@ static void b43_radio_2057_setup(struct b43_wldev *dev,
         switch (phy->radio_rev) {
         case 0 ... 4:
         case 6:
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         b43_radio_write(dev, R2057_RFPLL_LOOPFILTER_R1, 0x3f);
                         b43_radio_write(dev, R2057_CP_KPD_IDAC, 0x3f);
                         b43_radio_write(dev, R2057_RFPLL_LOOPFILTER_C1, 0x8);
@@ -751,7 +751,7 @@ static void b43_radio_2057_setup(struct b43_wldev *dev,
         case 9: /* e.g. PHY rev 16 */
                 b43_radio_write(dev, R2057_LOGEN_PTAT_RESETS, 0x20);
                 b43_radio_write(dev, R2057_VCOBUF_IDACS, 0x18);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         b43_radio_write(dev, R2057_LOGEN_PTAT_RESETS, 0x38);
                         b43_radio_write(dev, R2057_VCOBUF_IDACS, 0x0f);
 
@@ -775,7 +775,7 @@ static void b43_radio_2057_setup(struct b43_wldev *dev,
                 break;
         }
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 u16 txmix2g_tune_boost_pu = 0;
                 u16 pad2g_tune_pus = 0;
 
@@ -1135,7 +1135,7 @@ static void b43_radio_2056_setup(struct b43_wldev *dev,
 {
         struct b43_phy *phy = &dev->phy;
         struct ssb_sprom *sprom = dev->dev->bus_sprom;
-        enum ieee80211_band band = b43_current_band(dev->wl);
+        enum nl80211_band band = b43_current_band(dev->wl);
         u16 offset;
         u8 i;
         u16 bias, cbias;
@@ -1152,10 +1152,10 @@ static void b43_radio_2056_setup(struct b43_wldev *dev,
                  dev->dev->chip_pkg == BCMA_PKG_ID_BCM43224_FAB_SMIC);
 
         b43_chantab_radio_2056_upload(dev, e);
-        b2056_upload_syn_pll_cp2(dev, band == IEEE80211_BAND_5GHZ);
+        b2056_upload_syn_pll_cp2(dev, band == NL80211_BAND_5GHZ);
 
         if (sprom->boardflags2_lo & B43_BFL2_GPLL_WAR &&
-            b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+            b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER1, 0x1F);
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER2, 0x1F);
                 if (dev->dev->chip_id == BCMA_CHIP_ID_BCM4716 ||
@@ -1168,21 +1168,21 @@ static void b43_radio_2056_setup(struct b43_wldev *dev,
                 }
         }
         if (sprom->boardflags2_hi & B43_BFH2_GPLL_WAR2 &&
-            b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+            b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER1, 0x1f);
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER2, 0x1f);
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER4, 0x0b);
                 b43_radio_write(dev, B2056_SYN_PLL_CP2, 0x20);
         }
         if (sprom->boardflags2_lo & B43_BFL2_APLL_WAR &&
-            b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+            b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER1, 0x1F);
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER2, 0x1F);
                 b43_radio_write(dev, B2056_SYN_PLL_LOOPFILTER4, 0x05);
                 b43_radio_write(dev, B2056_SYN_PLL_CP2, 0x0C);
         }
 
-        if (dev->phy.n->ipa2g_on && band == IEEE80211_BAND_2GHZ) {
+        if (dev->phy.n->ipa2g_on && band == NL80211_BAND_2GHZ) {
                 for (i = 0; i < 2; i++) {
                         offset = i ? B2056_TX1 : B2056_TX0;
                         if (dev->phy.rev >= 5) {
@@ -1244,7 +1244,7 @@ static void b43_radio_2056_setup(struct b43_wldev *dev,
                         }
                         b43_radio_write(dev, offset | B2056_TX_PA_SPARE1, 0xee);
                 }
-        } else if (dev->phy.n->ipa5g_on && band == IEEE80211_BAND_5GHZ) {
+        } else if (dev->phy.n->ipa5g_on && band == NL80211_BAND_5GHZ) {
                 u16 freq = phy->chandef->chan->center_freq;
                 if (freq < 5100) {
                         paa_boost = 0xA;
@@ -1501,7 +1501,7 @@ static void b43_radio_init2055(struct b43_wldev *dev)
                 /* Follow wl, not specs. Do not force uploading all regs */
                 b2055_upload_inittab(dev, 0, 0);
         } else {
-                bool ghz5 = b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ;
+                bool ghz5 = b43_current_band(dev->wl) == NL80211_BAND_5GHZ;
                 b2055_upload_inittab(dev, ghz5, 0);
         }
         b43_radio_init2055_post(dev);
@@ -1785,7 +1785,7 @@ static void b43_nphy_rev3_rssi_select(struct b43_wldev *dev, u8 code,
                                 b43_phy_maskset(dev, reg, 0xFFC3, 0);
 
                                 if (rssi_type == N_RSSI_W1)
-                                        val = (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ? 4 : 8;
+                                        val = (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) ? 4 : 8;
                                 else if (rssi_type == N_RSSI_W2)
                                         val = 16;
                                 else
@@ -1813,12 +1813,12 @@ static void b43_nphy_rev3_rssi_select(struct b43_wldev *dev, u8 code,
 
                                 if (rssi_type != N_RSSI_IQ &&
                                     rssi_type != N_RSSI_TBD) {
-                                        enum ieee80211_band band =
+                                        enum nl80211_band band =
                                                 b43_current_band(dev->wl);
 
                                         if (dev->phy.rev < 7) {
                                                 if (b43_nphy_ipa(dev))
-                                                        val = (band == IEEE80211_BAND_5GHZ) ? 0xC : 0xE;
+                                                        val = (band == NL80211_BAND_5GHZ) ? 0xC : 0xE;
                                                 else
                                                         val = 0x11;
                                                 reg = (i == 0) ? B2056_TX0 : B2056_TX1;
@@ -2120,7 +2120,7 @@ static void b43_nphy_rev3_rssi_cal(struct b43_wldev *dev)
                                                      1, 0, false);
                 b43_nphy_rf_ctl_override_rev7(dev, 0x80, 1, 0, false, 0);
                 b43_nphy_rf_ctl_override_rev7(dev, 0x40, 1, 0, false, 0);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         b43_nphy_rf_ctl_override_rev7(dev, 0x20, 0, 0, false,
                                                       0);
                         b43_nphy_rf_ctl_override_rev7(dev, 0x10, 1, 0, false,
@@ -2136,7 +2136,7 @@ static void b43_nphy_rev3_rssi_cal(struct b43_wldev *dev)
                 b43_nphy_rf_ctl_override(dev, 0x2, 1, 0, false);
                 b43_nphy_rf_ctl_override(dev, 0x80, 1, 0, false);
                 b43_nphy_rf_ctl_override(dev, 0x40, 1, 0, false);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         b43_nphy_rf_ctl_override(dev, 0x20, 0, 0, false);
                         b43_nphy_rf_ctl_override(dev, 0x10, 1, 0, false);
                 } else {
@@ -2257,7 +2257,7 @@ static void b43_nphy_rev3_rssi_cal(struct b43_wldev *dev)
                 b43_phy_write(dev, regs_to_store[i], saved_regs_phy[i]);
 
         /* Store for future configuration */
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 rssical_radio_regs = nphy->rssical_cache.rssical_radio_regs_2G;
                 rssical_phy_regs = nphy->rssical_cache.rssical_phy_regs_2G;
         } else {
@@ -2289,7 +2289,7 @@ static void b43_nphy_rev3_rssi_cal(struct b43_wldev *dev)
         rssical_phy_regs[11] = b43_phy_read(dev, B43_NPHY_RSSIMC_1Q_RSSI_Y);
 
         /* Remember for which channel we store configuration */
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 nphy->rssical_chanspec_2G.center_freq = phy->chandef->chan->center_freq;
         else
                 nphy->rssical_chanspec_5G.center_freq = phy->chandef->chan->center_freq;
@@ -2336,7 +2336,7 @@ static void b43_nphy_rev2_rssi_cal(struct b43_wldev *dev, enum n_rssi_type type)
         b43_nphy_read_clip_detection(dev, clip_state);
         b43_nphy_write_clip_detection(dev, clip_off);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 override = 0x140;
         else
                 override = 0x110;
@@ -2629,7 +2629,7 @@ static void b43_nphy_gain_ctl_workarounds_rev1_2(struct b43_wldev *dev)
         b43_phy_write(dev, B43_NPHY_CCK_SHIFTB_REF, 0x809C);
 
         if (nphy->gain_boost) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ &&
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ &&
                     b43_is_40mhz(dev))
                         code = 4;
                 else
@@ -2688,7 +2688,7 @@ static void b43_nphy_gain_ctl_workarounds_rev1_2(struct b43_wldev *dev)
                 ~B43_NPHY_OVER_DGAIN_CCKDGECV & 0xFFFF,
                 0x5A << B43_NPHY_OVER_DGAIN_CCKDGECV_SHIFT);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 b43_phy_maskset(dev, B43_PHY_N(0xC5D), 0xFF80, 4);
 }
 
@@ -2803,7 +2803,7 @@ static void b43_nphy_workarounds_rev7plus(struct b43_wldev *dev)
         scap_val = b43_radio_read(dev, R2057_RCCAL_SCAP_VAL);
 
         if (b43_nphy_ipa(dev)) {
-                bool ghz2 = b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ;
+                bool ghz2 = b43_current_band(dev->wl) == NL80211_BAND_2GHZ;
 
                 switch (phy->radio_rev) {
                 case 5:
@@ -2831,7 +2831,7 @@ static void b43_nphy_workarounds_rev7plus(struct b43_wldev *dev)
                                 bcap_val_11b[core] = bcap_val;
                                 lpf_ofdm_20mhz[core] = 4;
                                 lpf_11b[core] = 1;
-                                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                                         scap_val_11n_20[core] = 0xc;
                                         bcap_val_11n_20[core] = 0xc;
                                         scap_val_11n_40[core] = 0xa;
@@ -2982,7 +2982,7 @@ static void b43_nphy_workarounds_rev7plus(struct b43_wldev *dev)
                         conv = 0x7f;
                         filt = 0xee;
                 }
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         for (core = 0; core < 2; core++) {
                                 if (core == 0) {
                                         b43_radio_write(dev, 0x5F, bias);
@@ -2998,7 +2998,7 @@ static void b43_nphy_workarounds_rev7plus(struct b43_wldev *dev)
         }
 
         if (b43_nphy_ipa(dev)) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         if (phy->radio_rev == 3 || phy->radio_rev == 4 ||
                             phy->radio_rev == 6) {
                                 for (core = 0; core < 2; core++) {
@@ -3221,7 +3221,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
                                          ARRAY_SIZE(rx2tx_events));
         }
 
-        tmp16 = (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) ?
+        tmp16 = (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) ?
                 0x2 : 0x9C40;
         b43_phy_write(dev, B43_NPHY_ENDROP_TLEN, tmp16);
 
@@ -3240,7 +3240,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
         b43_ntab_write(dev, B43_NTAB16(8, 0), 2);
         b43_ntab_write(dev, B43_NTAB16(8, 16), 2);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 pdet_range = sprom->fem.ghz2.pdet_range;
         else
                 pdet_range = sprom->fem.ghz5.pdet_range;
@@ -3249,7 +3249,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
         switch (pdet_range) {
         case 3:
                 if (!(dev->phy.rev >= 4 &&
-                      b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ))
+                      b43_current_band(dev->wl) == NL80211_BAND_2GHZ))
                         break;
                 /* FALL THROUGH */
         case 0:
@@ -3261,7 +3261,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
                 break;
         case 2:
                 if (dev->phy.rev >= 6) {
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                                 vmid[3] = 0x94;
                         else
                                 vmid[3] = 0x8e;
@@ -3277,7 +3277,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
                 break;
         case 4:
         case 5:
-                if (b43_current_band(dev->wl) != IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) != NL80211_BAND_2GHZ) {
                         if (pdet_range == 4) {
                                 vmid[3] = 0x8e;
                                 tmp16 = 0x96;
@@ -3322,9 +3322,9 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
         /* N PHY WAR TX Chain Update with hw_phytxchain as argument */
 
         if ((sprom->boardflags2_lo & B43_BFL2_APLL_WAR &&
-             b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ||
+             b43_current_band(dev->wl) == NL80211_BAND_5GHZ) ||
             (sprom->boardflags2_lo & B43_BFL2_GPLL_WAR &&
-             b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ))
+             b43_current_band(dev->wl) == NL80211_BAND_2GHZ))
                 tmp32 = 0x00088888;
         else
                 tmp32 = 0x88888888;
@@ -3333,7 +3333,7 @@ static void b43_nphy_workarounds_rev3plus(struct b43_wldev *dev)
         b43_ntab_write(dev, B43_NTAB32(30, 3), tmp32);
 
         if (dev->phy.rev == 4 &&
-            b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+            b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                 b43_radio_write(dev, B2056_TX0 | B2056_TX_GMBB_IDAC,
                                 0x70);
                 b43_radio_write(dev, B2056_TX1 | B2056_TX_GMBB_IDAC,
@@ -3376,7 +3376,7 @@ static void b43_nphy_workarounds_rev1_2(struct b43_wldev *dev)
                 delays1[5] = 0x14;
         }
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ &&
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ &&
             nphy->band5g_pwrgain) {
                 b43_radio_mask(dev, B2055_C1_TX_RF_SPARE, ~0x8);
                 b43_radio_mask(dev, B2055_C2_TX_RF_SPARE, ~0x8);
@@ -3451,7 +3451,7 @@ static void b43_nphy_workarounds(struct b43_wldev *dev)
         struct b43_phy *phy = &dev->phy;
         struct b43_phy_n *nphy = phy->n;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 b43_nphy_classifier(dev, 1, 0);
         else
                 b43_nphy_classifier(dev, 1, 1);
@@ -3586,7 +3586,7 @@ static void b43_nphy_iq_cal_gain_params(struct b43_wldev *dev, u16 core,
                 gain = (target.pad[core]) | (target.pga[core] << 4) |
                         (target.txgm[core] << 8);
 
-                indx = (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ?
+                indx = (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) ?
                         1 : 0;
                 for (i = 0; i < 9; i++)
                         if (tbl_iqcal_gainparams[indx][i][0] == gain)
@@ -3614,7 +3614,7 @@ static void b43_nphy_tx_power_ctrl(struct b43_wldev *dev, bool enable)
         struct b43_phy_n *nphy = dev->phy.n;
         u8 i;
         u16 bmask, val, tmp;
-        enum ieee80211_band band = b43_current_band(dev->wl);
+        enum nl80211_band band = b43_current_band(dev->wl);
 
         if (nphy->hang_avoid)
                 b43_nphy_stay_in_carrier_search(dev, 1);
@@ -3679,7 +3679,7 @@ static void b43_nphy_tx_power_ctrl(struct b43_wldev *dev, bool enable)
                 }
                 b43_phy_maskset(dev, B43_NPHY_TXPCTL_CMD, ~(bmask), val);
 
-                if (band == IEEE80211_BAND_5GHZ) {
+                if (band == NL80211_BAND_5GHZ) {
                         if (phy->rev >= 19) {
                                 /* TODO */
                         } else if (phy->rev >= 7) {
@@ -3770,7 +3770,7 @@ static void b43_nphy_tx_power_fix(struct b43_wldev *dev)
                 txpi[0] = 72;
                 txpi[1] = 72;
         } else {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         txpi[0] = sprom->txpid2g[0];
                         txpi[1] = sprom->txpid2g[1];
                 } else if (freq >= 4900 && freq < 5100) {
@@ -3868,7 +3868,7 @@ static void b43_nphy_ipa_internal_tssi_setup(struct b43_wldev *dev)
         } else if (phy->rev >= 7) {
                 for (core = 0; core < 2; core++) {
                         r = core ? 0x190 : 0x170;
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                                 b43_radio_write(dev, r + 0x5, 0x5);
                                 b43_radio_write(dev, r + 0x9, 0xE);
                                 if (phy->rev != 5)
@@ -3892,7 +3892,7 @@ static void b43_nphy_ipa_internal_tssi_setup(struct b43_wldev *dev)
                         b43_radio_write(dev, r + 0xC, 0);
                 }
         } else {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         b43_radio_write(dev, B2056_SYN_RESERVED_ADDR31, 0x128);
                 else
                         b43_radio_write(dev, B2056_SYN_RESERVED_ADDR31, 0x80);
@@ -3909,7 +3909,7 @@ static void b43_nphy_ipa_internal_tssi_setup(struct b43_wldev *dev)
                         b43_radio_write(dev, r | B2056_TX_TSSI_MISC1, 8);
                         b43_radio_write(dev, r | B2056_TX_TSSI_MISC2, 0);
                         b43_radio_write(dev, r | B2056_TX_TSSI_MISC3, 0);
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                                 b43_radio_write(dev, r | B2056_TX_TX_SSI_MASTER,
                                                 0x5);
                                 if (phy->rev != 5)
@@ -4098,7 +4098,7 @@ static void b43_nphy_tx_power_ctl_setup(struct b43_wldev *dev)
                 b0[0] = b0[1] = 5612;
                 b1[0] = b1[1] = -1393;
         } else {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         for (c = 0; c < 2; c++) {
                                 idle[c] = nphy->pwr_ctl_info[c].idle_tssi_2g;
                                 target[c] = sprom->core_pwr_info[c].maxpwr_2g;
@@ -4153,11 +4153,11 @@ static void b43_nphy_tx_power_ctl_setup(struct b43_wldev *dev)
                         for (c = 0; c < 2; c++) {
                                 r = c ? 0x190 : 0x170;
                                 if (b43_nphy_ipa(dev))
-                                        b43_radio_write(dev, r + 0x9, (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) ? 0xE : 0xC);
+                                        b43_radio_write(dev, r + 0x9, (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) ? 0xE : 0xC);
                         }
                 } else {
                         if (b43_nphy_ipa(dev)) {
-                                tmp = (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) ? 0xC : 0xE;
+                                tmp = (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) ? 0xC : 0xE;
                                 b43_radio_write(dev,
                                         B2056_TX0 | B2056_TX_TX_SSI_MUX, tmp);
                                 b43_radio_write(dev,
@@ -4267,13 +4267,13 @@ static void b43_nphy_tx_gain_table_upload(struct b43_wldev *dev)
                 } else if (phy->rev >= 7) {
                         pga_gain = (table[i] >> 24) & 0xf;
                         pad_gain = (table[i] >> 19) & 0x1f;
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                                 rfpwr_offset = rf_pwr_offset_table[pad_gain];
                         else
                                 rfpwr_offset = rf_pwr_offset_table[pga_gain];
                 } else {
                         pga_gain = (table[i] >> 24) & 0xF;
-                        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                                 rfpwr_offset = b43_ntab_papd_pga_gain_delta_ipa_2g[pga_gain];
                         else
                                 rfpwr_offset = 0; /* FIXME */
@@ -4288,7 +4288,7 @@ static void b43_nphy_tx_gain_table_upload(struct b43_wldev *dev)
 static void b43_nphy_pa_override(struct b43_wldev *dev, bool enable)
 {
         struct b43_phy_n *nphy = dev->phy.n;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u16 tmp;
 
         if (!enable) {
@@ -4300,12 +4300,12 @@ static void b43_nphy_pa_override(struct b43_wldev *dev, bool enable)
                 if (dev->phy.rev >= 7) {
                         tmp = 0x1480;
                 } else if (dev->phy.rev >= 3) {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 tmp = 0x600;
                         else
                                 tmp = 0x480;
                 } else {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 tmp = 0x180;
                         else
                                 tmp = 0x120;
@@ -4734,7 +4734,7 @@ static void b43_nphy_restore_rssi_cal(struct b43_wldev *dev)
         u16 *rssical_radio_regs = NULL;
         u16 *rssical_phy_regs = NULL;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if (!nphy->rssical_chanspec_2G.center_freq)
                         return;
                 rssical_radio_regs = nphy->rssical_cache.rssical_radio_regs_2G;
@@ -4804,7 +4804,7 @@ static void b43_nphy_tx_cal_radio_setup_rev7(struct b43_wldev *dev)
                 save[off + 7] = b43_radio_read(dev, r + R2057_TX0_TSSIG);
                 save[off + 8] = b43_radio_read(dev, r + R2057_TX0_TSSI_MISC1);
 
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         b43_radio_write(dev, r + R2057_TX0_TX_SSI_MASTER, 0xA);
                         b43_radio_write(dev, r + R2057_TX0_IQCAL_VCM_HG, 0x43);
                         b43_radio_write(dev, r + R2057_TX0_IQCAL_IDAC, 0x55);
@@ -4864,7 +4864,7 @@ static void b43_nphy_tx_cal_radio_setup(struct b43_wldev *dev)
                 save[offset + 9] = b43_radio_read(dev, B2055_XOMISC);
                 save[offset + 10] = b43_radio_read(dev, B2055_PLL_LFC1);
 
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                         b43_radio_write(dev, tmp | B2055_CAL_RVARCTL, 0x0A);
                         b43_radio_write(dev, tmp | B2055_CAL_LPOCTL, 0x40);
                         b43_radio_write(dev, tmp | B2055_CAL_TS, 0x55);
@@ -5005,7 +5005,7 @@ static void b43_nphy_int_pa_set_tx_dig_filters(struct b43_wldev *dev)
                 b43_nphy_pa_set_tx_dig_filter(dev, 0x186,
                                               tbl_tx_filter_coef_rev4[3]);
         } else {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                         b43_nphy_pa_set_tx_dig_filter(dev, 0x186,
                                                       tbl_tx_filter_coef_rev4[5]);
                 if (dev->phy.channel == 14)
@@ -5185,7 +5185,7 @@ static void b43_nphy_tx_cal_phy_setup(struct b43_wldev *dev)
                                                               false, 0);
                         } else if (phy->rev == 7) {
                                 b43_radio_maskset(dev, R2057_OVR_REG0, 1 << 4, 1 << 4);
-                                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                                         b43_radio_maskset(dev, R2057_PAD2G_TUNE_PUS_CORE0, ~1, 0);
                                         b43_radio_maskset(dev, R2057_PAD2G_TUNE_PUS_CORE1, ~1, 0);
                                 } else {
@@ -5210,7 +5210,7 @@ static void b43_nphy_tx_cal_phy_setup(struct b43_wldev *dev)
                 b43_ntab_write(dev, B43_NTAB16(8, 18), tmp);
                 regs[5] = b43_phy_read(dev, B43_NPHY_RFCTL_INTC1);
                 regs[6] = b43_phy_read(dev, B43_NPHY_RFCTL_INTC2);
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                         tmp = 0x0180;
                 else
                         tmp = 0x0120;
@@ -5233,7 +5233,7 @@ static void b43_nphy_save_cal(struct b43_wldev *dev)
         if (nphy->hang_avoid)
                 b43_nphy_stay_in_carrier_search(dev, 1);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 rxcal_coeffs = &nphy->cal_cache.rxcal_coeffs_2G;
                 txcal_radio_regs = nphy->cal_cache.txcal_radio_regs_2G;
                 iqcal_chanspec = &nphy->iqcal_chanspec_2G;
@@ -5304,7 +5304,7 @@ static void b43_nphy_restore_cal(struct b43_wldev *dev)
         u16 *txcal_radio_regs = NULL;
         struct b43_phy_n_iq_comp *rxcal_coeffs = NULL;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if (!nphy->iqcal_chanspec_2G.center_freq)
                         return;
                 table = nphy->cal_cache.txcal_coeffs_2G;
@@ -5332,7 +5332,7 @@ static void b43_nphy_restore_cal(struct b43_wldev *dev)
         if (dev->phy.rev < 2)
                 b43_nphy_tx_iq_workaround(dev);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 txcal_radio_regs = nphy->cal_cache.txcal_radio_regs_2G;
                 rxcal_coeffs = &nphy->cal_cache.rxcal_coeffs_2G;
         } else {
@@ -5422,7 +5422,7 @@ static int b43_nphy_cal_tx_iq_lo(struct b43_wldev *dev,
 
         phy6or5x = dev->phy.rev >= 6 ||
                 (dev->phy.rev == 5 && nphy->ipa2g_on &&
-                b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ);
+                b43_current_band(dev->wl) == NL80211_BAND_2GHZ);
         if (phy6or5x) {
                 if (b43_is_40mhz(dev)) {
                         b43_ntab_write_bulk(dev, B43_NTAB16(15, 0), 18,
@@ -5657,7 +5657,7 @@ static int b43_nphy_rev2_cal_rx_iq(struct b43_wldev *dev,
         u16 tmp[6];
         u16 uninitialized_var(cur_hpf1), uninitialized_var(cur_hpf2), cur_lna;
         u32 real, imag;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         u8 use;
         u16 cur_hpf;
@@ -5712,18 +5712,18 @@ static int b43_nphy_rev2_cal_rx_iq(struct b43_wldev *dev,
                 band = b43_current_band(dev->wl);
 
                 if (nphy->rxcalparams & 0xFF000000) {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 b43_phy_write(dev, rfctl[0], 0x140);
                         else
                                 b43_phy_write(dev, rfctl[0], 0x110);
                 } else {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 b43_phy_write(dev, rfctl[0], 0x180);
                         else
                                 b43_phy_write(dev, rfctl[0], 0x120);
                 }
 
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         b43_phy_write(dev, rfctl[1], 0x148);
                 else
                         b43_phy_write(dev, rfctl[1], 0x114);
@@ -5919,7 +5919,7 @@ static enum b43_txpwr_result b43_nphy_op_recalc_txpower(struct b43_wldev *dev,
 #if 0
         /* Some extra gains */
         hw_gain = 6; /* N-PHY specific */
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 hw_gain += sprom->antenna_gain.a0;
         else
                 hw_gain += sprom->antenna_gain.a1;
@@ -6043,7 +6043,7 @@ static int b43_phy_initn(struct b43_wldev *dev)
         u8 tx_pwr_state;
         struct nphy_txgains target;
         u16 tmp;
-        enum ieee80211_band tmp2;
+        enum nl80211_band tmp2;
         bool do_rssi_cal;
 
         u16 clip[2];
@@ -6051,7 +6051,7 @@ static int b43_phy_initn(struct b43_wldev *dev)
 
         if ((dev->phy.rev >= 3) &&
            (sprom->boardflags_lo & B43_BFL_EXTLNA) &&
-           (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)) {
+           (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)) {
                 switch (dev->dev->bus_type) {
 #ifdef CONFIG_B43_BCMA
                 case B43_BUS_BCMA:
@@ -6170,7 +6170,7 @@ static int b43_phy_initn(struct b43_wldev *dev)
 
         b43_nphy_classifier(dev, 0, 0);
         b43_nphy_read_clip_detection(dev, clip);
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 b43_nphy_bphy_init(dev);
 
         tx_pwr_state = nphy->txpwrctrl;
@@ -6187,7 +6187,7 @@ static int b43_phy_initn(struct b43_wldev *dev)
 
         do_rssi_cal = false;
         if (phy->rev >= 3) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         do_rssi_cal = !nphy->rssical_chanspec_2G.center_freq;
                 else
                         do_rssi_cal = !nphy->rssical_chanspec_5G.center_freq;
@@ -6201,7 +6201,7 @@ static int b43_phy_initn(struct b43_wldev *dev)
         }
 
         if (!((nphy->measure_hold & 0x6) != 0)) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         do_cal = !nphy->iqcal_chanspec_2G.center_freq;
                 else
                         do_cal = !nphy->iqcal_chanspec_5G.center_freq;
@@ -6291,7 +6291,7 @@ static void b43_nphy_channel_setup(struct b43_wldev *dev,
         int ch = new_channel->hw_value;
         u16 tmp16;
 
-        if (new_channel->band == IEEE80211_BAND_5GHZ) {
+        if (new_channel->band == NL80211_BAND_5GHZ) {
                 /* Switch to 2 GHz for a moment to access B43_PHY_B_BBCFG */
                 b43_phy_mask(dev, B43_NPHY_BANDCTL, ~B43_NPHY_BANDCTL_5GHZ);
 
@@ -6302,7 +6302,7 @@ static void b43_nphy_channel_setup(struct b43_wldev *dev,
                             B43_PHY_B_BBCFG_RSTCCA | B43_PHY_B_BBCFG_RSTRX);
                 b43_write16(dev, B43_MMIO_PSM_PHY_HDR, tmp16);
                 b43_phy_set(dev, B43_NPHY_BANDCTL, B43_NPHY_BANDCTL_5GHZ);
-        } else if (new_channel->band == IEEE80211_BAND_2GHZ) {
+        } else if (new_channel->band == NL80211_BAND_2GHZ) {
                 b43_phy_mask(dev, B43_NPHY_BANDCTL, ~B43_NPHY_BANDCTL_5GHZ);
                 tmp16 = b43_read16(dev, B43_MMIO_PSM_PHY_HDR);
                 b43_write16(dev, B43_MMIO_PSM_PHY_HDR, tmp16 | 4);
@@ -6319,7 +6319,7 @@ static void b43_nphy_channel_setup(struct b43_wldev *dev,
                 b43_phy_set(dev, B43_PHY_B_TEST, 0x0800);
         } else {
                 b43_nphy_classifier(dev, 2, 2);
-                if (new_channel->band == IEEE80211_BAND_2GHZ)
+                if (new_channel->band == NL80211_BAND_2GHZ)
                         b43_phy_mask(dev, B43_PHY_B_TEST, ~0x840);
         }
 
@@ -6449,7 +6449,7 @@ static int b43_nphy_set_channel(struct b43_wldev *dev,
                         &(tabent_r7->phy_regs) : &(tabent_r7_2g->phy_regs);
 
                 if (phy->radio_rev <= 4 || phy->radio_rev == 6) {
-                        tmp = (channel->band == IEEE80211_BAND_5GHZ) ? 2 : 0;
+                        tmp = (channel->band == NL80211_BAND_5GHZ) ? 2 : 0;
                         b43_radio_maskset(dev, R2057_TIA_CONFIG_CORE0, ~2, tmp);
                         b43_radio_maskset(dev, R2057_TIA_CONFIG_CORE1, ~2, tmp);
                 }
@@ -6457,12 +6457,12 @@ static int b43_nphy_set_channel(struct b43_wldev *dev,
                 b43_radio_2057_setup(dev, tabent_r7, tabent_r7_2g);
                 b43_nphy_channel_setup(dev, phy_regs, channel);
         } else if (phy->rev >= 3) {
-                tmp = (channel->band == IEEE80211_BAND_5GHZ) ? 4 : 0;
+                tmp = (channel->band == NL80211_BAND_5GHZ) ? 4 : 0;
                 b43_radio_maskset(dev, 0x08, 0xFFFB, tmp);
                 b43_radio_2056_setup(dev, tabent_r3);
                 b43_nphy_channel_setup(dev, &(tabent_r3->phy_regs), channel);
         } else {
-                tmp = (channel->band == IEEE80211_BAND_5GHZ) ? 0x0020 : 0x0050;
+                tmp = (channel->band == NL80211_BAND_5GHZ) ? 0x0020 : 0x0050;
                 b43_radio_maskset(dev, B2055_MASTER1, 0xFF8F, tmp);
                 b43_radio_2055_setup(dev, tabent_r2);
                 b43_nphy_channel_setup(dev, &(tabent_r2->phy_regs), channel);
@@ -6692,7 +6692,7 @@ static int b43_nphy_op_switch_channel(struct b43_wldev *dev,
         enum nl80211_channel_type channel_type =
                 cfg80211_get_chandef_type(&dev->wl->hw->conf.chandef);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if ((new_channel < 1) || (new_channel > 14))
                         return -EINVAL;
         } else {
@@ -6705,7 +6705,7 @@ static int b43_nphy_op_switch_channel(struct b43_wldev *dev,
 
 static unsigned int b43_nphy_op_get_default_chan(struct b43_wldev *dev)
 {
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                 return 1;
         return 36;
 }
diff --git a/drivers/net/wireless/broadcom/b43/tables_lpphy.c b/drivers/net/wireless/broadcom/b43/tables_lpphy.c
index cff187c5616d..ce01e1645df7 100644
--- a/drivers/net/wireless/broadcom/b43/tables_lpphy.c
+++ b/drivers/net/wireless/broadcom/b43/tables_lpphy.c
@@ -560,7 +560,7 @@ void b2062_upload_init_table(struct b43_wldev *dev)
 
         for (i = 0; i < ARRAY_SIZE(b2062_init_tab); i++) {
                 e = &b2062_init_tab[i];
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         if (!(e->flags & B206X_FLAG_G))
                                 continue;
                         b43_radio_write(dev, e->offset, e->value_g);
@@ -579,7 +579,7 @@ void b2063_upload_init_table(struct b43_wldev *dev)
 
         for (i = 0; i < ARRAY_SIZE(b2063_init_tab); i++) {
                 e = &b2063_init_tab[i];
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+                if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                         if (!(e->flags & B206X_FLAG_G))
                                 continue;
                         b43_radio_write(dev, e->offset, e->value_g);
@@ -2379,12 +2379,12 @@ static void lpphy_rev2plus_write_gain_table(struct b43_wldev *dev, int offset,
         tmp |= data.pga << 8;
         tmp |= data.gm;
         if (dev->phy.rev >= 3) {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                         tmp |= 0x10 << 24;
                 else
                         tmp |= 0x70 << 24;
         } else {
-                if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+                if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                         tmp |= 0x14 << 24;
                 else
                         tmp |= 0x7F << 24;
@@ -2423,7 +2423,7 @@ void lpphy_init_tx_gain_table(struct b43_wldev *dev)
                     (sprom->boardflags_lo & B43_BFL_HGPA))
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev0_nopa_tx_gain_table);
-                else if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                else if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev0_2ghz_tx_gain_table);
                 else
@@ -2435,7 +2435,7 @@ void lpphy_init_tx_gain_table(struct b43_wldev *dev)
                     (sprom->boardflags_lo & B43_BFL_HGPA))
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev1_nopa_tx_gain_table);
-                else if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                else if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev1_2ghz_tx_gain_table);
                 else
@@ -2446,7 +2446,7 @@ void lpphy_init_tx_gain_table(struct b43_wldev *dev)
                 if (sprom->boardflags_hi & B43_BFH_NOPA)
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev2_nopa_tx_gain_table);
-                else if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)
+                else if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ)
                         lpphy_write_gain_table_bulk(dev, 0, 128,
                                         lpphy_rev2_2ghz_tx_gain_table);
                 else
diff --git a/drivers/net/wireless/broadcom/b43/tables_nphy.c b/drivers/net/wireless/broadcom/b43/tables_nphy.c
index b2f0d245bcf3..44e0957a70cc 100644
--- a/drivers/net/wireless/broadcom/b43/tables_nphy.c
+++ b/drivers/net/wireless/broadcom/b43/tables_nphy.c
@@ -3502,7 +3502,7 @@ static void b43_nphy_tables_init_rev7_volatile(struct b43_wldev *dev)
                 { 0x2, 0x18, 0x2 }, /* Core 1 */
         };
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 antswlut = sprom->fem.ghz5.antswlut;
         else
                 antswlut = sprom->fem.ghz2.antswlut;
@@ -3566,7 +3566,7 @@ static void b43_nphy_tables_init_rev3(struct b43_wldev *dev)
         struct ssb_sprom *sprom = dev->dev->bus_sprom;
         u8 antswlut;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
+        if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ)
                 antswlut = sprom->fem.ghz5.antswlut;
         else
                 antswlut = sprom->fem.ghz2.antswlut;
@@ -3651,7 +3651,7 @@ static const u32 *b43_nphy_get_ipa_gain_table(struct b43_wldev *dev)
 {
         struct b43_phy *phy = &dev->phy;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 switch (phy->rev) {
                 case 17:
                         if (phy->radio_rev == 14)
@@ -3698,17 +3698,17 @@ static const u32 *b43_nphy_get_ipa_gain_table(struct b43_wldev *dev)
 const u32 *b43_nphy_get_tx_gain_table(struct b43_wldev *dev)
 {
         struct b43_phy *phy = &dev->phy;
-        enum ieee80211_band band = b43_current_band(dev->wl);
+        enum nl80211_band band = b43_current_band(dev->wl);
         struct ssb_sprom *sprom = dev->dev->bus_sprom;
 
         if (dev->phy.rev < 3)
                 return b43_ntab_tx_gain_rev0_1_2;
 
         /* rev 3+ */
-        if ((dev->phy.n->ipa2g_on && band == IEEE80211_BAND_2GHZ) ||
-            (dev->phy.n->ipa5g_on && band == IEEE80211_BAND_5GHZ)) {
+        if ((dev->phy.n->ipa2g_on && band == NL80211_BAND_2GHZ) ||
+            (dev->phy.n->ipa5g_on && band == NL80211_BAND_5GHZ)) {
                 return b43_nphy_get_ipa_gain_table(dev);
-        } else if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ) {
+        } else if (b43_current_band(dev->wl) == NL80211_BAND_5GHZ) {
                 switch (phy->rev) {
                 case 6:
                 case 5:
@@ -3746,7 +3746,7 @@ const s16 *b43_ntab_get_rf_pwr_offset_table(struct b43_wldev *dev)
 {
         struct b43_phy *phy = &dev->phy;
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 switch (phy->rev) {
                 case 17:
                         if (phy->radio_rev == 14)
diff --git a/drivers/net/wireless/broadcom/b43/tables_phy_lcn.c b/drivers/net/wireless/broadcom/b43/tables_phy_lcn.c
index e347b8d80ea4..704ef1bcb5b1 100644
--- a/drivers/net/wireless/broadcom/b43/tables_phy_lcn.c
+++ b/drivers/net/wireless/broadcom/b43/tables_phy_lcn.c
@@ -701,7 +701,7 @@ void b43_phy_lcn_tables_init(struct b43_wldev *dev)
 
         b43_phy_lcn_upload_static_tables(dev);
 
-        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) {
+        if (b43_current_band(dev->wl) == NL80211_BAND_2GHZ) {
                 if (sprom->boardflags_lo & B43_BFL_FEM)
                         b43_phy_lcn_load_tx_gain_tab(dev,
                                 b43_lcntab_tx_gain_tbl_2ghz_ext_pa_rev0);
diff --git a/drivers/net/wireless/broadcom/b43/xmit.c b/drivers/net/wireless/broadcom/b43/xmit.c
index 426dc13c44cd..f6201264de49 100644
--- a/drivers/net/wireless/broadcom/b43/xmit.c
+++ b/drivers/net/wireless/broadcom/b43/xmit.c
@@ -803,7 +803,7 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
         chanid = (chanstat & B43_RX_CHAN_ID) >> B43_RX_CHAN_ID_SHIFT;
         switch (chanstat & B43_RX_CHAN_PHYTYPE) {
         case B43_PHYTYPE_A:
-                status.band = IEEE80211_BAND_5GHZ;
+                status.band = NL80211_BAND_5GHZ;
                 B43_WARN_ON(1);
                 /* FIXME: We don't really know which value the "chanid" contains.
                  *        So the following assignment might be wrong. */
@@ -811,7 +811,7 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
                         ieee80211_channel_to_frequency(chanid, status.band);
                 break;
         case B43_PHYTYPE_G:
-                status.band = IEEE80211_BAND_2GHZ;
+                status.band = NL80211_BAND_2GHZ;
                 /* Somewhere between 478.104 and 508.1084 firmware for G-PHY
                  * has been modified to be compatible with N-PHY and others.
                  */
@@ -826,9 +826,9 @@ void b43_rx(struct b43_wldev *dev, struct sk_buff *skb, const void *_rxhdr)
                 /* chanid is the SHM channel cookie. Which is the plain
                  * channel number in b43. */
                 if (chanstat & B43_RX_CHAN_5GHZ)
-                        status.band = IEEE80211_BAND_5GHZ;
+                        status.band = NL80211_BAND_5GHZ;
                 else
-                        status.band = IEEE80211_BAND_2GHZ;
+                        status.band = NL80211_BAND_2GHZ;
                 status.freq =
                         ieee80211_channel_to_frequency(chanid, status.band);
                 break;
diff --git a/drivers/net/wireless/broadcom/b43legacy/main.c b/drivers/net/wireless/broadcom/b43legacy/main.c
index afc1fb3e38df..83770d2ea057 100644
--- a/drivers/net/wireless/broadcom/b43legacy/main.c
+++ b/drivers/net/wireless/broadcom/b43legacy/main.c
@@ -1056,7 +1056,7 @@ static void b43legacy_write_probe_resp_plcp(struct b43legacy_wldev *dev,
         b43legacy_generate_plcp_hdr(&plcp, size + FCS_LEN, rate->hw_value);
         dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                                dev->wl->vif,
-                                               IEEE80211_BAND_2GHZ,
+                                               NL80211_BAND_2GHZ,
                                                size,
                                                rate);
         /* Write PLCP in two parts and timing for packet transfer */
@@ -1122,7 +1122,7 @@ static const u8 *b43legacy_generate_probe_resp(struct b43legacy_wldev *dev,
                                          IEEE80211_STYPE_PROBE_RESP);
         dur = ieee80211_generic_frame_duration(dev->wl->hw,
                                                dev->wl->vif,
-                                               IEEE80211_BAND_2GHZ,
+                                               NL80211_BAND_2GHZ,
                                                *dest_size,
                                                rate);
         hdr->duration_id = dur;
@@ -2719,7 +2719,7 @@ static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
 
         /* Switch the PHY mode (if necessary). */
         switch (conf->chandef.chan->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 if (phy->type == B43legacy_PHYTYPE_B)
                         new_phymode = B43legacy_PHYMODE_B;
                 else
@@ -2792,7 +2792,7 @@ out_unlock_mutex:
 static void b43legacy_update_basic_rates(struct b43legacy_wldev *dev, u32 brates)
 {
         struct ieee80211_supported_band *sband =
-                dev->wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ];
+                dev->wl->hw->wiphy->bands[NL80211_BAND_2GHZ];
         struct ieee80211_rate *rate;
         int i;
         u16 basic, direct, offset, basic_offset, rateptr;
@@ -3630,13 +3630,13 @@ static int b43legacy_setup_modes(struct b43legacy_wldev *dev,
 
         phy->possible_phymodes = 0;
         if (have_bphy) {
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
                         &b43legacy_band_2GHz_BPHY;
                 phy->possible_phymodes |= B43legacy_PHYMODE_B;
         }
 
         if (have_gphy) {
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
                         &b43legacy_band_2GHz_GPHY;
                 phy->possible_phymodes |= B43legacy_PHYMODE_G;
         }
diff --git a/drivers/net/wireless/broadcom/b43legacy/xmit.c b/drivers/net/wireless/broadcom/b43legacy/xmit.c
index 34bf3f0b729f..35ccf400b02c 100644
--- a/drivers/net/wireless/broadcom/b43legacy/xmit.c
+++ b/drivers/net/wireless/broadcom/b43legacy/xmit.c
@@ -565,7 +565,7 @@ void b43legacy_rx(struct b43legacy_wldev *dev,
         switch (chanstat & B43legacy_RX_CHAN_PHYTYPE) {
         case B43legacy_PHYTYPE_B:
         case B43legacy_PHYTYPE_G:
-                status.band = IEEE80211_BAND_2GHZ;
+                status.band = NL80211_BAND_2GHZ;
                 status.freq = chanid + 2400;
                 break;
         default:
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c
index da0cdd313880..2fc0597f2cd0 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/bcmsdh.c
@@ -250,7 +250,7 @@ static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn,
                                     u32 addr, u8 regsz, void *data, bool write)
 {
         struct sdio_func *func;
-        int ret;
+        int ret = -EINVAL;
 
         brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
                   write, fn, addr, regsz);
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
index d5c2a27573b4..9a567e263bb1 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
@@ -144,7 +144,7 @@ static struct ieee80211_rate __wl_rates[] = {
 #define wl_a_rates_size         (wl_g_rates_size - 4)
 
 #define CHAN2G(_channel, _freq) {                               \
-        .band                   = IEEE80211_BAND_2GHZ,          \
+        .band                   = NL80211_BAND_2GHZ,            \
         .center_freq            = (_freq),                      \
         .hw_value               = (_channel),                   \
         .flags                  = IEEE80211_CHAN_DISABLED,      \
@@ -153,7 +153,7 @@ static struct ieee80211_rate __wl_rates[] = {
 }
 
 #define CHAN5G(_channel) {                                      \
-        .band                   = IEEE80211_BAND_5GHZ,          \
+        .band                   = NL80211_BAND_5GHZ,            \
         .center_freq            = 5000 + (5 * (_channel)),      \
         .hw_value               = (_channel),                   \
         .flags                  = IEEE80211_CHAN_DISABLED,      \
@@ -181,13 +181,13 @@ static struct ieee80211_channel __wl_5ghz_channels[] = {
  * above is added to the band during setup.
  */
 static const struct ieee80211_supported_band __wl_band_2ghz = {
-        .band = IEEE80211_BAND_2GHZ,
+        .band = NL80211_BAND_2GHZ,
         .bitrates = wl_g_rates,
         .n_bitrates = wl_g_rates_size,
 };
 
 static const struct ieee80211_supported_band __wl_band_5ghz = {
-        .band = IEEE80211_BAND_5GHZ,
+        .band = NL80211_BAND_5GHZ,
         .bitrates = wl_a_rates,
         .n_bitrates = wl_a_rates_size,
 };
@@ -292,13 +292,13 @@ static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf,
                 WARN_ON_ONCE(1);
         }
         switch (ch->chan->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 ch_inf.band = BRCMU_CHAN_BAND_2G;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 ch_inf.band = BRCMU_CHAN_BAND_5G;
                 break;
-        case IEEE80211_BAND_60GHZ:
+        case NL80211_BAND_60GHZ:
         default:
                 WARN_ON_ONCE(1);
         }
@@ -2679,9 +2679,9 @@ static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg,
         channel = bi->ctl_ch;
 
         if (channel <= CH_MAX_2G_CHANNEL)
-                band = wiphy->bands[IEEE80211_BAND_2GHZ];
+                band = wiphy->bands[NL80211_BAND_2GHZ];
         else
-                band = wiphy->bands[IEEE80211_BAND_5GHZ];
+                band = wiphy->bands[NL80211_BAND_5GHZ];
 
         freq = ieee80211_channel_to_frequency(channel, band->band);
         notify_channel = ieee80211_get_channel(wiphy, freq);
@@ -2788,9 +2788,9 @@ static s32 brcmf_inform_ibss(struct brcmf_cfg80211_info *cfg,
         cfg->d11inf.decchspec(&ch);
 
         if (ch.band == BRCMU_CHAN_BAND_2G)
-                band = wiphy->bands[IEEE80211_BAND_2GHZ];
+                band = wiphy->bands[NL80211_BAND_2GHZ];
         else
-                band = wiphy->bands[IEEE80211_BAND_5GHZ];
+                band = wiphy->bands[NL80211_BAND_5GHZ];
 
         freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
         cfg->channel = freq;
@@ -5215,9 +5215,9 @@ brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
         cfg->d11inf.decchspec(&ch);
 
         if (ch.band == BRCMU_CHAN_BAND_2G)
-                band = wiphy->bands[IEEE80211_BAND_2GHZ];
+                band = wiphy->bands[NL80211_BAND_2GHZ];
         else
-                band = wiphy->bands[IEEE80211_BAND_5GHZ];
+                band = wiphy->bands[NL80211_BAND_5GHZ];
 
         freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
         notify_channel = ieee80211_get_channel(wiphy, freq);
@@ -5707,11 +5707,11 @@ static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
         }
 
         wiphy = cfg_to_wiphy(cfg);
-        band = wiphy->bands[IEEE80211_BAND_2GHZ];
+        band = wiphy->bands[NL80211_BAND_2GHZ];
         if (band)
                 for (i = 0; i < band->n_channels; i++)
                         band->channels[i].flags = IEEE80211_CHAN_DISABLED;
-        band = wiphy->bands[IEEE80211_BAND_5GHZ];
+        band = wiphy->bands[NL80211_BAND_5GHZ];
         if (band)
                 for (i = 0; i < band->n_channels; i++)
                         band->channels[i].flags = IEEE80211_CHAN_DISABLED;
@@ -5722,9 +5722,9 @@ static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
                 cfg->d11inf.decchspec(&ch);
 
                 if (ch.band == BRCMU_CHAN_BAND_2G) {
-                        band = wiphy->bands[IEEE80211_BAND_2GHZ];
+                        band = wiphy->bands[NL80211_BAND_2GHZ];
                 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
-                        band = wiphy->bands[IEEE80211_BAND_5GHZ];
+                        band = wiphy->bands[NL80211_BAND_5GHZ];
                 } else {
                         brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
                         continue;
@@ -5839,7 +5839,7 @@ static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
                         return err;
                 }
 
-                band = cfg_to_wiphy(cfg)->bands[IEEE80211_BAND_2GHZ];
+                band = cfg_to_wiphy(cfg)->bands[NL80211_BAND_2GHZ];
                 list = (struct brcmf_chanspec_list *)pbuf;
                 num_chan = le32_to_cpu(list->count);
                 for (i = 0; i < num_chan; i++) {
@@ -5871,11 +5871,11 @@ static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
         band = WLC_BAND_2G;
         err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
         if (!err) {
-                bw_cap[IEEE80211_BAND_2GHZ] = band;
+                bw_cap[NL80211_BAND_2GHZ] = band;
                 band = WLC_BAND_5G;
                 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
                 if (!err) {
-                        bw_cap[IEEE80211_BAND_5GHZ] = band;
+                        bw_cap[NL80211_BAND_5GHZ] = band;
                         return;
                 }
                 WARN_ON(1);
@@ -5890,14 +5890,14 @@ static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
 
         switch (mimo_bwcap) {
         case WLC_N_BW_40ALL:
-                bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
+                bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
                 /* fall-thru */
         case WLC_N_BW_20IN2G_40IN5G:
-                bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
+                bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
                 /* fall-thru */
         case WLC_N_BW_20ALL:
-                bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
-                bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
+                bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
+                bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
                 break;
         default:
                 brcmf_err("invalid mimo_bw_cap value\n");
@@ -5938,7 +5938,7 @@ static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
         __le16 mcs_map;
 
         /* not allowed in 2.4G band */
-        if (band->band == IEEE80211_BAND_2GHZ)
+        if (band->band == NL80211_BAND_2GHZ)
                 return;
 
         band->vht_cap.vht_supported = true;
@@ -5997,8 +5997,8 @@ static int brcmf_setup_wiphybands(struct wiphy *wiphy)
                 brcmf_get_bwcap(ifp, bw_cap);
         }
         brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
-                  nmode, vhtmode, bw_cap[IEEE80211_BAND_2GHZ],
-                  bw_cap[IEEE80211_BAND_5GHZ]);
+                  nmode, vhtmode, bw_cap[NL80211_BAND_2GHZ],
+                  bw_cap[NL80211_BAND_5GHZ]);
 
         err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
         if (err) {
@@ -6321,7 +6321,7 @@ static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
                         }
 
                         band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
-                        wiphy->bands[IEEE80211_BAND_2GHZ] = band;
+                        wiphy->bands[NL80211_BAND_2GHZ] = band;
                 }
                 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
                         band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
@@ -6338,7 +6338,7 @@ static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
                         }
 
                         band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
-                        wiphy->bands[IEEE80211_BAND_5GHZ] = band;
+                        wiphy->bands[NL80211_BAND_5GHZ] = band;
                 }
         }
         err = brcmf_setup_wiphybands(wiphy);
@@ -6604,13 +6604,13 @@ static void brcmf_free_wiphy(struct wiphy *wiphy)
                         kfree(wiphy->iface_combinations[i].limits);
         }
         kfree(wiphy->iface_combinations);
-        if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
-                kfree(wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
-                kfree(wiphy->bands[IEEE80211_BAND_2GHZ]);
+        if (wiphy->bands[NL80211_BAND_2GHZ]) {
+                kfree(wiphy->bands[NL80211_BAND_2GHZ]->channels);
+                kfree(wiphy->bands[NL80211_BAND_2GHZ]);
         }
-        if (wiphy->bands[IEEE80211_BAND_5GHZ]) {
-                kfree(wiphy->bands[IEEE80211_BAND_5GHZ]->channels);
-                kfree(wiphy->bands[IEEE80211_BAND_5GHZ]);
+        if (wiphy->bands[NL80211_BAND_5GHZ]) {
+                kfree(wiphy->bands[NL80211_BAND_5GHZ]->channels);
+                kfree(wiphy->bands[NL80211_BAND_5GHZ]);
         }
         wiphy_free(wiphy);
 }
@@ -6698,8 +6698,8 @@ struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
          * cfg80211 here that we do and have it decide we can enable
          * it. But first check if device does support 2G operation.
          */
-        if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
-                cap = &wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap.cap;
+        if (wiphy->bands[NL80211_BAND_2GHZ]) {
+                cap = &wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap;
                 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
         }
         err = wiphy_register(wiphy);
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
index b5a49e564f25..c2ac91df35ed 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
@@ -1430,8 +1430,8 @@ int brcmf_p2p_notify_action_frame_rx(struct brcmf_if *ifp,
 
         freq = ieee80211_channel_to_frequency(ch.chnum,
                                               ch.band == BRCMU_CHAN_BAND_2G ?
-                                              IEEE80211_BAND_2GHZ :
-                                              IEEE80211_BAND_5GHZ);
+                                              NL80211_BAND_2GHZ :
+                                              NL80211_BAND_5GHZ);
 
         wdev = &ifp->vif->wdev;
         cfg80211_rx_mgmt(wdev, freq, 0, (u8 *)mgmt_frame, mgmt_frame_len, 0);
@@ -1900,8 +1900,8 @@ s32 brcmf_p2p_notify_rx_mgmt_p2p_probereq(struct brcmf_if *ifp,
         mgmt_frame_len = e->datalen - sizeof(*rxframe);
         freq = ieee80211_channel_to_frequency(ch.chnum,
                                               ch.band == BRCMU_CHAN_BAND_2G ?
-                                              IEEE80211_BAND_2GHZ :
-                                              IEEE80211_BAND_5GHZ);
+                                              NL80211_BAND_2GHZ :
+                                              NL80211_BAND_5GHZ);
 
         cfg80211_rx_mgmt(&vif->wdev, freq, 0, mgmt_frame, mgmt_frame_len, 0);
 
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
index 43fd3f402eba..48d7467d270e 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/sdio.c
@@ -535,9 +535,6 @@ static int qcount[NUMPRIO];
 
 #define RETRYCHAN(chan) ((chan) == SDPCM_EVENT_CHANNEL)
 
-/* Retry count for register access failures */
-static const uint retry_limit = 2;
-
 /* Limit on rounding up frames */
 static const uint max_roundup = 512;
 
@@ -3261,7 +3258,7 @@ static int brcmf_sdio_download_firmware(struct brcmf_sdio *bus,
                                         const struct firmware *fw,
                                         void *nvram, u32 nvlen)
 {
-        int bcmerror = -EFAULT;
+        int bcmerror;
         u32 rstvec;
 
         sdio_claim_host(bus->sdiodev->func[1]);
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/channel.c b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/channel.c
index 38bd5890bd53..3a03287fa912 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/channel.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/channel.c
@@ -636,7 +636,7 @@ static void brcms_reg_apply_radar_flags(struct wiphy *wiphy)
         struct ieee80211_channel *ch;
         int i;
 
-        sband = wiphy->bands[IEEE80211_BAND_5GHZ];
+        sband = wiphy->bands[NL80211_BAND_5GHZ];
         if (!sband)
                 return;
 
@@ -666,7 +666,7 @@ brcms_reg_apply_beaconing_flags(struct wiphy *wiphy,
         const struct ieee80211_reg_rule *rule;
         int band, i;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 sband = wiphy->bands[band];
                 if (!sband)
                         continue;
@@ -710,7 +710,7 @@ static void brcms_reg_notifier(struct wiphy *wiphy,
                 brcms_reg_apply_beaconing_flags(wiphy, request->initiator);
 
         /* Disable radio if all channels disallowed by regulatory */
-        for (band = 0; !ch_found && band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; !ch_found && band < NUM_NL80211_BANDS; band++) {
                 sband = wiphy->bands[band];
                 if (!sband)
                         continue;
@@ -755,9 +755,9 @@ void brcms_c_regd_init(struct brcms_c_info *wlc)
                                               &sup_chan);
 
                 if (band_idx == BAND_2G_INDEX)
-                        sband = wiphy->bands[IEEE80211_BAND_2GHZ];
+                        sband = wiphy->bands[NL80211_BAND_2GHZ];
                 else
-                        sband = wiphy->bands[IEEE80211_BAND_5GHZ];
+                        sband = wiphy->bands[NL80211_BAND_5GHZ];
 
                 for (i = 0; i < sband->n_channels; i++) {
                         ch = &sband->channels[i];
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c
index 61ae2768132a..7c2a9a9bc372 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/mac80211_if.c
@@ -49,7 +49,7 @@
         FIF_PSPOLL)
 
 #define CHAN2GHZ(channel, freqency, chflags)  { \
-        .band = IEEE80211_BAND_2GHZ, \
+        .band = NL80211_BAND_2GHZ, \
         .center_freq = (freqency), \
         .hw_value = (channel), \
         .flags = chflags, \
@@ -58,7 +58,7 @@
 }
 
 #define CHAN5GHZ(channel, chflags)  { \
-        .band = IEEE80211_BAND_5GHZ, \
+        .band = NL80211_BAND_5GHZ, \
         .center_freq = 5000 + 5*(channel), \
         .hw_value = (channel), \
         .flags = chflags, \
@@ -217,7 +217,7 @@ static struct ieee80211_rate legacy_ratetable[] = {
 };
 
 static const struct ieee80211_supported_band brcms_band_2GHz_nphy_template = {
-        .band = IEEE80211_BAND_2GHZ,
+        .band = NL80211_BAND_2GHZ,
         .channels = brcms_2ghz_chantable,
         .n_channels = ARRAY_SIZE(brcms_2ghz_chantable),
         .bitrates = legacy_ratetable,
@@ -238,7 +238,7 @@ static const struct ieee80211_supported_band brcms_band_2GHz_nphy_template = {
 };
 
 static const struct ieee80211_supported_band brcms_band_5GHz_nphy_template = {
-        .band = IEEE80211_BAND_5GHZ,
+        .band = NL80211_BAND_5GHZ,
         .channels = brcms_5ghz_nphy_chantable,
         .n_channels = ARRAY_SIZE(brcms_5ghz_nphy_chantable),
         .bitrates = legacy_ratetable + BRCMS_LEGACY_5G_RATE_OFFSET,
@@ -1026,8 +1026,8 @@ static int ieee_hw_rate_init(struct ieee80211_hw *hw)
         int has_5g = 0;
         u16 phy_type;
 
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
-        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
+        hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
 
         phy_type = brcms_c_get_phy_type(wl->wlc, 0);
         if (phy_type == PHY_TYPE_N || phy_type == PHY_TYPE_LCN) {
@@ -1038,7 +1038,7 @@ static int ieee_hw_rate_init(struct ieee80211_hw *hw)
                         band->ht_cap.mcs.rx_mask[1] = 0;
                         band->ht_cap.mcs.rx_highest = cpu_to_le16(72);
                 }
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
+                hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
         } else {
                 return -EPERM;
         }
@@ -1049,7 +1049,7 @@ static int ieee_hw_rate_init(struct ieee80211_hw *hw)
                 if (phy_type == PHY_TYPE_N || phy_type == PHY_TYPE_LCN) {
                         band = &wlc->bandstate[BAND_5G_INDEX]->band;
                         *band = brcms_band_5GHz_nphy_template;
-                        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
+                        hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
                 } else {
                         return -EPERM;
                 }
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
index 218cbc8bf3a7..e16ee60639f5 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmsmac/main.c
@@ -7076,7 +7076,7 @@ prep_mac80211_status(struct brcms_c_info *wlc, struct d11rxhdr *rxh,
         channel = BRCMS_CHAN_CHANNEL(rxh->RxChan);
 
         rx_status->band =
-                channel > 14 ? IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
+                channel > 14 ? NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
         rx_status->freq =
                 ieee80211_channel_to_frequency(channel, rx_status->band);
 
@@ -7143,7 +7143,7 @@ prep_mac80211_status(struct brcms_c_info *wlc, struct d11rxhdr *rxh,
                  * a subset of the 2.4G rates. See bitrates field
                  * of brcms_band_5GHz_nphy (in mac80211_if.c).
                  */
-                if (rx_status->band == IEEE80211_BAND_5GHZ)
+                if (rx_status->band == NL80211_BAND_5GHZ)
                         rx_status->rate_idx -= BRCMS_LEGACY_5G_RATE_OFFSET;
 
                 /* Determine short preamble and rate_idx */
diff --git a/drivers/net/wireless/cisco/airo.c b/drivers/net/wireless/cisco/airo.c
index d2353f6e5214..4bd9e2b97e86 100644
--- a/drivers/net/wireless/cisco/airo.c
+++ b/drivers/net/wireless/cisco/airo.c
@@ -5836,7 +5836,7 @@ static int airo_get_freq(struct net_device *dev,
         ch = le16_to_cpu(status_rid.channel);
         if((ch > 0) && (ch < 15)) {
                 fwrq->m = 100000 *
-                        ieee80211_channel_to_frequency(ch, IEEE80211_BAND_2GHZ);
+                        ieee80211_channel_to_frequency(ch, NL80211_BAND_2GHZ);
                 fwrq->e = 1;
         } else {
                 fwrq->m = ch;
@@ -6894,7 +6894,7 @@ static int airo_get_range(struct net_device *dev,
         for(i = 0; i < 14; i++) {
                 range->freq[k].i = i + 1; /* List index */
                 range->freq[k].m = 100000 *
-                     ieee80211_channel_to_frequency(i + 1, IEEE80211_BAND_2GHZ);
+                     ieee80211_channel_to_frequency(i + 1, NL80211_BAND_2GHZ);
                 range->freq[k++].e = 1; /* Values in MHz -> * 10^5 * 10 */
         }
         range->num_frequency = k;
@@ -7302,7 +7302,7 @@ static inline char *airo_translate_scan(struct net_device *dev,
         iwe.cmd = SIOCGIWFREQ;
         iwe.u.freq.m = le16_to_cpu(bss->dsChannel);
         iwe.u.freq.m = 100000 *
-              ieee80211_channel_to_frequency(iwe.u.freq.m, IEEE80211_BAND_2GHZ);
+              ieee80211_channel_to_frequency(iwe.u.freq.m, NL80211_BAND_2GHZ);
         iwe.u.freq.e = 1;
         current_ev = iwe_stream_add_event(info, current_ev, end_buf,
                                           &iwe, IW_EV_FREQ_LEN);
diff --git a/drivers/net/wireless/intel/ipw2x00/ipw2100.c b/drivers/net/wireless/intel/ipw2x00/ipw2100.c
index f93a7f71c047..e1e42ed6c412 100644
--- a/drivers/net/wireless/intel/ipw2x00/ipw2100.c
+++ b/drivers/net/wireless/intel/ipw2x00/ipw2100.c
@@ -1913,7 +1913,7 @@ static int ipw2100_wdev_init(struct net_device *dev)
         if (geo->bg_channels) {
                 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
 
-                bg_band->band = IEEE80211_BAND_2GHZ;
+                bg_band->band = NL80211_BAND_2GHZ;
                 bg_band->n_channels = geo->bg_channels;
                 bg_band->channels = kcalloc(geo->bg_channels,
                                             sizeof(struct ieee80211_channel),
@@ -1924,7 +1924,7 @@ static int ipw2100_wdev_init(struct net_device *dev)
                 }
                 /* translate geo->bg to bg_band.channels */
                 for (i = 0; i < geo->bg_channels; i++) {
-                        bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
+                        bg_band->channels[i].band = NL80211_BAND_2GHZ;
                         bg_band->channels[i].center_freq = geo->bg[i].freq;
                         bg_band->channels[i].hw_value = geo->bg[i].channel;
                         bg_band->channels[i].max_power = geo->bg[i].max_power;
@@ -1945,7 +1945,7 @@ static int ipw2100_wdev_init(struct net_device *dev)
                 bg_band->bitrates = ipw2100_bg_rates;
                 bg_band->n_bitrates = RATE_COUNT;
 
-                wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
+                wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
         }
 
         wdev->wiphy->cipher_suites = ipw_cipher_suites;
@@ -3521,7 +3521,7 @@ static void ipw2100_msg_free(struct ipw2100_priv *priv)
 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
                         char *buf)
 {
-        struct pci_dev *pci_dev = container_of(d, struct pci_dev, dev);
+        struct pci_dev *pci_dev = to_pci_dev(d);
         char *out = buf;
         int i, j;
         u32 val;
diff --git a/drivers/net/wireless/intel/ipw2x00/ipw2200.c b/drivers/net/wireless/intel/ipw2x00/ipw2200.c
index ed0adaf1eec4..dac13cf42e9f 100644
--- a/drivers/net/wireless/intel/ipw2x00/ipw2200.c
+++ b/drivers/net/wireless/intel/ipw2x00/ipw2200.c
@@ -11359,7 +11359,7 @@ static int ipw_wdev_init(struct net_device *dev)
         if (geo->bg_channels) {
                 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
 
-                bg_band->band = IEEE80211_BAND_2GHZ;
+                bg_band->band = NL80211_BAND_2GHZ;
                 bg_band->n_channels = geo->bg_channels;
                 bg_band->channels = kcalloc(geo->bg_channels,
                                             sizeof(struct ieee80211_channel),
@@ -11370,7 +11370,7 @@ static int ipw_wdev_init(struct net_device *dev)
                 }
                 /* translate geo->bg to bg_band.channels */
                 for (i = 0; i < geo->bg_channels; i++) {
-                        bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
+                        bg_band->channels[i].band = NL80211_BAND_2GHZ;
                         bg_band->channels[i].center_freq = geo->bg[i].freq;
                         bg_band->channels[i].hw_value = geo->bg[i].channel;
                         bg_band->channels[i].max_power = geo->bg[i].max_power;
@@ -11391,14 +11391,14 @@ static int ipw_wdev_init(struct net_device *dev)
                 bg_band->bitrates = ipw2200_bg_rates;
                 bg_band->n_bitrates = ipw2200_num_bg_rates;
 
-                wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
+                wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
         }
 
         /* fill-out priv->ieee->a_band */
         if (geo->a_channels) {
                 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
 
-                a_band->band = IEEE80211_BAND_5GHZ;
+                a_band->band = NL80211_BAND_5GHZ;
                 a_band->n_channels = geo->a_channels;
                 a_band->channels = kcalloc(geo->a_channels,
                                            sizeof(struct ieee80211_channel),
@@ -11409,7 +11409,7 @@ static int ipw_wdev_init(struct net_device *dev)
                 }
                 /* translate geo->a to a_band.channels */
                 for (i = 0; i < geo->a_channels; i++) {
-                        a_band->channels[i].band = IEEE80211_BAND_5GHZ;
+                        a_band->channels[i].band = NL80211_BAND_5GHZ;
                         a_band->channels[i].center_freq = geo->a[i].freq;
                         a_band->channels[i].hw_value = geo->a[i].channel;
                         a_band->channels[i].max_power = geo->a[i].max_power;
@@ -11430,7 +11430,7 @@ static int ipw_wdev_init(struct net_device *dev)
                 a_band->bitrates = ipw2200_a_rates;
                 a_band->n_bitrates = ipw2200_num_a_rates;
 
-                wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = a_band;
+                wdev->wiphy->bands[NL80211_BAND_5GHZ] = a_band;
         }
 
         wdev->wiphy->cipher_suites = ipw_cipher_suites;
diff --git a/drivers/net/wireless/intel/iwlegacy/3945-mac.c b/drivers/net/wireless/intel/iwlegacy/3945-mac.c
index af1b3e6839fa..466912eb2d87 100644
--- a/drivers/net/wireless/intel/iwlegacy/3945-mac.c
+++ b/drivers/net/wireless/intel/iwlegacy/3945-mac.c
@@ -1547,7 +1547,7 @@ il3945_irq_tasklet(struct il_priv *il)
 }
 
 static int
-il3945_get_channels_for_scan(struct il_priv *il, enum ieee80211_band band,
+il3945_get_channels_for_scan(struct il_priv *il, enum nl80211_band band,
                              u8 is_active, u8 n_probes,
                              struct il3945_scan_channel *scan_ch,
                              struct ieee80211_vif *vif)
@@ -1618,7 +1618,7 @@ il3945_get_channels_for_scan(struct il_priv *il, enum ieee80211_band band,
                 /* scan_pwr_info->tpc.dsp_atten; */
 
                 /*scan_pwr_info->tpc.tx_gain; */
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
                 else {
                         scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
@@ -2534,7 +2534,7 @@ il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
         };
         struct il3945_scan_cmd *scan;
         u8 n_probes = 0;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         bool is_active = false;
         int ret;
         u16 len;
@@ -2615,14 +2615,14 @@ il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
         /* flags + rate selection */
 
         switch (il->scan_band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
                 scan->tx_cmd.rate = RATE_1M_PLCP;
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 scan->tx_cmd.rate = RATE_6M_PLCP;
-                band = IEEE80211_BAND_5GHZ;
+                band = NL80211_BAND_5GHZ;
                 break;
         default:
                 IL_WARN("Invalid scan band\n");
@@ -3507,7 +3507,7 @@ il3945_init_drv(struct il_priv *il)
 
         il->ieee_channels = NULL;
         il->ieee_rates = NULL;
-        il->band = IEEE80211_BAND_2GHZ;
+        il->band = NL80211_BAND_2GHZ;
 
         il->iw_mode = NL80211_IFTYPE_STATION;
         il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
@@ -3582,13 +3582,13 @@ il3945_setup_mac(struct il_priv *il)
         /* Default value; 4 EDCA QOS priorities */
         hw->queues = 4;
 
-        if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
-                il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                    &il->bands[IEEE80211_BAND_2GHZ];
+        if (il->bands[NL80211_BAND_2GHZ].n_channels)
+                il->hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                    &il->bands[NL80211_BAND_2GHZ];
 
-        if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
-                il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                    &il->bands[IEEE80211_BAND_5GHZ];
+        if (il->bands[NL80211_BAND_5GHZ].n_channels)
+                il->hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                    &il->bands[NL80211_BAND_5GHZ];
 
         il_leds_init(il);
 
@@ -3761,7 +3761,7 @@ il3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto out_release_irq;
         }
 
-        il_set_rxon_channel(il, &il->bands[IEEE80211_BAND_2GHZ].channels[5]);
+        il_set_rxon_channel(il, &il->bands[NL80211_BAND_2GHZ].channels[5]);
         il3945_setup_deferred_work(il);
         il3945_setup_handlers(il);
         il_power_initialize(il);
diff --git a/drivers/net/wireless/intel/iwlegacy/3945-rs.c b/drivers/net/wireless/intel/iwlegacy/3945-rs.c
index 76b0729ade17..03ad9b8b55f4 100644
--- a/drivers/net/wireless/intel/iwlegacy/3945-rs.c
+++ b/drivers/net/wireless/intel/iwlegacy/3945-rs.c
@@ -97,7 +97,7 @@ static struct il3945_tpt_entry il3945_tpt_table_g[] = {
 #define RATE_RETRY_TH           15
 
 static u8
-il3945_get_rate_idx_by_rssi(s32 rssi, enum ieee80211_band band)
+il3945_get_rate_idx_by_rssi(s32 rssi, enum nl80211_band band)
 {
         u32 idx = 0;
         u32 table_size = 0;
@@ -107,11 +107,11 @@ il3945_get_rate_idx_by_rssi(s32 rssi, enum ieee80211_band band)
                 rssi = IL_MIN_RSSI_VAL;
 
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 tpt_table = il3945_tpt_table_g;
                 table_size = ARRAY_SIZE(il3945_tpt_table_g);
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 tpt_table = il3945_tpt_table_a;
                 table_size = ARRAY_SIZE(il3945_tpt_table_a);
                 break;
@@ -380,7 +380,7 @@ il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
 
         il->_3945.sta_supp_rates = sta->supp_rates[sband->band];
         /* For 5 GHz band it start at IL_FIRST_OFDM_RATE */
-        if (sband->band == IEEE80211_BAND_5GHZ) {
+        if (sband->band == NL80211_BAND_5GHZ) {
                 rs_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
                 il->_3945.sta_supp_rates <<= IL_FIRST_OFDM_RATE;
         }
@@ -541,7 +541,7 @@ il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *sband,
 
 static u16
 il3945_get_adjacent_rate(struct il3945_rs_sta *rs_sta, u8 idx, u16 rate_mask,
-                         enum ieee80211_band band)
+                         enum nl80211_band band)
 {
         u8 high = RATE_INVALID;
         u8 low = RATE_INVALID;
@@ -549,7 +549,7 @@ il3945_get_adjacent_rate(struct il3945_rs_sta *rs_sta, u8 idx, u16 rate_mask,
 
         /* 802.11A walks to the next literal adjacent rate in
          * the rate table */
-        if (unlikely(band == IEEE80211_BAND_5GHZ)) {
+        if (unlikely(band == NL80211_BAND_5GHZ)) {
                 int i;
                 u32 mask;
 
@@ -657,14 +657,14 @@ il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
 
         /* get user max rate if set */
         max_rate_idx = txrc->max_rate_idx;
-        if (sband->band == IEEE80211_BAND_5GHZ && max_rate_idx != -1)
+        if (sband->band == NL80211_BAND_5GHZ && max_rate_idx != -1)
                 max_rate_idx += IL_FIRST_OFDM_RATE;
         if (max_rate_idx < 0 || max_rate_idx >= RATE_COUNT)
                 max_rate_idx = -1;
 
         idx = min(rs_sta->last_txrate_idx & 0xffff, RATE_COUNT_3945 - 1);
 
-        if (sband->band == IEEE80211_BAND_5GHZ)
+        if (sband->band == NL80211_BAND_5GHZ)
                 rate_mask = rate_mask << IL_FIRST_OFDM_RATE;
 
         spin_lock_irqsave(&rs_sta->lock, flags);
@@ -806,7 +806,7 @@ il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
 
 out:
 
-        if (sband->band == IEEE80211_BAND_5GHZ) {
+        if (sband->band == NL80211_BAND_5GHZ) {
                 if (WARN_ON_ONCE(idx < IL_FIRST_OFDM_RATE))
                         idx = IL_FIRST_OFDM_RATE;
                 rs_sta->last_txrate_idx = idx;
@@ -935,7 +935,7 @@ il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
 
         rs_sta->tgg = 0;
         switch (il->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 /* TODO: this always does G, not a regression */
                 if (il->active.flags & RXON_FLG_TGG_PROTECT_MSK) {
                         rs_sta->tgg = 1;
@@ -943,7 +943,7 @@ il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
                 } else
                         rs_sta->expected_tpt = il3945_expected_tpt_g;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 rs_sta->expected_tpt = il3945_expected_tpt_a;
                 break;
         default:
diff --git a/drivers/net/wireless/intel/iwlegacy/3945.c b/drivers/net/wireless/intel/iwlegacy/3945.c
index 93bdf684babe..7bcedbb53d94 100644
--- a/drivers/net/wireless/intel/iwlegacy/3945.c
+++ b/drivers/net/wireless/intel/iwlegacy/3945.c
@@ -255,13 +255,13 @@ il3945_rs_next_rate(struct il_priv *il, int rate)
         int next_rate = il3945_get_prev_ieee_rate(rate);
 
         switch (il->band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 if (rate == RATE_12M_IDX)
                         next_rate = RATE_9M_IDX;
                 else if (rate == RATE_6M_IDX)
                         next_rate = RATE_6M_IDX;
                 break;
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 if (!(il->_3945.sta_supp_rates & IL_OFDM_RATES_MASK) &&
                     il_is_associated(il)) {
                         if (rate == RATE_11M_IDX)
@@ -349,7 +349,7 @@ il3945_hdl_tx(struct il_priv *il, struct il_rx_buf *rxb)
 
         /* Fill the MRR chain with some info about on-chip retransmissions */
         rate_idx = il3945_hwrate_to_plcp_idx(tx_resp->rate);
-        if (info->band == IEEE80211_BAND_5GHZ)
+        if (info->band == NL80211_BAND_5GHZ)
                 rate_idx -= IL_FIRST_OFDM_RATE;
 
         fail = tx_resp->failure_frame;
@@ -554,14 +554,14 @@ il3945_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
         rx_status.mactime = le64_to_cpu(rx_end->timestamp);
         rx_status.band =
             (rx_hdr->
-             phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
-            IEEE80211_BAND_5GHZ;
+             phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? NL80211_BAND_2GHZ :
+            NL80211_BAND_5GHZ;
         rx_status.freq =
             ieee80211_channel_to_frequency(le16_to_cpu(rx_hdr->channel),
                                            rx_status.band);
 
         rx_status.rate_idx = il3945_hwrate_to_plcp_idx(rx_hdr->rate);
-        if (rx_status.band == IEEE80211_BAND_5GHZ)
+        if (rx_status.band == NL80211_BAND_5GHZ)
                 rx_status.rate_idx -= IL_FIRST_OFDM_RATE;
 
         rx_status.antenna =
@@ -1409,7 +1409,7 @@ il3945_send_tx_power(struct il_priv *il)
 
         chan = le16_to_cpu(il->active.channel);
 
-        txpower.band = (il->band == IEEE80211_BAND_5GHZ) ? 0 : 1;
+        txpower.band = (il->band == NL80211_BAND_5GHZ) ? 0 : 1;
         ch_info = il_get_channel_info(il, il->band, chan);
         if (!ch_info) {
                 IL_ERR("Failed to get channel info for channel %d [%d]\n", chan,
@@ -2310,7 +2310,7 @@ il3945_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
 
                 il3945_sync_sta(il, vif_priv->ibss_bssid_sta_id,
                                 (il->band ==
-                                 IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP :
+                                 NL80211_BAND_5GHZ) ? RATE_6M_PLCP :
                                 RATE_1M_PLCP);
                 il3945_rate_scale_init(il->hw, vif_priv->ibss_bssid_sta_id);
 
@@ -2343,7 +2343,7 @@ il3945_init_hw_rate_table(struct il_priv *il)
         }
 
         switch (il->band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 D_RATE("Select A mode rate scale\n");
                 /* If one of the following CCK rates is used,
                  * have it fall back to the 6M OFDM rate */
@@ -2359,7 +2359,7 @@ il3945_init_hw_rate_table(struct il_priv *il)
                     il3945_rates[IL_FIRST_OFDM_RATE].table_rs_idx;
                 break;
 
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 D_RATE("Select B/G mode rate scale\n");
                 /* If an OFDM rate is used, have it fall back to the
                  * 1M CCK rates */
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-mac.c b/drivers/net/wireless/intel/iwlegacy/4965-mac.c
index b75f4ef3cdc7..a91d170a614b 100644
--- a/drivers/net/wireless/intel/iwlegacy/4965-mac.c
+++ b/drivers/net/wireless/intel/iwlegacy/4965-mac.c
@@ -457,7 +457,7 @@ il4965_rxq_stop(struct il_priv *il)
 }
 
 int
-il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
+il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum nl80211_band band)
 {
         int idx = 0;
         int band_offset = 0;
@@ -468,7 +468,7 @@ il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
                 return idx;
                 /* Legacy rate format, search for match in table */
         } else {
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         band_offset = IL_FIRST_OFDM_RATE;
                 for (idx = band_offset; idx < RATE_COUNT_LEGACY; idx++)
                         if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
@@ -688,8 +688,8 @@ il4965_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
         rx_status.mactime = le64_to_cpu(phy_res->timestamp);
         rx_status.band =
             (phy_res->
-             phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
-            IEEE80211_BAND_5GHZ;
+             phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? NL80211_BAND_2GHZ :
+            NL80211_BAND_5GHZ;
         rx_status.freq =
             ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
                                            rx_status.band);
@@ -766,7 +766,7 @@ il4965_hdl_rx_phy(struct il_priv *il, struct il_rx_buf *rxb)
 
 static int
 il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
-                             enum ieee80211_band band, u8 is_active,
+                             enum nl80211_band band, u8 is_active,
                              u8 n_probes, struct il_scan_channel *scan_ch)
 {
         struct ieee80211_channel *chan;
@@ -822,7 +822,7 @@ il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
                  * power level:
                  * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
                  */
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
                 else
                         scan_ch->tx_gain = ((1 << 5) | (5 << 3));
@@ -870,7 +870,7 @@ il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
         u32 rate_flags = 0;
         u16 cmd_len;
         u16 rx_chain = 0;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u8 n_probes = 0;
         u8 rx_ant = il->hw_params.valid_rx_ant;
         u8 rate;
@@ -944,7 +944,7 @@ il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
         scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 
         switch (il->scan_band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
                 chan_mod =
                     le32_to_cpu(il->active.flags & RXON_FLG_CHANNEL_MODE_MSK) >>
@@ -956,7 +956,7 @@ il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
                         rate_flags = RATE_MCS_CCK_MSK;
                 }
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 rate = RATE_6M_PLCP;
                 break;
         default:
@@ -1590,7 +1590,7 @@ il4965_tx_cmd_build_rate(struct il_priv *il,
             || rate_idx > RATE_COUNT_LEGACY)
                 rate_idx = rate_lowest_index(&il->bands[info->band], sta);
         /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
-        if (info->band == IEEE80211_BAND_5GHZ)
+        if (info->band == NL80211_BAND_5GHZ)
                 rate_idx += IL_FIRST_OFDM_RATE;
         /* Get PLCP rate for tx_cmd->rate_n_flags */
         rate_plcp = il_rates[rate_idx].plcp;
@@ -3051,7 +3051,7 @@ il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
         }
         /* Set up the rate scaling to start at selected rate, fall back
          * all the way down to 1M in IEEE order, and then spin on 1M */
-        if (il->band == IEEE80211_BAND_5GHZ)
+        if (il->band == NL80211_BAND_5GHZ)
                 r = RATE_6M_IDX;
         else
                 r = RATE_1M_IDX;
@@ -5553,6 +5553,7 @@ __il4965_up(struct il_priv *il)
 
         il4965_prepare_card_hw(il);
         if (!il->hw_ready) {
+                il_dealloc_bcast_stations(il);
                 IL_ERR("HW not ready\n");
                 return -EIO;
         }
@@ -5564,6 +5565,7 @@ __il4965_up(struct il_priv *il)
                 set_bit(S_RFKILL, &il->status);
                 wiphy_rfkill_set_hw_state(il->hw->wiphy, true);
 
+                il_dealloc_bcast_stations(il);
                 il_enable_rfkill_int(il);
                 IL_WARN("Radio disabled by HW RF Kill switch\n");
                 return 0;
@@ -5577,6 +5579,7 @@ __il4965_up(struct il_priv *il)
         ret = il4965_hw_nic_init(il);
         if (ret) {
                 IL_ERR("Unable to init nic\n");
+                il_dealloc_bcast_stations(il);
                 return ret;
         }
 
@@ -5787,12 +5790,12 @@ il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length)
 
         hw->max_listen_interval = IL_CONN_MAX_LISTEN_INTERVAL;
 
-        if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
-                il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                    &il->bands[IEEE80211_BAND_2GHZ];
-        if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
-                il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                    &il->bands[IEEE80211_BAND_5GHZ];
+        if (il->bands[NL80211_BAND_2GHZ].n_channels)
+                il->hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                    &il->bands[NL80211_BAND_2GHZ];
+        if (il->bands[NL80211_BAND_5GHZ].n_channels)
+                il->hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                    &il->bands[NL80211_BAND_5GHZ];
 
         il_leds_init(il);
 
@@ -6365,7 +6368,7 @@ il4965_init_drv(struct il_priv *il)
 
         il->ieee_channels = NULL;
         il->ieee_rates = NULL;
-        il->band = IEEE80211_BAND_2GHZ;
+        il->band = NL80211_BAND_2GHZ;
 
         il->iw_mode = NL80211_IFTYPE_STATION;
         il->current_ht_config.smps = IEEE80211_SMPS_STATIC;
@@ -6477,7 +6480,7 @@ il4965_set_hw_params(struct il_priv *il)
         il->hw_params.max_data_size = IL49_RTC_DATA_SIZE;
         il->hw_params.max_inst_size = IL49_RTC_INST_SIZE;
         il->hw_params.max_bsm_size = BSM_SRAM_SIZE;
-        il->hw_params.ht40_channel = BIT(IEEE80211_BAND_5GHZ);
+        il->hw_params.ht40_channel = BIT(NL80211_BAND_5GHZ);
 
         il->hw_params.rx_wrt_ptr_reg = FH49_RSCSR_CHNL0_WPTR;
 
diff --git a/drivers/net/wireless/intel/iwlegacy/4965-rs.c b/drivers/net/wireless/intel/iwlegacy/4965-rs.c
index bac60b2bc3f0..a867ae7f4095 100644
--- a/drivers/net/wireless/intel/iwlegacy/4965-rs.c
+++ b/drivers/net/wireless/intel/iwlegacy/4965-rs.c
@@ -549,7 +549,7 @@ il4965_rate_n_flags_from_tbl(struct il_priv *il, struct il_scale_tbl_info *tbl,
  */
 static int
 il4965_rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
-                                enum ieee80211_band band,
+                                enum nl80211_band band,
                                 struct il_scale_tbl_info *tbl, int *rate_idx)
 {
         u32 ant_msk = (rate_n_flags & RATE_MCS_ANT_ABC_MSK);
@@ -574,7 +574,7 @@ il4965_rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
         /* legacy rate format */
         if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
                 if (il4965_num_of_ant == 1) {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 tbl->lq_type = LQ_A;
                         else
                                 tbl->lq_type = LQ_G;
@@ -743,7 +743,7 @@ il4965_rs_get_lower_rate(struct il_lq_sta *lq_sta,
         if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_idx)) {
                 switch_to_legacy = 1;
                 scale_idx = rs_ht_to_legacy[scale_idx];
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         tbl->lq_type = LQ_A;
                 else
                         tbl->lq_type = LQ_G;
@@ -762,7 +762,7 @@ il4965_rs_get_lower_rate(struct il_lq_sta *lq_sta,
         /* Mask with station rate restriction */
         if (is_legacy(tbl->lq_type)) {
                 /* supp_rates has no CCK bits in A mode */
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         rate_mask =
                             (u16) (rate_mask &
                                    (lq_sta->supp_rates << IL_FIRST_OFDM_RATE));
@@ -851,7 +851,7 @@ il4965_rs_tx_status(void *il_r, struct ieee80211_supported_band *sband,
         table = &lq_sta->lq;
         tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
         il4965_rs_get_tbl_info_from_mcs(tx_rate, il->band, &tbl_type, &rs_idx);
-        if (il->band == IEEE80211_BAND_5GHZ)
+        if (il->band == NL80211_BAND_5GHZ)
                 rs_idx -= IL_FIRST_OFDM_RATE;
         mac_flags = info->status.rates[0].flags;
         mac_idx = info->status.rates[0].idx;
@@ -864,7 +864,7 @@ il4965_rs_tx_status(void *il_r, struct ieee80211_supported_band *sband,
                  * mac80211 HT idx is always zero-idxed; we need to move
                  * HT OFDM rates after CCK rates in 2.4 GHz band
                  */
-                if (il->band == IEEE80211_BAND_2GHZ)
+                if (il->band == NL80211_BAND_2GHZ)
                         mac_idx += IL_FIRST_OFDM_RATE;
         }
         /* Here we actually compare this rate to the latest LQ command */
@@ -1816,7 +1816,7 @@ il4965_rs_rate_scale_perform(struct il_priv *il, struct sk_buff *skb,
 
         /* mask with station rate restriction */
         if (is_legacy(tbl->lq_type)) {
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         /* supp_rates has no CCK bits in A mode */
                         rate_scale_idx_msk =
                             (u16) (rate_mask &
@@ -2212,7 +2212,7 @@ il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
         /* Get max rate if user set max rate */
         if (lq_sta) {
                 lq_sta->max_rate_idx = txrc->max_rate_idx;
-                if (sband->band == IEEE80211_BAND_5GHZ &&
+                if (sband->band == NL80211_BAND_5GHZ &&
                     lq_sta->max_rate_idx != -1)
                         lq_sta->max_rate_idx += IL_FIRST_OFDM_RATE;
                 if (lq_sta->max_rate_idx < 0 ||
@@ -2258,11 +2258,11 @@ il4965_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,
         } else {
                 /* Check for invalid rates */
                 if (rate_idx < 0 || rate_idx >= RATE_COUNT_LEGACY ||
-                    (sband->band == IEEE80211_BAND_5GHZ &&
+                    (sband->band == NL80211_BAND_5GHZ &&
                      rate_idx < IL_FIRST_OFDM_RATE))
                         rate_idx = rate_lowest_index(sband, sta);
                 /* On valid 5 GHz rate, adjust idx */
-                else if (sband->band == IEEE80211_BAND_5GHZ)
+                else if (sband->band == NL80211_BAND_5GHZ)
                         rate_idx -= IL_FIRST_OFDM_RATE;
                 info->control.rates[0].flags = 0;
         }
@@ -2362,7 +2362,7 @@ il4965_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)
 
         /* Set last_txrate_idx to lowest rate */
         lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
-        if (sband->band == IEEE80211_BAND_5GHZ)
+        if (sband->band == NL80211_BAND_5GHZ)
                 lq_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;
         lq_sta->is_agg = 0;
 
diff --git a/drivers/net/wireless/intel/iwlegacy/4965.c b/drivers/net/wireless/intel/iwlegacy/4965.c
index fe47db9c20cd..c3c638ed0ed7 100644
--- a/drivers/net/wireless/intel/iwlegacy/4965.c
+++ b/drivers/net/wireless/intel/iwlegacy/4965.c
@@ -1267,7 +1267,7 @@ il4965_send_tx_power(struct il_priv *il)
              "TX Power requested while scanning!\n"))
                 return -EAGAIN;
 
-        band = il->band == IEEE80211_BAND_2GHZ;
+        band = il->band == NL80211_BAND_2GHZ;
 
         is_ht40 = iw4965_is_ht40_channel(il->active.flags);
 
@@ -1480,7 +1480,7 @@ il4965_hw_channel_switch(struct il_priv *il,
         u8 switch_count;
         u16 beacon_interval = le16_to_cpu(il->timing.beacon_interval);
         struct ieee80211_vif *vif = il->vif;
-        band = (il->band == IEEE80211_BAND_2GHZ);
+        band = (il->band == NL80211_BAND_2GHZ);
 
         if (WARN_ON_ONCE(vif == NULL))
                 return -EIO;
@@ -1918,7 +1918,7 @@ struct il_cfg il4965_cfg = {
          * Force use of chains B and C for scan RX on 5 GHz band
          * because the device has off-channel reception on chain A.
          */
-        .scan_rx_antennas[IEEE80211_BAND_5GHZ] = ANT_BC,
+        .scan_rx_antennas[NL80211_BAND_5GHZ] = ANT_BC,
 
         .eeprom_size = IL4965_EEPROM_IMG_SIZE,
         .num_of_queues = IL49_NUM_QUEUES,
diff --git a/drivers/net/wireless/intel/iwlegacy/4965.h b/drivers/net/wireless/intel/iwlegacy/4965.h
index e432715e02d8..527e8b531aed 100644
--- a/drivers/net/wireless/intel/iwlegacy/4965.h
+++ b/drivers/net/wireless/intel/iwlegacy/4965.h
@@ -68,7 +68,7 @@ void il4965_rx_replenish(struct il_priv *il);
 void il4965_rx_replenish_now(struct il_priv *il);
 void il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq);
 int il4965_rxq_stop(struct il_priv *il);
-int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band);
+int il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum nl80211_band band);
 void il4965_rx_handle(struct il_priv *il);
 
 /* tx */
diff --git a/drivers/net/wireless/intel/iwlegacy/common.c b/drivers/net/wireless/intel/iwlegacy/common.c
index eb5cb603bc52..eb24b9241bb2 100644
--- a/drivers/net/wireless/intel/iwlegacy/common.c
+++ b/drivers/net/wireless/intel/iwlegacy/common.c
@@ -723,10 +723,9 @@ il_eeprom_init(struct il_priv *il)
         sz = il->cfg->eeprom_size;
         D_EEPROM("NVM size = %d\n", sz);
         il->eeprom = kzalloc(sz, GFP_KERNEL);
-        if (!il->eeprom) {
-                ret = -ENOMEM;
-                goto alloc_err;
-        }
+        if (!il->eeprom)
+                return -ENOMEM;
+
         e = (__le16 *) il->eeprom;
 
         il->ops->apm_init(il);
@@ -778,7 +777,6 @@ err:
                 il_eeprom_free(il);
         /* Reset chip to save power until we load uCode during "up". */
         il_apm_stop(il);
-alloc_err:
         return ret;
 }
 EXPORT_SYMBOL(il_eeprom_init);
@@ -862,7 +860,7 @@ il_init_band_reference(const struct il_priv *il, int eep_band,
  * Does not set up a command, or touch hardware.
  */
 static int
-il_mod_ht40_chan_info(struct il_priv *il, enum ieee80211_band band, u16 channel,
+il_mod_ht40_chan_info(struct il_priv *il, enum nl80211_band band, u16 channel,
                       const struct il_eeprom_channel *eeprom_ch,
                       u8 clear_ht40_extension_channel)
 {
@@ -947,7 +945,7 @@ il_init_channel_map(struct il_priv *il)
                         ch_info->channel = eeprom_ch_idx[ch];
                         ch_info->band =
                             (band ==
-                             1) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                             1) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 
                         /* permanently store EEPROM's channel regulatory flags
                          *   and max power in channel info database. */
@@ -1005,14 +1003,14 @@ il_init_channel_map(struct il_priv *il)
 
         /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
         for (band = 6; band <= 7; band++) {
-                enum ieee80211_band ieeeband;
+                enum nl80211_band ieeeband;
 
                 il_init_band_reference(il, band, &eeprom_ch_count,
                                        &eeprom_ch_info, &eeprom_ch_idx);
 
                 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
                 ieeeband =
-                    (band == 6) ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                    (band == 6) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 
                 /* Loop through each band adding each of the channels */
                 for (ch = 0; ch < eeprom_ch_count; ch++) {
@@ -1050,19 +1048,19 @@ EXPORT_SYMBOL(il_free_channel_map);
  * Based on band and channel number.
  */
 const struct il_channel_info *
-il_get_channel_info(const struct il_priv *il, enum ieee80211_band band,
+il_get_channel_info(const struct il_priv *il, enum nl80211_band band,
                     u16 channel)
 {
         int i;
 
         switch (band) {
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 for (i = 14; i < il->channel_count; i++) {
                         if (il->channel_info[i].channel == channel)
                                 return &il->channel_info[i];
                 }
                 break;
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 if (channel >= 1 && channel <= 14)
                         return &il->channel_info[channel - 1];
                 break;
@@ -1459,7 +1457,7 @@ il_hdl_scan_complete(struct il_priv *il, struct il_rx_buf *rxb)
         clear_bit(S_SCAN_HW, &il->status);
 
         D_SCAN("Scan on %sGHz took %dms\n",
-               (il->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
+               (il->scan_band == NL80211_BAND_2GHZ) ? "2.4" : "5.2",
                jiffies_to_msecs(jiffies - il->scan_start));
 
         queue_work(il->workqueue, &il->scan_completed);
@@ -1477,10 +1475,10 @@ il_setup_rx_scan_handlers(struct il_priv *il)
 EXPORT_SYMBOL(il_setup_rx_scan_handlers);
 
 u16
-il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
+il_get_active_dwell_time(struct il_priv *il, enum nl80211_band band,
                          u8 n_probes)
 {
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 return IL_ACTIVE_DWELL_TIME_52 +
                     IL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
         else
@@ -1490,14 +1488,14 @@ il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
 EXPORT_SYMBOL(il_get_active_dwell_time);
 
 u16
-il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
+il_get_passive_dwell_time(struct il_priv *il, enum nl80211_band band,
                           struct ieee80211_vif *vif)
 {
         u16 value;
 
         u16 passive =
             (band ==
-             IEEE80211_BAND_2GHZ) ? IL_PASSIVE_DWELL_BASE +
+             NL80211_BAND_2GHZ) ? IL_PASSIVE_DWELL_BASE +
             IL_PASSIVE_DWELL_TIME_24 : IL_PASSIVE_DWELL_BASE +
             IL_PASSIVE_DWELL_TIME_52;
 
@@ -1522,10 +1520,10 @@ void
 il_init_scan_params(struct il_priv *il)
 {
         u8 ant_idx = fls(il->hw_params.valid_tx_ant) - 1;
-        if (!il->scan_tx_ant[IEEE80211_BAND_5GHZ])
-                il->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
-        if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
-                il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
+        if (!il->scan_tx_ant[NL80211_BAND_5GHZ])
+                il->scan_tx_ant[NL80211_BAND_5GHZ] = ant_idx;
+        if (!il->scan_tx_ant[NL80211_BAND_2GHZ])
+                il->scan_tx_ant[NL80211_BAND_2GHZ] = ant_idx;
 }
 EXPORT_SYMBOL(il_init_scan_params);
 
@@ -2005,7 +2003,7 @@ il_prep_station(struct il_priv *il, const u8 *addr, bool is_ap,
         il_set_ht_add_station(il, sta_id, sta);
 
         /* 3945 only */
-        rate = (il->band == IEEE80211_BAND_5GHZ) ? RATE_6M_PLCP : RATE_1M_PLCP;
+        rate = (il->band == NL80211_BAND_5GHZ) ? RATE_6M_PLCP : RATE_1M_PLCP;
         /* Turn on both antennas for the station... */
         station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);
 
@@ -2794,8 +2792,10 @@ il_tx_queue_free(struct il_priv *il, int txq_id)
         il_tx_queue_unmap(il, txq_id);
 
         /* De-alloc array of command/tx buffers */
-        for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
-                kfree(txq->cmd[i]);
+        if (txq->cmd) {
+                for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
+                        kfree(txq->cmd[i]);
+        }
 
         /* De-alloc circular buffer of TFDs */
         if (txq->q.n_bd)
@@ -2873,8 +2873,10 @@ il_cmd_queue_free(struct il_priv *il)
         il_cmd_queue_unmap(il);
 
         /* De-alloc array of command/tx buffers */
-        for (i = 0; i <= TFD_CMD_SLOTS; i++)
-                kfree(txq->cmd[i]);
+        if (txq->cmd) {
+                for (i = 0; i <= TFD_CMD_SLOTS; i++)
+                        kfree(txq->cmd[i]);
+        }
 
         /* De-alloc circular buffer of TFDs */
         if (txq->q.n_bd)
@@ -3080,7 +3082,9 @@ err:
                 kfree(txq->cmd[i]);
 out_free_arrays:
         kfree(txq->meta);
+        txq->meta = NULL;
         kfree(txq->cmd);
+        txq->cmd = NULL;
 
         return -ENOMEM;
 }
@@ -3378,7 +3382,7 @@ EXPORT_SYMBOL(il_bcast_addr);
 static void
 il_init_ht_hw_capab(const struct il_priv *il,
                     struct ieee80211_sta_ht_cap *ht_info,
-                    enum ieee80211_band band)
+                    enum nl80211_band band)
 {
         u16 max_bit_rate = 0;
         u8 rx_chains_num = il->hw_params.rx_chains_num;
@@ -3439,8 +3443,8 @@ il_init_geos(struct il_priv *il)
         int i = 0;
         s8 max_tx_power = 0;
 
-        if (il->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
-            il->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
+        if (il->bands[NL80211_BAND_2GHZ].n_bitrates ||
+            il->bands[NL80211_BAND_5GHZ].n_bitrates) {
                 D_INFO("Geography modes already initialized.\n");
                 set_bit(S_GEO_CONFIGURED, &il->status);
                 return 0;
@@ -3461,23 +3465,23 @@ il_init_geos(struct il_priv *il)
         }
 
         /* 5.2GHz channels start after the 2.4GHz channels */
-        sband = &il->bands[IEEE80211_BAND_5GHZ];
+        sband = &il->bands[NL80211_BAND_5GHZ];
         sband->channels = &channels[ARRAY_SIZE(il_eeprom_band_1)];
         /* just OFDM */
         sband->bitrates = &rates[IL_FIRST_OFDM_RATE];
         sband->n_bitrates = RATE_COUNT_LEGACY - IL_FIRST_OFDM_RATE;
 
         if (il->cfg->sku & IL_SKU_N)
-                il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_5GHZ);
+                il_init_ht_hw_capab(il, &sband->ht_cap, NL80211_BAND_5GHZ);
 
-        sband = &il->bands[IEEE80211_BAND_2GHZ];
+        sband = &il->bands[NL80211_BAND_2GHZ];
         sband->channels = channels;
         /* OFDM & CCK */
         sband->bitrates = rates;
         sband->n_bitrates = RATE_COUNT_LEGACY;
 
         if (il->cfg->sku & IL_SKU_N)
-                il_init_ht_hw_capab(il, &sband->ht_cap, IEEE80211_BAND_2GHZ);
+                il_init_ht_hw_capab(il, &sband->ht_cap, NL80211_BAND_2GHZ);
 
         il->ieee_channels = channels;
         il->ieee_rates = rates;
@@ -3528,7 +3532,7 @@ il_init_geos(struct il_priv *il)
         il->tx_power_user_lmt = max_tx_power;
         il->tx_power_next = max_tx_power;
 
-        if (il->bands[IEEE80211_BAND_5GHZ].n_channels == 0 &&
+        if (il->bands[NL80211_BAND_5GHZ].n_channels == 0 &&
             (il->cfg->sku & IL_SKU_A)) {
                 IL_INFO("Incorrectly detected BG card as ABG. "
                         "Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
@@ -3537,8 +3541,8 @@ il_init_geos(struct il_priv *il)
         }
 
         IL_INFO("Tunable channels: %d 802.11bg, %d 802.11a channels\n",
-                il->bands[IEEE80211_BAND_2GHZ].n_channels,
-                il->bands[IEEE80211_BAND_5GHZ].n_channels);
+                il->bands[NL80211_BAND_2GHZ].n_channels,
+                il->bands[NL80211_BAND_5GHZ].n_channels);
 
         set_bit(S_GEO_CONFIGURED, &il->status);
 
@@ -3559,7 +3563,7 @@ il_free_geos(struct il_priv *il)
 EXPORT_SYMBOL(il_free_geos);
 
 static bool
-il_is_channel_extension(struct il_priv *il, enum ieee80211_band band,
+il_is_channel_extension(struct il_priv *il, enum nl80211_band band,
                         u16 channel, u8 extension_chan_offset)
 {
         const struct il_channel_info *ch_info;
@@ -3922,14 +3926,14 @@ EXPORT_SYMBOL(il_set_rxon_ht);
 
 /* Return valid, unused, channel for a passive scan to reset the RF */
 u8
-il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band)
+il_get_single_channel_number(struct il_priv *il, enum nl80211_band band)
 {
         const struct il_channel_info *ch_info;
         int i;
         u8 channel = 0;
         u8 min, max;
 
-        if (band == IEEE80211_BAND_5GHZ) {
+        if (band == NL80211_BAND_5GHZ) {
                 min = 14;
                 max = il->channel_count;
         } else {
@@ -3961,14 +3965,14 @@ EXPORT_SYMBOL(il_get_single_channel_number);
 int
 il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch)
 {
-        enum ieee80211_band band = ch->band;
+        enum nl80211_band band = ch->band;
         u16 channel = ch->hw_value;
 
         if (le16_to_cpu(il->staging.channel) == channel && il->band == band)
                 return 0;
 
         il->staging.channel = cpu_to_le16(channel);
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 il->staging.flags &= ~RXON_FLG_BAND_24G_MSK;
         else
                 il->staging.flags |= RXON_FLG_BAND_24G_MSK;
@@ -3982,10 +3986,10 @@ il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch)
 EXPORT_SYMBOL(il_set_rxon_channel);
 
 void
-il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
+il_set_flags_for_band(struct il_priv *il, enum nl80211_band band,
                       struct ieee80211_vif *vif)
 {
-        if (band == IEEE80211_BAND_5GHZ) {
+        if (band == NL80211_BAND_5GHZ) {
                 il->staging.flags &=
                     ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
                       RXON_FLG_CCK_MSK);
@@ -5411,7 +5415,7 @@ il_mac_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 
         if (changes & BSS_CHANGED_ERP_CTS_PROT) {
                 D_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
-                if (bss_conf->use_cts_prot && il->band != IEEE80211_BAND_5GHZ)
+                if (bss_conf->use_cts_prot && il->band != NL80211_BAND_5GHZ)
                         il->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
                 else
                         il->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
diff --git a/drivers/net/wireless/intel/iwlegacy/common.h b/drivers/net/wireless/intel/iwlegacy/common.h
index ce52cf114fde..726ede391cb9 100644
--- a/drivers/net/wireless/intel/iwlegacy/common.h
+++ b/drivers/net/wireless/intel/iwlegacy/common.h
@@ -432,7 +432,7 @@ u16 il_eeprom_query16(const struct il_priv *il, size_t offset);
 int il_init_channel_map(struct il_priv *il);
 void il_free_channel_map(struct il_priv *il);
 const struct il_channel_info *il_get_channel_info(const struct il_priv *il,
-                                                  enum ieee80211_band band,
+                                                  enum nl80211_band band,
                                                   u16 channel);
 
 #define IL_NUM_SCAN_RATES         (2)
@@ -497,7 +497,7 @@ struct il_channel_info {
 
         u8 group_idx;           /* 0-4, maps channel to group1/2/3/4/5 */
         u8 band_idx;            /* 0-4, maps channel to band1/2/3/4/5 */
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         /* HT40 channel info */
         s8 ht40_max_power_avg;  /* (dBm) regul. eeprom, normal Tx, any rate */
@@ -811,7 +811,7 @@ struct il_sensitivity_ranges {
  * @rx_wrt_ptr_reg: FH{39}_RSCSR_CHNL0_WPTR
  * @max_stations:
  * @ht40_channel: is 40MHz width possible in band 2.4
- * BIT(IEEE80211_BAND_5GHZ) BIT(IEEE80211_BAND_5GHZ)
+ * BIT(NL80211_BAND_5GHZ) BIT(NL80211_BAND_5GHZ)
  * @sw_crypto: 0 for hw, 1 for sw
  * @max_xxx_size: for ucode uses
  * @ct_kill_threshold: temperature threshold
@@ -1141,13 +1141,13 @@ struct il_priv {
         struct list_head free_frames;
         int frames_count;
 
-        enum ieee80211_band band;
+        enum nl80211_band band;
         int alloc_rxb_page;
 
         void (*handlers[IL_CN_MAX]) (struct il_priv *il,
                                      struct il_rx_buf *rxb);
 
-        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
 
         /* spectrum measurement report caching */
         struct il_spectrum_notification measure_report;
@@ -1176,10 +1176,10 @@ struct il_priv {
         unsigned long scan_start;
         unsigned long scan_start_tsf;
         void *scan_cmd;
-        enum ieee80211_band scan_band;
+        enum nl80211_band scan_band;
         struct cfg80211_scan_request *scan_request;
         struct ieee80211_vif *scan_vif;
-        u8 scan_tx_ant[IEEE80211_NUM_BANDS];
+        u8 scan_tx_ant[NUM_NL80211_BANDS];
         u8 mgmt_tx_ant;
 
         /* spinlock */
@@ -1479,7 +1479,7 @@ il_is_channel_radar(const struct il_channel_info *ch_info)
 static inline u8
 il_is_channel_a_band(const struct il_channel_info *ch_info)
 {
-        return ch_info->band == IEEE80211_BAND_5GHZ;
+        return ch_info->band == NL80211_BAND_5GHZ;
 }
 
 static inline int
@@ -1673,7 +1673,7 @@ struct il_cfg {
         /* params not likely to change within a device family */
         struct il_base_params *base_params;
         /* params likely to change within a device family */
-        u8 scan_rx_antennas[IEEE80211_NUM_BANDS];
+        u8 scan_rx_antennas[NUM_NL80211_BANDS];
         enum il_led_mode led_mode;
 
         int eeprom_size;
@@ -1707,9 +1707,9 @@ void il_set_rxon_hwcrypto(struct il_priv *il, int hw_decrypt);
 int il_check_rxon_cmd(struct il_priv *il);
 int il_full_rxon_required(struct il_priv *il);
 int il_set_rxon_channel(struct il_priv *il, struct ieee80211_channel *ch);
-void il_set_flags_for_band(struct il_priv *il, enum ieee80211_band band,
+void il_set_flags_for_band(struct il_priv *il, enum nl80211_band band,
                            struct ieee80211_vif *vif);
-u8 il_get_single_channel_number(struct il_priv *il, enum ieee80211_band band);
+u8 il_get_single_channel_number(struct il_priv *il, enum nl80211_band band);
 void il_set_rxon_ht(struct il_priv *il, struct il_ht_config *ht_conf);
 bool il_is_ht40_tx_allowed(struct il_priv *il,
                            struct ieee80211_sta_ht_cap *ht_cap);
@@ -1793,9 +1793,9 @@ int il_force_reset(struct il_priv *il, bool external);
 u16 il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
                       const u8 *ta, const u8 *ie, int ie_len, int left);
 void il_setup_rx_scan_handlers(struct il_priv *il);
-u16 il_get_active_dwell_time(struct il_priv *il, enum ieee80211_band band,
+u16 il_get_active_dwell_time(struct il_priv *il, enum nl80211_band band,
                              u8 n_probes);
-u16 il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
+u16 il_get_passive_dwell_time(struct il_priv *il, enum nl80211_band band,
                               struct ieee80211_vif *vif);
 void il_setup_scan_deferred_work(struct il_priv *il);
 void il_cancel_scan_deferred_work(struct il_priv *il);
@@ -1955,7 +1955,7 @@ il_commit_rxon(struct il_priv *il)
 }
 
 static inline const struct ieee80211_supported_band *
-il_get_hw_mode(struct il_priv *il, enum ieee80211_band band)
+il_get_hw_mode(struct il_priv *il, enum nl80211_band band)
 {
         return il->hw->wiphy->bands[band];
 }
@@ -2813,7 +2813,7 @@ struct il_lq_sta {
         u8 action_counter;      /* # mode-switch actions tried */
         u8 is_green;
         u8 is_dup;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         /* The following are bitmaps of rates; RATE_6M_MASK, etc. */
         u32 supp_rates;
diff --git a/drivers/net/wireless/intel/iwlegacy/debug.c b/drivers/net/wireless/intel/iwlegacy/debug.c
index 908b9f4fef6f..6fc6b7ff9849 100644
--- a/drivers/net/wireless/intel/iwlegacy/debug.c
+++ b/drivers/net/wireless/intel/iwlegacy/debug.c
@@ -544,7 +544,7 @@ il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count,
                 return -ENOMEM;
         }
 
-        supp_band = il_get_hw_mode(il, IEEE80211_BAND_2GHZ);
+        supp_band = il_get_hw_mode(il, NL80211_BAND_2GHZ);
         if (supp_band) {
                 channels = supp_band->channels;
 
@@ -571,7 +571,7 @@ il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count,
                                       flags & IEEE80211_CHAN_NO_IR ?
                                       "passive only" : "active/passive");
         }
-        supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ);
+        supp_band = il_get_hw_mode(il, NL80211_BAND_5GHZ);
         if (supp_band) {
                 channels = supp_band->channels;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/agn.h b/drivers/net/wireless/intel/iwlwifi/dvm/agn.h
index 9de277c6c420..b79e38734f2f 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/agn.h
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/agn.h
@@ -158,7 +158,7 @@ void iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch,
                          struct iwl_rxon_context *ctx);
 void iwl_set_flags_for_band(struct iwl_priv *priv,
                             struct iwl_rxon_context *ctx,
-                            enum ieee80211_band band,
+                            enum nl80211_band band,
                             struct ieee80211_vif *vif);
 
 /* uCode */
@@ -186,7 +186,7 @@ int iwl_send_statistics_request(struct iwl_priv *priv,
                                 u8 flags, bool clear);
 
 static inline const struct ieee80211_supported_band *iwl_get_hw_mode(
-                        struct iwl_priv *priv, enum ieee80211_band band)
+                        struct iwl_priv *priv, enum nl80211_band band)
 {
         return priv->hw->wiphy->bands[band];
 }
@@ -198,7 +198,7 @@ int iwlagn_suspend(struct iwl_priv *priv, struct cfg80211_wowlan *wowlan);
 #endif
 
 /* rx */
-int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band);
+int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags, enum nl80211_band band);
 void iwl_setup_rx_handlers(struct iwl_priv *priv);
 void iwl_chswitch_done(struct iwl_priv *priv, bool is_success);
 
@@ -258,7 +258,7 @@ void iwl_cancel_scan_deferred_work(struct iwl_priv *priv);
 int __must_check iwl_scan_initiate(struct iwl_priv *priv,
                                    struct ieee80211_vif *vif,
                                    enum iwl_scan_type scan_type,
-                                   enum ieee80211_band band);
+                                   enum nl80211_band band);
 
 /* For faster active scanning, scan will move to the next channel if fewer than
  * PLCP_QUIET_THRESH packets are heard on this channel within
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/debugfs.c b/drivers/net/wireless/intel/iwlwifi/dvm/debugfs.c
index 74c51615244e..f6591c83d636 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/debugfs.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/debugfs.c
@@ -335,7 +335,7 @@ static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
         if (!buf)
                 return -ENOMEM;
 
-        supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_2GHZ);
+        supp_band = iwl_get_hw_mode(priv, NL80211_BAND_2GHZ);
         if (supp_band) {
                 channels = supp_band->channels;
 
@@ -358,7 +358,7 @@ static ssize_t iwl_dbgfs_channels_read(struct file *file, char __user *user_buf,
                                         IEEE80211_CHAN_NO_IR ?
                                         "passive only" : "active/passive");
         }
-        supp_band = iwl_get_hw_mode(priv, IEEE80211_BAND_5GHZ);
+        supp_band = iwl_get_hw_mode(priv, NL80211_BAND_5GHZ);
         if (supp_band) {
                 channels = supp_band->channels;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/dev.h b/drivers/net/wireless/intel/iwlwifi/dvm/dev.h
index 1a7ead753eee..8148df61a916 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/dev.h
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/dev.h
@@ -677,7 +677,7 @@ struct iwl_priv {
 
         struct iwl_hw_params hw_params;
 
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u8 valid_contexts;
 
         void (*rx_handlers[REPLY_MAX])(struct iwl_priv *priv,
@@ -722,11 +722,11 @@ struct iwl_priv {
         unsigned long scan_start;
         unsigned long scan_start_tsf;
         void *scan_cmd;
-        enum ieee80211_band scan_band;
+        enum nl80211_band scan_band;
         struct cfg80211_scan_request *scan_request;
         struct ieee80211_vif *scan_vif;
         enum iwl_scan_type scan_type;
-        u8 scan_tx_ant[IEEE80211_NUM_BANDS];
+        u8 scan_tx_ant[NUM_NL80211_BANDS];
         u8 mgmt_tx_ant;
 
         /* max number of station keys */
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/devices.c b/drivers/net/wireless/intel/iwlwifi/dvm/devices.c
index cc13c04063a5..f21732ec3b25 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/devices.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/devices.c
@@ -420,7 +420,7 @@ static int iwl5000_hw_channel_switch(struct iwl_priv *priv,
                 .data = { &cmd, },
         };
 
-        cmd.band = priv->band == IEEE80211_BAND_2GHZ;
+        cmd.band = priv->band == NL80211_BAND_2GHZ;
         ch = ch_switch->chandef.chan->hw_value;
         IWL_DEBUG_11H(priv, "channel switch from %d to %d\n",
                       ctx->active.channel, ch);
@@ -588,7 +588,7 @@ static int iwl6000_hw_channel_switch(struct iwl_priv *priv,
 
         hcmd.data[0] = cmd;
 
-        cmd->band = priv->band == IEEE80211_BAND_2GHZ;
+        cmd->band = priv->band == NL80211_BAND_2GHZ;
         ch = ch_switch->chandef.chan->hw_value;
         IWL_DEBUG_11H(priv, "channel switch from %u to %u\n",
                       ctx->active.channel, ch);
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/lib.c b/drivers/net/wireless/intel/iwlwifi/dvm/lib.c
index 1799469268ea..8dda52ae3bb5 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/lib.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/lib.c
@@ -94,7 +94,7 @@ void iwlagn_temperature(struct iwl_priv *priv)
         iwl_tt_handler(priv);
 }
 
-int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
+int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags, enum nl80211_band band)
 {
         int idx = 0;
         int band_offset = 0;
@@ -105,7 +105,7 @@ int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
                 return idx;
         /* Legacy rate format, search for match in table */
         } else {
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         band_offset = IWL_FIRST_OFDM_RATE;
                 for (idx = band_offset; idx < IWL_RATE_COUNT_LEGACY; idx++)
                         if (iwl_rates[idx].plcp == (rate_n_flags & 0xFF))
@@ -878,7 +878,7 @@ u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant, u8 valid)
         int i;
         u8 ind = ant;
 
-        if (priv->band == IEEE80211_BAND_2GHZ &&
+        if (priv->band == NL80211_BAND_2GHZ &&
             priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH)
                 return 0;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/dvm/mac80211.c
index c63ea79571ff..8c0719468d00 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/mac80211.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/mac80211.c
@@ -202,12 +202,12 @@ int iwlagn_mac_setup_register(struct iwl_priv *priv,
 
         hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
 
-        if (priv->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels)
-                priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                        &priv->nvm_data->bands[IEEE80211_BAND_2GHZ];
-        if (priv->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels)
-                priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                        &priv->nvm_data->bands[IEEE80211_BAND_5GHZ];
+        if (priv->nvm_data->bands[NL80211_BAND_2GHZ].n_channels)
+                priv->hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                        &priv->nvm_data->bands[NL80211_BAND_2GHZ];
+        if (priv->nvm_data->bands[NL80211_BAND_5GHZ].n_channels)
+                priv->hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                        &priv->nvm_data->bands[NL80211_BAND_5GHZ];
 
         hw->wiphy->hw_version = priv->trans->hw_id;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/main.c b/drivers/net/wireless/intel/iwlwifi/dvm/main.c
index 614716251c39..37b32a6f60fd 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/main.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/main.c
@@ -262,7 +262,7 @@ int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
         rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
 
         /* In mac80211, rates for 5 GHz start at 0 */
-        if (info->band == IEEE80211_BAND_5GHZ)
+        if (info->band == NL80211_BAND_5GHZ)
                 rate += IWL_FIRST_OFDM_RATE;
         else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
                 rate_flags |= RATE_MCS_CCK_MSK;
@@ -1117,7 +1117,7 @@ static int iwl_init_drv(struct iwl_priv *priv)
 
         INIT_LIST_HEAD(&priv->calib_results);
 
-        priv->band = IEEE80211_BAND_2GHZ;
+        priv->band = NL80211_BAND_2GHZ;
 
         priv->plcp_delta_threshold = priv->lib->plcp_delta_threshold;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/rs.c b/drivers/net/wireless/intel/iwlwifi/dvm/rs.c
index ee7505537c96..b95c2d76db33 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/rs.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/rs.c
@@ -599,7 +599,7 @@ static u32 rate_n_flags_from_tbl(struct iwl_priv *priv,
  * fill "search" or "active" tx mode table.
  */
 static int rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
-                                    enum ieee80211_band band,
+                                    enum nl80211_band band,
                                     struct iwl_scale_tbl_info *tbl,
                                     int *rate_idx)
 {
@@ -624,7 +624,7 @@ static int rs_get_tbl_info_from_mcs(const u32 rate_n_flags,
         /* legacy rate format */
         if (!(rate_n_flags & RATE_MCS_HT_MSK)) {
                 if (num_of_ant == 1) {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 tbl->lq_type = LQ_A;
                         else
                                 tbl->lq_type = LQ_G;
@@ -802,7 +802,7 @@ static u32 rs_get_lower_rate(struct iwl_lq_sta *lq_sta,
         if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_index)) {
                 switch_to_legacy = 1;
                 scale_index = rs_ht_to_legacy[scale_index];
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         tbl->lq_type = LQ_A;
                 else
                         tbl->lq_type = LQ_G;
@@ -821,7 +821,7 @@ static u32 rs_get_lower_rate(struct iwl_lq_sta *lq_sta,
         /* Mask with station rate restriction */
         if (is_legacy(tbl->lq_type)) {
                 /* supp_rates has no CCK bits in A mode */
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         rate_mask  = (u16)(rate_mask &
                            (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
                 else
@@ -939,7 +939,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
         table = &lq_sta->lq;
         tx_rate = le32_to_cpu(table->rs_table[0].rate_n_flags);
         rs_get_tbl_info_from_mcs(tx_rate, priv->band, &tbl_type, &rs_index);
-        if (priv->band == IEEE80211_BAND_5GHZ)
+        if (priv->band == NL80211_BAND_5GHZ)
                 rs_index -= IWL_FIRST_OFDM_RATE;
         mac_flags = info->status.rates[0].flags;
         mac_index = info->status.rates[0].idx;
@@ -952,7 +952,7 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
                  * mac80211 HT index is always zero-indexed; we need to move
                  * HT OFDM rates after CCK rates in 2.4 GHz band
                  */
-                if (priv->band == IEEE80211_BAND_2GHZ)
+                if (priv->band == NL80211_BAND_2GHZ)
                         mac_index += IWL_FIRST_OFDM_RATE;
         }
         /* Here we actually compare this rate to the latest LQ command */
@@ -2284,7 +2284,7 @@ static void rs_rate_scale_perform(struct iwl_priv *priv,
 
         /* mask with station rate restriction */
         if (is_legacy(tbl->lq_type)) {
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         /* supp_rates has no CCK bits in A mode */
                         rate_scale_index_msk = (u16) (rate_mask &
                                 (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
@@ -2721,7 +2721,7 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
         /* Get max rate if user set max rate */
         if (lq_sta) {
                 lq_sta->max_rate_idx = txrc->max_rate_idx;
-                if ((sband->band == IEEE80211_BAND_5GHZ) &&
+                if ((sband->band == NL80211_BAND_5GHZ) &&
                     (lq_sta->max_rate_idx != -1))
                         lq_sta->max_rate_idx += IWL_FIRST_OFDM_RATE;
                 if ((lq_sta->max_rate_idx < 0) ||
@@ -2763,11 +2763,11 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
         } else {
                 /* Check for invalid rates */
                 if ((rate_idx < 0) || (rate_idx >= IWL_RATE_COUNT_LEGACY) ||
-                                ((sband->band == IEEE80211_BAND_5GHZ) &&
+                                ((sband->band == NL80211_BAND_5GHZ) &&
                                  (rate_idx < IWL_FIRST_OFDM_RATE)))
                         rate_idx = rate_lowest_index(sband, sta);
                 /* On valid 5 GHz rate, adjust index */
-                else if (sband->band == IEEE80211_BAND_5GHZ)
+                else if (sband->band == NL80211_BAND_5GHZ)
                         rate_idx -= IWL_FIRST_OFDM_RATE;
                 info->control.rates[0].flags = 0;
         }
@@ -2880,7 +2880,7 @@ void iwl_rs_rate_init(struct iwl_priv *priv, struct ieee80211_sta *sta, u8 sta_i
 
         /* Set last_txrate_idx to lowest rate */
         lq_sta->last_txrate_idx = rate_lowest_index(sband, sta);
-        if (sband->band == IEEE80211_BAND_5GHZ)
+        if (sband->band == NL80211_BAND_5GHZ)
                 lq_sta->last_txrate_idx += IWL_FIRST_OFDM_RATE;
         lq_sta->is_agg = 0;
 #ifdef CONFIG_MAC80211_DEBUGFS
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/rs.h b/drivers/net/wireless/intel/iwlwifi/dvm/rs.h
index c5fe44584613..50c1e951dd2d 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/rs.h
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/rs.h
@@ -355,7 +355,7 @@ struct iwl_lq_sta {
         u8 action_counter;      /* # mode-switch actions tried */
         u8 is_green;
         u8 is_dup;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         /* The following are bitmaps of rates; IWL_RATE_6M_MASK, etc. */
         u32 supp_rates;
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/rx.c b/drivers/net/wireless/intel/iwlwifi/dvm/rx.c
index 52ab1e012e8f..dfa2041cfdac 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/rx.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/rx.c
@@ -686,7 +686,7 @@ static void iwlagn_pass_packet_to_mac80211(struct iwl_priv *priv,
 
         memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
 
-        ieee80211_rx_napi(priv->hw, skb, priv->napi);
+        ieee80211_rx_napi(priv->hw, NULL, skb, priv->napi);
 }
 
 static u32 iwlagn_translate_rx_status(struct iwl_priv *priv, u32 decrypt_in)
@@ -834,7 +834,7 @@ static void iwlagn_rx_reply_rx(struct iwl_priv *priv,
         /* rx_status carries information about the packet to mac80211 */
         rx_status.mactime = le64_to_cpu(phy_res->timestamp);
         rx_status.band = (phy_res->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
-                                IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                                NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
         rx_status.freq =
                 ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
                                                rx_status.band);
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/rxon.c b/drivers/net/wireless/intel/iwlwifi/dvm/rxon.c
index 2d47cb24c48b..b228552184b5 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/rxon.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/rxon.c
@@ -719,7 +719,7 @@ void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf)
 void iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch,
                          struct iwl_rxon_context *ctx)
 {
-        enum ieee80211_band band = ch->band;
+        enum nl80211_band band = ch->band;
         u16 channel = ch->hw_value;
 
         if ((le16_to_cpu(ctx->staging.channel) == channel) &&
@@ -727,7 +727,7 @@ void iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch,
                 return;
 
         ctx->staging.channel = cpu_to_le16(channel);
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 ctx->staging.flags &= ~RXON_FLG_BAND_24G_MSK;
         else
                 ctx->staging.flags |= RXON_FLG_BAND_24G_MSK;
@@ -740,10 +740,10 @@ void iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch,
 
 void iwl_set_flags_for_band(struct iwl_priv *priv,
                             struct iwl_rxon_context *ctx,
-                            enum ieee80211_band band,
+                            enum nl80211_band band,
                             struct ieee80211_vif *vif)
 {
-        if (band == IEEE80211_BAND_5GHZ) {
+        if (band == NL80211_BAND_5GHZ) {
                 ctx->staging.flags &=
                     ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
                       | RXON_FLG_CCK_MSK);
@@ -1476,7 +1476,7 @@ void iwlagn_bss_info_changed(struct ieee80211_hw *hw,
 
         iwlagn_set_rxon_chain(priv, ctx);
 
-        if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
+        if (bss_conf->use_cts_prot && (priv->band != NL80211_BAND_5GHZ))
                 ctx->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
         else
                 ctx->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/scan.c b/drivers/net/wireless/intel/iwlwifi/dvm/scan.c
index 81a2ddbe9569..d01766f16175 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/scan.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/scan.c
@@ -312,7 +312,7 @@ static void iwl_rx_scan_complete_notif(struct iwl_priv *priv,
                        scan_notif->tsf_high, scan_notif->status);
 
         IWL_DEBUG_SCAN(priv, "Scan on %sGHz took %dms\n",
-                       (priv->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
+                       (priv->scan_band == NL80211_BAND_2GHZ) ? "2.4" : "5.2",
                        jiffies_to_msecs(jiffies - priv->scan_start));
 
         /*
@@ -362,9 +362,9 @@ void iwl_setup_rx_scan_handlers(struct iwl_priv *priv)
 }
 
 static u16 iwl_get_active_dwell_time(struct iwl_priv *priv,
-                                     enum ieee80211_band band, u8 n_probes)
+                                     enum nl80211_band band, u8 n_probes)
 {
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 return IWL_ACTIVE_DWELL_TIME_52 +
                         IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
         else
@@ -431,9 +431,9 @@ static u16 iwl_limit_dwell(struct iwl_priv *priv, u16 dwell_time)
 }
 
 static u16 iwl_get_passive_dwell_time(struct iwl_priv *priv,
-                                      enum ieee80211_band band)
+                                      enum nl80211_band band)
 {
-        u16 passive = (band == IEEE80211_BAND_2GHZ) ?
+        u16 passive = (band == NL80211_BAND_2GHZ) ?
             IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
             IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;
 
@@ -442,7 +442,7 @@ static u16 iwl_get_passive_dwell_time(struct iwl_priv *priv,
 
 /* Return valid, unused, channel for a passive scan to reset the RF */
 static u8 iwl_get_single_channel_number(struct iwl_priv *priv,
-                                        enum ieee80211_band band)
+                                        enum nl80211_band band)
 {
         struct ieee80211_supported_band *sband = priv->hw->wiphy->bands[band];
         struct iwl_rxon_context *ctx;
@@ -470,7 +470,7 @@ static u8 iwl_get_single_channel_number(struct iwl_priv *priv,
 
 static int iwl_get_channel_for_reset_scan(struct iwl_priv *priv,
                                           struct ieee80211_vif *vif,
-                                          enum ieee80211_band band,
+                                          enum nl80211_band band,
                                           struct iwl_scan_channel *scan_ch)
 {
         const struct ieee80211_supported_band *sband;
@@ -492,7 +492,7 @@ static int iwl_get_channel_for_reset_scan(struct iwl_priv *priv,
                         cpu_to_le16(IWL_RADIO_RESET_DWELL_TIME);
                 /* Set txpower levels to defaults */
                 scan_ch->dsp_atten = 110;
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
                 else
                         scan_ch->tx_gain = ((1 << 5) | (5 << 3));
@@ -505,7 +505,7 @@ static int iwl_get_channel_for_reset_scan(struct iwl_priv *priv,
 
 static int iwl_get_channels_for_scan(struct iwl_priv *priv,
                                      struct ieee80211_vif *vif,
-                                     enum ieee80211_band band,
+                                     enum nl80211_band band,
                                      u8 is_active, u8 n_probes,
                                      struct iwl_scan_channel *scan_ch)
 {
@@ -553,7 +553,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
                  * power level:
                  * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
                  */
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
                 else
                         scan_ch->tx_gain = ((1 << 5) | (5 << 3));
@@ -636,7 +636,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
         u32 rate_flags = 0;
         u16 cmd_len = 0;
         u16 rx_chain = 0;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u8 n_probes = 0;
         u8 rx_ant = priv->nvm_data->valid_rx_ant;
         u8 rate;
@@ -750,7 +750,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
         scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 
         switch (priv->scan_band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
                 chan_mod = le32_to_cpu(
                         priv->contexts[IWL_RXON_CTX_BSS].active.flags &
@@ -771,7 +771,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
                     priv->lib->bt_params->advanced_bt_coexist)
                         scan->tx_cmd.tx_flags |= TX_CMD_FLG_IGNORE_BT;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 rate = IWL_RATE_6M_PLCP;
                 break;
         default:
@@ -809,7 +809,7 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
 
         band = priv->scan_band;
 
-        if (band == IEEE80211_BAND_2GHZ &&
+        if (band == NL80211_BAND_2GHZ &&
             priv->lib->bt_params &&
             priv->lib->bt_params->advanced_bt_coexist) {
                 /* transmit 2.4 GHz probes only on first antenna */
@@ -925,16 +925,16 @@ static int iwlagn_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
 void iwl_init_scan_params(struct iwl_priv *priv)
 {
         u8 ant_idx = fls(priv->nvm_data->valid_tx_ant) - 1;
-        if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ])
-                priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
-        if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ])
-                priv->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
+        if (!priv->scan_tx_ant[NL80211_BAND_5GHZ])
+                priv->scan_tx_ant[NL80211_BAND_5GHZ] = ant_idx;
+        if (!priv->scan_tx_ant[NL80211_BAND_2GHZ])
+                priv->scan_tx_ant[NL80211_BAND_2GHZ] = ant_idx;
 }
 
 int __must_check iwl_scan_initiate(struct iwl_priv *priv,
                                    struct ieee80211_vif *vif,
                                    enum iwl_scan_type scan_type,
-                                   enum ieee80211_band band)
+                                   enum nl80211_band band)
 {
         int ret;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/sta.c b/drivers/net/wireless/intel/iwlwifi/dvm/sta.c
index 8e9768a553e4..de6ec9b7ace4 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/sta.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/sta.c
@@ -579,7 +579,7 @@ static void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
 
         /* Set up the rate scaling to start at selected rate, fall back
          * all the way down to 1M in IEEE order, and then spin on 1M */
-        if (priv->band == IEEE80211_BAND_5GHZ)
+        if (priv->band == NL80211_BAND_5GHZ)
                 r = IWL_RATE_6M_INDEX;
         else if (ctx && ctx->vif && ctx->vif->p2p)
                 r = IWL_RATE_6M_INDEX;
diff --git a/drivers/net/wireless/intel/iwlwifi/dvm/tx.c b/drivers/net/wireless/intel/iwlwifi/dvm/tx.c
index 59e2001c39f8..4b97371c3b42 100644
--- a/drivers/net/wireless/intel/iwlwifi/dvm/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/dvm/tx.c
@@ -81,7 +81,7 @@ static void iwlagn_tx_cmd_build_basic(struct iwl_priv *priv,
                 tx_flags |= TX_CMD_FLG_TSF_MSK;
         else if (ieee80211_is_back_req(fc))
                 tx_flags |= TX_CMD_FLG_ACK_MSK | TX_CMD_FLG_IMM_BA_RSP_MASK;
-        else if (info->band == IEEE80211_BAND_2GHZ &&
+        else if (info->band == NL80211_BAND_2GHZ &&
                  priv->lib->bt_params &&
                  priv->lib->bt_params->advanced_bt_coexist &&
                  (ieee80211_is_auth(fc) || ieee80211_is_assoc_req(fc) ||
@@ -177,7 +177,7 @@ static void iwlagn_tx_cmd_build_rate(struct iwl_priv *priv,
                 rate_idx = rate_lowest_index(
                                 &priv->nvm_data->bands[info->band], sta);
         /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
-        if (info->band == IEEE80211_BAND_5GHZ)
+        if (info->band == NL80211_BAND_5GHZ)
                 rate_idx += IWL_FIRST_OFDM_RATE;
         /* Get PLCP rate for tx_cmd->rate_n_flags */
         rate_plcp = iwl_rates[rate_idx].plcp;
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-1000.c b/drivers/net/wireless/intel/iwlwifi/iwl-1000.c
index ef22c3d168fc..5c2aae64d59f 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-1000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-1000.c
@@ -64,7 +64,7 @@ static const struct iwl_base_params iwl1000_base_params = {
 static const struct iwl_ht_params iwl1000_ht_params = {
         .ht_greenfield_support = true,
         .use_rts_for_aggregation = true, /* use rts/cts protection */
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ),
 };
 
 static const struct iwl_eeprom_params iwl1000_eeprom_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-2000.c b/drivers/net/wireless/intel/iwlwifi/iwl-2000.c
index dc246c997084..2e823bdc4757 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-2000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-2000.c
@@ -89,7 +89,7 @@ static const struct iwl_base_params iwl2030_base_params = {
 static const struct iwl_ht_params iwl2000_ht_params = {
         .ht_greenfield_support = true,
         .use_rts_for_aggregation = true, /* use rts/cts protection */
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ),
 };
 
 static const struct iwl_eeprom_params iwl20x0_eeprom_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-5000.c b/drivers/net/wireless/intel/iwlwifi/iwl-5000.c
index 4dcdab6781cc..4c3e3cf4c799 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-5000.c
@@ -62,7 +62,7 @@ static const struct iwl_base_params iwl5000_base_params = {
 
 static const struct iwl_ht_params iwl5000_ht_params = {
         .ht_greenfield_support = true,
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 static const struct iwl_eeprom_params iwl5000_eeprom_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-6000.c b/drivers/net/wireless/intel/iwlwifi/iwl-6000.c
index 9938f5340ac0..5a7b7e1f0aab 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-6000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-6000.c
@@ -110,7 +110,7 @@ static const struct iwl_base_params iwl6000_g2_base_params = {
 static const struct iwl_ht_params iwl6000_ht_params = {
         .ht_greenfield_support = true,
         .use_rts_for_aggregation = true, /* use rts/cts protection */
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 static const struct iwl_eeprom_params iwl6000_eeprom_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-7000.c b/drivers/net/wireless/intel/iwlwifi/iwl-7000.c
index b6283c881d42..abd2904ecc48 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-7000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-7000.c
@@ -156,7 +156,7 @@ static const struct iwl_tt_params iwl7000_high_temp_tt_params = {
 
 static const struct iwl_ht_params iwl7000_ht_params = {
         .stbc = true,
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 #define IWL_DEVICE_7000_COMMON                                  \
@@ -287,7 +287,7 @@ static const struct iwl_pwr_tx_backoff iwl7265_pwr_tx_backoffs[] = {
 static const struct iwl_ht_params iwl7265_ht_params = {
         .stbc = true,
         .ldpc = true,
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 const struct iwl_cfg iwl3165_2ac_cfg = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
index 0728a288aa3d..a9212a12f4da 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
@@ -124,7 +124,7 @@ static const struct iwl_base_params iwl8000_base_params = {
 static const struct iwl_ht_params iwl8000_ht_params = {
         .stbc = true,
         .ldpc = true,
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 static const struct iwl_tt_params iwl8000_tt_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-9000.c b/drivers/net/wireless/intel/iwlwifi/iwl-9000.c
index a3d35aa291a9..b9aca3795f06 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-9000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-9000.c
@@ -93,7 +93,7 @@ static const struct iwl_base_params iwl9000_base_params = {
 static const struct iwl_ht_params iwl9000_ht_params = {
         .stbc = true,
         .ldpc = true,
-        .ht40_bands = BIT(IEEE80211_BAND_2GHZ) | BIT(IEEE80211_BAND_5GHZ),
+        .ht40_bands = BIT(NL80211_BAND_2GHZ) | BIT(NL80211_BAND_5GHZ),
 };
 
 static const struct iwl_tt_params iwl9000_tt_params = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-config.h b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
index 08bb4f4e424a..720679889ab3 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-config.h
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-config.h
@@ -185,7 +185,7 @@ struct iwl_base_params {
  * @stbc: support Tx STBC and 1*SS Rx STBC
  * @ldpc: support Tx/Rx with LDPC
  * @use_rts_for_aggregation: use rts/cts protection for HT traffic
- * @ht40_bands: bitmap of bands (using %IEEE80211_BAND_*) that support HT40
+ * @ht40_bands: bitmap of bands (using %NL80211_BAND_*) that support HT40
  */
 struct iwl_ht_params {
         enum ieee80211_smps_mode smps_mode;
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.c b/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.c
index c15f5be85197..bf1b69aec813 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.c
@@ -390,10 +390,10 @@ iwl_eeprom_enh_txp_read_element(struct iwl_nvm_data *data,
                                 int n_channels, s8 max_txpower_avg)
 {
         int ch_idx;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         band = txp->flags & IWL_EEPROM_ENH_TXP_FL_BAND_52G ?
-                IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
+                NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
 
         for (ch_idx = 0; ch_idx < n_channels; ch_idx++) {
                 struct ieee80211_channel *chan = &data->channels[ch_idx];
@@ -526,7 +526,7 @@ static void iwl_init_band_reference(const struct iwl_cfg *cfg,
 
 static void iwl_mod_ht40_chan_info(struct device *dev,
                                    struct iwl_nvm_data *data, int n_channels,
-                                   enum ieee80211_band band, u16 channel,
+                                   enum nl80211_band band, u16 channel,
                                    const struct iwl_eeprom_channel *eeprom_ch,
                                    u8 clear_ht40_extension_channel)
 {
@@ -548,7 +548,7 @@ static void iwl_mod_ht40_chan_info(struct device *dev,
         IWL_DEBUG_EEPROM(dev,
                          "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
                          channel,
-                         band == IEEE80211_BAND_5GHZ ? "5.2" : "2.4",
+                         band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
                          CHECK_AND_PRINT(IBSS),
                          CHECK_AND_PRINT(ACTIVE),
                          CHECK_AND_PRINT(RADAR),
@@ -606,8 +606,8 @@ static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
                         n_channels++;
 
                         channel->hw_value = eeprom_ch_array[ch_idx];
-                        channel->band = (band == 1) ? IEEE80211_BAND_2GHZ
-                                                    : IEEE80211_BAND_5GHZ;
+                        channel->band = (band == 1) ? NL80211_BAND_2GHZ
+                                                    : NL80211_BAND_5GHZ;
                         channel->center_freq =
                                 ieee80211_channel_to_frequency(
                                         channel->hw_value, channel->band);
@@ -677,15 +677,15 @@ static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 
         /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
         for (band = 6; band <= 7; band++) {
-                enum ieee80211_band ieeeband;
+                enum nl80211_band ieeeband;
 
                 iwl_init_band_reference(cfg, eeprom, eeprom_size, band,
                                         &eeprom_ch_count, &eeprom_ch_info,
                                         &eeprom_ch_array);
 
                 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
-                ieeeband = (band == 6) ? IEEE80211_BAND_2GHZ
-                                       : IEEE80211_BAND_5GHZ;
+                ieeeband = (band == 6) ? NL80211_BAND_2GHZ
+                                       : NL80211_BAND_5GHZ;
 
                 /* Loop through each band adding each of the channels */
                 for (ch_idx = 0; ch_idx < eeprom_ch_count; ch_idx++) {
@@ -708,7 +708,7 @@ static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 
 int iwl_init_sband_channels(struct iwl_nvm_data *data,
                             struct ieee80211_supported_band *sband,
-                            int n_channels, enum ieee80211_band band)
+                            int n_channels, enum nl80211_band band)
 {
         struct ieee80211_channel *chan = &data->channels[0];
         int n = 0, idx = 0;
@@ -734,7 +734,7 @@ int iwl_init_sband_channels(struct iwl_nvm_data *data,
 void iwl_init_ht_hw_capab(const struct iwl_cfg *cfg,
                           struct iwl_nvm_data *data,
                           struct ieee80211_sta_ht_cap *ht_info,
-                          enum ieee80211_band band,
+                          enum nl80211_band band,
                           u8 tx_chains, u8 rx_chains)
 {
         int max_bit_rate = 0;
@@ -813,22 +813,22 @@ static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
         int n_used = 0;
         struct ieee80211_supported_band *sband;
 
-        sband = &data->bands[IEEE80211_BAND_2GHZ];
-        sband->band = IEEE80211_BAND_2GHZ;
+        sband = &data->bands[NL80211_BAND_2GHZ];
+        sband->band = NL80211_BAND_2GHZ;
         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
         sband->n_bitrates = N_RATES_24;
         n_used += iwl_init_sband_channels(data, sband, n_channels,
-                                          IEEE80211_BAND_2GHZ);
-        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
+                                          NL80211_BAND_2GHZ);
+        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
                              data->valid_tx_ant, data->valid_rx_ant);
 
-        sband = &data->bands[IEEE80211_BAND_5GHZ];
-        sband->band = IEEE80211_BAND_5GHZ;
+        sband = &data->bands[NL80211_BAND_5GHZ];
+        sband->band = NL80211_BAND_5GHZ;
         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
         sband->n_bitrates = N_RATES_52;
         n_used += iwl_init_sband_channels(data, sband, n_channels,
-                                          IEEE80211_BAND_5GHZ);
-        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
+                                          NL80211_BAND_5GHZ);
+        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
                              data->valid_tx_ant, data->valid_rx_ant);
 
         if (n_channels != n_used)
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.h b/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.h
index ad2b834668ff..53f39a34eca2 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.h
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-eeprom-parse.h
@@ -98,7 +98,7 @@ struct iwl_nvm_data {
         s8 max_tx_pwr_half_dbm;
 
         bool lar_enabled;
-        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
         struct ieee80211_channel channels[];
 };
 
@@ -133,12 +133,12 @@ int iwl_nvm_check_version(struct iwl_nvm_data *data,
 
 int iwl_init_sband_channels(struct iwl_nvm_data *data,
                             struct ieee80211_supported_band *sband,
-                            int n_channels, enum ieee80211_band band);
+                            int n_channels, enum nl80211_band band);
 
 void iwl_init_ht_hw_capab(const struct iwl_cfg *cfg,
                           struct iwl_nvm_data *data,
                           struct ieee80211_sta_ht_cap *ht_info,
-                          enum ieee80211_band band,
+                          enum nl80211_band band,
                           u8 tx_chains, u8 rx_chains);
 
 #endif /* __iwl_eeprom_parse_h__ */
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c b/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
index 93a689583dff..14743c37d976 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
@@ -308,7 +308,7 @@ static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 
                 channel->hw_value = nvm_chan[ch_idx];
                 channel->band = (ch_idx < num_2ghz_channels) ?
-                                IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                                NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
                 channel->center_freq =
                         ieee80211_channel_to_frequency(
                                 channel->hw_value, channel->band);
@@ -320,7 +320,7 @@ static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
                  * is not used in mvm, and is used for backwards compatibility
                  */
                 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
-                is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
+                is_5ghz = channel->band == NL80211_BAND_5GHZ;
 
                 /* don't put limitations in case we're using LAR */
                 if (!lar_supported)
@@ -439,22 +439,22 @@ static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
                                 &ch_section[NVM_CHANNELS_FAMILY_8000],
                                 lar_supported);
 
-        sband = &data->bands[IEEE80211_BAND_2GHZ];
-        sband->band = IEEE80211_BAND_2GHZ;
+        sband = &data->bands[NL80211_BAND_2GHZ];
+        sband->band = NL80211_BAND_2GHZ;
         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
         sband->n_bitrates = N_RATES_24;
         n_used += iwl_init_sband_channels(data, sband, n_channels,
-                                          IEEE80211_BAND_2GHZ);
-        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
+                                          NL80211_BAND_2GHZ);
+        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
                              tx_chains, rx_chains);
 
-        sband = &data->bands[IEEE80211_BAND_5GHZ];
-        sband->band = IEEE80211_BAND_5GHZ;
+        sband = &data->bands[NL80211_BAND_5GHZ];
+        sband->band = NL80211_BAND_5GHZ;
         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
         sband->n_bitrates = N_RATES_52;
         n_used += iwl_init_sband_channels(data, sband, n_channels,
-                                          IEEE80211_BAND_5GHZ);
-        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
+                                          NL80211_BAND_5GHZ);
+        iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
                              tx_chains, rx_chains);
         if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
@@ -781,7 +781,7 @@ iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
         struct ieee80211_regdomain *regd;
         int size_of_regd;
         struct ieee80211_reg_rule *rule;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         int center_freq, prev_center_freq = 0;
         int valid_rules = 0;
         bool new_rule;
@@ -809,7 +809,7 @@ iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
                 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
                 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
-                       IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                       NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
                 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
                                                              band);
                 new_rule = false;
@@ -857,7 +857,7 @@ iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
                 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
                               "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
                               center_freq,
-                              band == IEEE80211_BAND_5GHZ ? "5.2" : "2.4",
+                              band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
                               CHECK_AND_PRINT_I(VALID),
                               CHECK_AND_PRINT_I(ACTIVE),
                               CHECK_AND_PRINT_I(RADAR),
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/coex.c b/drivers/net/wireless/intel/iwlwifi/mvm/coex.c
index 35cdeca3d61e..a63f5bbb1ba7 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/coex.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/coex.c
@@ -378,7 +378,7 @@ iwl_get_coex_type(struct iwl_mvm *mvm, const struct ieee80211_vif *vif)
         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 
         if (!chanctx_conf ||
-             chanctx_conf->def.chan->band != IEEE80211_BAND_2GHZ) {
+             chanctx_conf->def.chan->band != NL80211_BAND_2GHZ) {
                 rcu_read_unlock();
                 return BT_COEX_INVALID_LUT;
         }
@@ -537,7 +537,7 @@ static void iwl_mvm_bt_notif_iterator(void *_data, u8 *mac,
 
         /* If channel context is invalid or not on 2.4GHz .. */
         if ((!chanctx_conf ||
-             chanctx_conf->def.chan->band != IEEE80211_BAND_2GHZ)) {
+             chanctx_conf->def.chan->band != NL80211_BAND_2GHZ)) {
                 if (vif->type == NL80211_IFTYPE_STATION) {
                         /* ... relax constraints and disable rssi events */
                         iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX,
@@ -857,11 +857,11 @@ bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm)
 }
 
 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm,
-                                    enum ieee80211_band band)
+                                    enum nl80211_band band)
 {
         u32 bt_activity = le32_to_cpu(mvm->last_bt_notif.bt_activity_grading);
 
-        if (band != IEEE80211_BAND_2GHZ)
+        if (band != NL80211_BAND_2GHZ)
                 return false;
 
         return bt_activity >= BT_LOW_TRAFFIC;
@@ -873,7 +873,7 @@ u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr,
         __le16 fc = hdr->frame_control;
         bool mplut_enabled = iwl_mvm_is_mplut_supported(mvm);
 
-        if (info->band != IEEE80211_BAND_2GHZ)
+        if (info->band != NL80211_BAND_2GHZ)
                 return 0;
 
         if (unlikely(mvm->bt_tx_prio))
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
index 3a279d3403ef..fb96bc00f022 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/debugfs-vif.c
@@ -724,9 +724,9 @@ static ssize_t iwl_dbgfs_tof_responder_params_write(struct ieee80211_vif *vif,
 
                 ret = kstrtou32(data, 10, &value);
                 if (ret == 0 && value) {
-                        enum ieee80211_band band = (cmd->channel_num <= 14) ?
-                                                   IEEE80211_BAND_2GHZ :
-                                                   IEEE80211_BAND_5GHZ;
+                        enum nl80211_band band = (cmd->channel_num <= 14) ?
+                                                   NL80211_BAND_2GHZ :
+                                                   NL80211_BAND_5GHZ;
                         struct ieee80211_channel chn = {
                                 .band = band,
                                 .center_freq = ieee80211_channel_to_frequency(
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
index 6ad5c602e84c..9e97cf4ff1c5 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
@@ -980,7 +980,7 @@ int iwl_mvm_up(struct iwl_mvm *mvm)
                 goto error;
 
         /* Add all the PHY contexts */
-        chan = &mvm->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels[0];
+        chan = &mvm->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[0];
         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
         for (i = 0; i < NUM_PHY_CTX; i++) {
                 /*
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
index 5f950568e92c..456067b2f48d 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
@@ -559,7 +559,7 @@ void iwl_mvm_mac_ctxt_release(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
 
 static void iwl_mvm_ack_rates(struct iwl_mvm *mvm,
                               struct ieee80211_vif *vif,
-                              enum ieee80211_band band,
+                              enum nl80211_band band,
                               u8 *cck_rates, u8 *ofdm_rates)
 {
         struct ieee80211_supported_band *sband;
@@ -730,7 +730,7 @@ static void iwl_mvm_mac_ctxt_cmd_common(struct iwl_mvm *mvm,
         rcu_read_lock();
         chanctx = rcu_dereference(vif->chanctx_conf);
         iwl_mvm_ack_rates(mvm, vif, chanctx ? chanctx->def.chan->band
-                                            : IEEE80211_BAND_2GHZ,
+                                            : NL80211_BAND_2GHZ,
                           &cck_ack_rates, &ofdm_ack_rates);
         rcu_read_unlock();
 
@@ -1065,7 +1065,7 @@ static int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm,
                 cpu_to_le32(BIT(mvm->mgmt_last_antenna_idx) <<
                             RATE_MCS_ANT_POS);
 
-        if (info->band == IEEE80211_BAND_5GHZ || vif->p2p) {
+        if (info->band == NL80211_BAND_5GHZ || vif->p2p) {
                 rate = IWL_FIRST_OFDM_RATE;
         } else {
                 rate = IWL_FIRST_CCK_RATE;
@@ -1516,7 +1516,7 @@ void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm,
         rx_status.device_timestamp = le32_to_cpu(sb->system_time);
         rx_status.band =
                 (sb->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24)) ?
-                                IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                                NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
         rx_status.freq =
                 ieee80211_channel_to_frequency(le16_to_cpu(sb->channel),
                                                rx_status.band);
@@ -1526,5 +1526,5 @@ void iwl_mvm_rx_stored_beacon_notif(struct iwl_mvm *mvm,
         memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
 
         /* pass it as regular rx to mac80211 */
-        ieee80211_rx_napi(mvm->hw, skb, NULL);
+        ieee80211_rx_napi(mvm->hw, NULL, skb, NULL);
 }
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
index 4f5ec495b460..ef91b3770703 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
@@ -550,18 +550,18 @@ int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm)
         else
                 mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
 
-        if (mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels)
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                        &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
-        if (mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels) {
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                        &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
+        if (mvm->nvm_data->bands[NL80211_BAND_2GHZ].n_channels)
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                        &mvm->nvm_data->bands[NL80211_BAND_2GHZ];
+        if (mvm->nvm_data->bands[NL80211_BAND_5GHZ].n_channels) {
+                hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                        &mvm->nvm_data->bands[NL80211_BAND_5GHZ];
 
                 if (fw_has_capa(&mvm->fw->ucode_capa,
                                 IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
                     fw_has_api(&mvm->fw->ucode_capa,
                                IWL_UCODE_TLV_API_LQ_SS_PARAMS))
-                        hw->wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap.cap |=
+                        hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.cap |=
                                 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
         }
 
@@ -2911,7 +2911,7 @@ static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm *mvm,
                         cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
                 .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
                 /* Set the channel info data */
-                .channel_info.band = (channel->band == IEEE80211_BAND_2GHZ) ?
+                .channel_info.band = (channel->band == NL80211_BAND_2GHZ) ?
                         PHY_BAND_24 : PHY_BAND_5,
                 .channel_info.channel = channel->hw_value,
                 .channel_info.width = PHY_VHT_CHANNEL_MODE20,
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
index 2d685e02d488..85800ba0c667 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h
@@ -1133,9 +1133,9 @@ int iwl_run_init_mvm_ucode(struct iwl_mvm *mvm, bool read_nvm);
 
 /* Utils */
 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags,
-                                        enum ieee80211_band band);
+                                        enum nl80211_band band);
 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
-                               enum ieee80211_band band,
+                               enum nl80211_band band,
                                struct ieee80211_tx_rate *r);
 u8 iwl_mvm_mac80211_idx_to_hwrate(int rate_idx);
 void iwl_mvm_dump_nic_error_log(struct iwl_mvm *mvm);
@@ -1468,7 +1468,7 @@ bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm,
 bool iwl_mvm_bt_coex_is_ant_avail(struct iwl_mvm *mvm, u8 ant);
 bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm);
 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm,
-                                    enum ieee80211_band band);
+                                    enum nl80211_band band);
 u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr,
                            struct ieee80211_tx_info *info, u8 ac);
 
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c b/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c
index 6e6a56f2153d..95138830b9f8 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c
@@ -147,7 +147,7 @@ static void iwl_mvm_phy_ctxt_cmd_data(struct iwl_mvm *mvm,
         u8 active_cnt, idle_cnt;
 
         /* Set the channel info data */
-        cmd->ci.band = (chandef->chan->band == IEEE80211_BAND_2GHZ ?
+        cmd->ci.band = (chandef->chan->band == NL80211_BAND_2GHZ ?
               PHY_BAND_24 : PHY_BAND_5);
 
         cmd->ci.channel = chandef->chan->hw_value;
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rs.c b/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
index 61d0a8cd13f9..81dd2f6a48a5 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rs.c
@@ -829,7 +829,7 @@ static u32 ucode_rate_from_rs_rate(struct iwl_mvm *mvm,
 
 /* Convert a ucode rate into an rs_rate object */
 static int rs_rate_from_ucode_rate(const u32 ucode_rate,
-                                   enum ieee80211_band band,
+                                   enum nl80211_band band,
                                    struct rs_rate *rate)
 {
         u32 ant_msk = ucode_rate & RATE_MCS_ANT_ABC_MSK;
@@ -848,7 +848,7 @@ static int rs_rate_from_ucode_rate(const u32 ucode_rate,
         if (!(ucode_rate & RATE_MCS_HT_MSK) &&
             !(ucode_rate & RATE_MCS_VHT_MSK)) {
                 if (num_of_ant == 1) {
-                        if (band == IEEE80211_BAND_5GHZ)
+                        if (band == NL80211_BAND_5GHZ)
                                 rate->type = LQ_LEGACY_A;
                         else
                                 rate->type = LQ_LEGACY_G;
@@ -1043,7 +1043,7 @@ static void rs_get_lower_rate_down_column(struct iwl_lq_sta *lq_sta,
                 return;
         } else if (is_siso(rate)) {
                 /* Downgrade to Legacy if we were in SISO */
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         rate->type = LQ_LEGACY_A;
                 else
                         rate->type = LQ_LEGACY_G;
@@ -1850,7 +1850,7 @@ static int rs_switch_to_column(struct iwl_mvm *mvm,
         rate->ant = column->ant;
 
         if (column->mode == RS_LEGACY) {
-                if (lq_sta->band == IEEE80211_BAND_5GHZ)
+                if (lq_sta->band == NL80211_BAND_5GHZ)
                         rate->type = LQ_LEGACY_A;
                 else
                         rate->type = LQ_LEGACY_G;
@@ -2020,7 +2020,7 @@ static void rs_get_adjacent_txp(struct iwl_mvm *mvm, int index,
 }
 
 static bool rs_tpc_allowed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
-                           struct rs_rate *rate, enum ieee80211_band band)
+                           struct rs_rate *rate, enum nl80211_band band)
 {
         int index = rate->index;
         bool cam = (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM);
@@ -2126,7 +2126,7 @@ static bool rs_tpc_perform(struct iwl_mvm *mvm,
         struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
         struct ieee80211_vif *vif = mvm_sta->vif;
         struct ieee80211_chanctx_conf *chanctx_conf;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct iwl_rate_scale_data *window;
         struct rs_rate *rate = &tbl->rate;
         enum tpc_action action;
@@ -2148,7 +2148,7 @@ static bool rs_tpc_perform(struct iwl_mvm *mvm,
         rcu_read_lock();
         chanctx_conf = rcu_dereference(vif->chanctx_conf);
         if (WARN_ON(!chanctx_conf))
-                band = IEEE80211_NUM_BANDS;
+                band = NUM_NL80211_BANDS;
         else
                 band = chanctx_conf->def.chan->band;
         rcu_read_unlock();
@@ -2606,7 +2606,7 @@ static void rs_init_optimal_rate(struct iwl_mvm *mvm,
                 rate->type = lq_sta->is_vht ? LQ_VHT_MIMO2 : LQ_HT_MIMO2;
         else if (lq_sta->max_siso_rate_idx != IWL_RATE_INVALID)
                 rate->type = lq_sta->is_vht ? LQ_VHT_SISO : LQ_HT_SISO;
-        else if (lq_sta->band == IEEE80211_BAND_5GHZ)
+        else if (lq_sta->band == NL80211_BAND_5GHZ)
                 rate->type = LQ_LEGACY_A;
         else
                 rate->type = LQ_LEGACY_G;
@@ -2623,7 +2623,7 @@ static void rs_init_optimal_rate(struct iwl_mvm *mvm,
         } else {
                 lq_sta->optimal_rate_mask = lq_sta->active_legacy_rate;
 
-                if (lq_sta->band == IEEE80211_BAND_5GHZ) {
+                if (lq_sta->band == NL80211_BAND_5GHZ) {
                         lq_sta->optimal_rates = rs_optimal_rates_5ghz_legacy;
                         lq_sta->optimal_nentries =
                                 ARRAY_SIZE(rs_optimal_rates_5ghz_legacy);
@@ -2679,7 +2679,7 @@ static struct rs_rate *rs_get_optimal_rate(struct iwl_mvm *mvm,
 static void rs_get_initial_rate(struct iwl_mvm *mvm,
                                 struct ieee80211_sta *sta,
                                 struct iwl_lq_sta *lq_sta,
-                                enum ieee80211_band band,
+                                enum nl80211_band band,
                                 struct rs_rate *rate)
 {
         int i, nentries;
@@ -2714,7 +2714,7 @@ static void rs_get_initial_rate(struct iwl_mvm *mvm,
         rate->index = find_first_bit(&lq_sta->active_legacy_rate,
                                      BITS_PER_LONG);
 
-        if (band == IEEE80211_BAND_5GHZ) {
+        if (band == NL80211_BAND_5GHZ) {
                 rate->type = LQ_LEGACY_A;
                 initial_rates = rs_optimal_rates_5ghz_legacy;
                 nentries = ARRAY_SIZE(rs_optimal_rates_5ghz_legacy);
@@ -2814,7 +2814,7 @@ void rs_update_last_rssi(struct iwl_mvm *mvm,
 static void rs_initialize_lq(struct iwl_mvm *mvm,
                              struct ieee80211_sta *sta,
                              struct iwl_lq_sta *lq_sta,
-                             enum ieee80211_band band,
+                             enum nl80211_band band,
                              bool init)
 {
         struct iwl_scale_tbl_info *tbl;
@@ -3097,7 +3097,7 @@ void iwl_mvm_update_frame_stats(struct iwl_mvm *mvm, u32 rate, bool agg)
  * Called after adding a new station to initialize rate scaling
  */
 void iwl_mvm_rs_rate_init(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
-                          enum ieee80211_band band, bool init)
+                          enum nl80211_band band, bool init)
 {
         int i, j;
         struct ieee80211_hw *hw = mvm->hw;
@@ -3203,7 +3203,7 @@ static void rs_rate_update(void *mvm_r,
 #ifdef CONFIG_MAC80211_DEBUGFS
 static void rs_build_rates_table_from_fixed(struct iwl_mvm *mvm,
                                             struct iwl_lq_cmd *lq_cmd,
-                                            enum ieee80211_band band,
+                                            enum nl80211_band band,
                                             u32 ucode_rate)
 {
         struct rs_rate rate;
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rs.h b/drivers/net/wireless/intel/iwlwifi/mvm/rs.h
index bdb6f2d8d854..90d046fb24a0 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rs.h
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rs.h
@@ -305,7 +305,7 @@ struct iwl_lq_sta {
         bool stbc_capable;      /* Tx STBC is supported by chip and Rx by STA */
         bool bfer_capable;      /* Remote supports beamformee and we BFer */
 
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         /* The following are bitmaps of rates; IWL_RATE_6M_MASK, etc. */
         unsigned long active_legacy_rate;
@@ -358,7 +358,7 @@ struct iwl_lq_sta {
 
 /* Initialize station's rate scaling information after adding station */
 void iwl_mvm_rs_rate_init(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
-                          enum ieee80211_band band, bool init);
+                          enum nl80211_band band, bool init);
 
 /* Notify RS about Tx status */
 void iwl_mvm_rs_tx_status(struct iwl_mvm *mvm, struct ieee80211_sta *sta,
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rx.c b/drivers/net/wireless/intel/iwlwifi/mvm/rx.c
index 485cfc1a4daa..263e8a8576b7 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rx.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rx.c
@@ -131,7 +131,7 @@ static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm *mvm,
                                 fraglen, rxb->truesize);
         }
 
-        ieee80211_rx_napi(mvm->hw, skb, napi);
+        ieee80211_rx_napi(mvm->hw, NULL, skb, napi);
 }
 
 /*
@@ -319,7 +319,7 @@ void iwl_mvm_rx_rx_mpdu(struct iwl_mvm *mvm, struct napi_struct *napi,
         rx_status->device_timestamp = le32_to_cpu(phy_info->system_timestamp);
         rx_status->band =
                 (phy_info->phy_flags & cpu_to_le16(RX_RES_PHY_FLAGS_BAND_24)) ?
-                                IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+                                NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
         rx_status->freq =
                 ieee80211_channel_to_frequency(le16_to_cpu(phy_info->channel),
                                                rx_status->band);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
index b2bc3d96a13f..651604d18a32 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/rxmq.c
@@ -210,7 +210,7 @@ static void iwl_mvm_pass_packet_to_mac80211(struct iwl_mvm *mvm,
         if (iwl_mvm_check_pn(mvm, skb, queue, sta))
                 kfree_skb(skb);
         else
-                ieee80211_rx_napi(mvm->hw, skb, napi);
+                ieee80211_rx_napi(mvm->hw, NULL, skb, napi);
 }
 
 static void iwl_mvm_get_signal_strength(struct iwl_mvm *mvm,
@@ -456,8 +456,8 @@ void iwl_mvm_rx_mpdu_mq(struct iwl_mvm *mvm, struct napi_struct *napi,
 
         rx_status->mactime = le64_to_cpu(desc->tsf_on_air_rise);
         rx_status->device_timestamp = le32_to_cpu(desc->gp2_on_air_rise);
-        rx_status->band = desc->channel > 14 ? IEEE80211_BAND_5GHZ :
-                                               IEEE80211_BAND_2GHZ;
+        rx_status->band = desc->channel > 14 ? NL80211_BAND_5GHZ :
+                                               NL80211_BAND_2GHZ;
         rx_status->freq = ieee80211_channel_to_frequency(desc->channel,
                                                          rx_status->band);
         iwl_mvm_get_signal_strength(mvm, desc, rx_status);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
index c1d1be9c5d01..6f609dd5c222 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/scan.c
@@ -163,16 +163,16 @@ static inline __le16 iwl_mvm_scan_rx_chain(struct iwl_mvm *mvm)
         return cpu_to_le16(rx_chain);
 }
 
-static __le32 iwl_mvm_scan_rxon_flags(enum ieee80211_band band)
+static __le32 iwl_mvm_scan_rxon_flags(enum nl80211_band band)
 {
-        if (band == IEEE80211_BAND_2GHZ)
+        if (band == NL80211_BAND_2GHZ)
                 return cpu_to_le32(PHY_BAND_24);
         else
                 return cpu_to_le32(PHY_BAND_5);
 }
 
 static inline __le32
-iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum ieee80211_band band,
+iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum nl80211_band band,
                           bool no_cck)
 {
         u32 tx_ant;
@@ -182,7 +182,7 @@ iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum ieee80211_band band,
                                      mvm->scan_last_antenna_idx);
         tx_ant = BIT(mvm->scan_last_antenna_idx) << RATE_MCS_ANT_POS;
 
-        if (band == IEEE80211_BAND_2GHZ && !no_cck)
+        if (band == NL80211_BAND_2GHZ && !no_cck)
                 return cpu_to_le32(IWL_RATE_1M_PLCP | RATE_MCS_CCK_MSK |
                                    tx_ant);
         else
@@ -591,14 +591,14 @@ static void iwl_mvm_scan_fill_tx_cmd(struct iwl_mvm *mvm,
         tx_cmd[0].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL |
                                          TX_CMD_FLG_BT_DIS);
         tx_cmd[0].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm,
-                                                           IEEE80211_BAND_2GHZ,
+                                                           NL80211_BAND_2GHZ,
                                                            no_cck);
         tx_cmd[0].sta_id = mvm->aux_sta.sta_id;
 
         tx_cmd[1].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL |
                                          TX_CMD_FLG_BT_DIS);
         tx_cmd[1].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm,
-                                                           IEEE80211_BAND_5GHZ,
+                                                           NL80211_BAND_5GHZ,
                                                            no_cck);
         tx_cmd[1].sta_id = mvm->aux_sta.sta_id;
 }
@@ -695,19 +695,19 @@ iwl_mvm_build_scan_probe(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 
         /* Insert ds parameter set element on 2.4 GHz band */
         newpos = iwl_mvm_copy_and_insert_ds_elem(mvm,
-                                                 ies->ies[IEEE80211_BAND_2GHZ],
-                                                 ies->len[IEEE80211_BAND_2GHZ],
+                                                 ies->ies[NL80211_BAND_2GHZ],
+                                                 ies->len[NL80211_BAND_2GHZ],
                                                  pos);
         params->preq.band_data[0].offset = cpu_to_le16(pos - params->preq.buf);
         params->preq.band_data[0].len = cpu_to_le16(newpos - pos);
         pos = newpos;
 
-        memcpy(pos, ies->ies[IEEE80211_BAND_5GHZ],
-               ies->len[IEEE80211_BAND_5GHZ]);
+        memcpy(pos, ies->ies[NL80211_BAND_5GHZ],
+               ies->len[NL80211_BAND_5GHZ]);
         params->preq.band_data[1].offset = cpu_to_le16(pos - params->preq.buf);
         params->preq.band_data[1].len =
-                cpu_to_le16(ies->len[IEEE80211_BAND_5GHZ]);
-        pos += ies->len[IEEE80211_BAND_5GHZ];
+                cpu_to_le16(ies->len[NL80211_BAND_5GHZ]);
+        pos += ies->len[NL80211_BAND_5GHZ];
 
         memcpy(pos, ies->common_ies, ies->common_ie_len);
         params->preq.common_data.offset = cpu_to_le16(pos - params->preq.buf);
@@ -921,10 +921,10 @@ static __le32 iwl_mvm_scan_config_rates(struct iwl_mvm *mvm)
         unsigned int rates = 0;
         int i;
 
-        band = &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
+        band = &mvm->nvm_data->bands[NL80211_BAND_2GHZ];
         for (i = 0; i < band->n_bitrates; i++)
                 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value);
-        band = &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
+        band = &mvm->nvm_data->bands[NL80211_BAND_5GHZ];
         for (i = 0; i < band->n_bitrates; i++)
                 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value);
 
@@ -939,8 +939,8 @@ int iwl_mvm_config_scan(struct iwl_mvm *mvm)
         struct iwl_scan_config *scan_config;
         struct ieee80211_supported_band *band;
         int num_channels =
-                mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels +
-                mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels;
+                mvm->nvm_data->bands[NL80211_BAND_2GHZ].n_channels +
+                mvm->nvm_data->bands[NL80211_BAND_5GHZ].n_channels;
         int ret, i, j = 0, cmd_size;
         struct iwl_host_cmd cmd = {
                 .id = iwl_cmd_id(SCAN_CFG_CMD, IWL_ALWAYS_LONG_GROUP, 0),
@@ -994,10 +994,10 @@ int iwl_mvm_config_scan(struct iwl_mvm *mvm)
                                      IWL_CHANNEL_FLAG_EBS_ADD |
                                      IWL_CHANNEL_FLAG_PRE_SCAN_PASSIVE2ACTIVE;
 
-        band = &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
+        band = &mvm->nvm_data->bands[NL80211_BAND_2GHZ];
         for (i = 0; i < band->n_channels; i++, j++)
                 scan_config->channel_array[j] = band->channels[i].hw_value;
-        band = &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
+        band = &mvm->nvm_data->bands[NL80211_BAND_5GHZ];
         for (i = 0; i < band->n_channels; i++, j++)
                 scan_config->channel_array[j] = band->channels[i].hw_value;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/tdls.c b/drivers/net/wireless/intel/iwlwifi/mvm/tdls.c
index 18711c5de35a..9f160fc58cd0 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/tdls.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/tdls.c
@@ -444,7 +444,7 @@ iwl_mvm_tdls_config_channel_switch(struct iwl_mvm *mvm,
         }
 
         if (chandef) {
-                cmd.ci.band = (chandef->chan->band == IEEE80211_BAND_2GHZ ?
+                cmd.ci.band = (chandef->chan->band == NL80211_BAND_2GHZ ?
                                PHY_BAND_24 : PHY_BAND_5);
                 cmd.ci.channel = chandef->chan->hw_value;
                 cmd.ci.width = iwl_mvm_get_channel_width(chandef);
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
index efb9b98c4c98..bd286fca3776 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/tx.c
@@ -359,7 +359,7 @@ void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,
                                 &mvm->nvm_data->bands[info->band], sta);
 
         /* For 5 GHZ band, remap mac80211 rate indices into driver indices */
-        if (info->band == IEEE80211_BAND_5GHZ)
+        if (info->band == NL80211_BAND_5GHZ)
                 rate_idx += IWL_FIRST_OFDM_RATE;
 
         /* For 2.4 GHZ band, check that there is no need to remap */
@@ -372,7 +372,7 @@ void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,
                 iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm),
                                      mvm->mgmt_last_antenna_idx);
 
-        if (info->band == IEEE80211_BAND_2GHZ &&
+        if (info->band == NL80211_BAND_2GHZ &&
             !iwl_mvm_bt_coex_is_shared_ant_avail(mvm))
                 rate_flags = mvm->cfg->non_shared_ant << RATE_MCS_ANT_POS;
         else
@@ -1052,7 +1052,7 @@ const char *iwl_mvm_get_tx_fail_reason(u32 status)
 #endif /* CONFIG_IWLWIFI_DEBUG */
 
 void iwl_mvm_hwrate_to_tx_rate(u32 rate_n_flags,
-                               enum ieee80211_band band,
+                               enum nl80211_band band,
                                struct ieee80211_tx_rate *r)
 {
         if (rate_n_flags & RATE_HT_MCS_GF_MSK)
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/utils.c b/drivers/net/wireless/intel/iwlwifi/mvm/utils.c
index 486c98541afc..f0ffd62f02d3 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/utils.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/utils.c
@@ -217,14 +217,14 @@ static const u8 fw_rate_idx_to_plcp[IWL_RATE_COUNT] = {
 };
 
 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags,
-                                        enum ieee80211_band band)
+                                        enum nl80211_band band)
 {
         int rate = rate_n_flags & RATE_LEGACY_RATE_MSK;
         int idx;
         int band_offset = 0;
 
         /* Legacy rate format, search for match in table */
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 band_offset = IWL_FIRST_OFDM_RATE;
         for (idx = band_offset; idx < IWL_RATE_COUNT_LEGACY; idx++)
                 if (fw_rate_idx_to_plcp[idx] == rate)
diff --git a/drivers/net/wireless/intersil/orinoco/cfg.c b/drivers/net/wireless/intersil/orinoco/cfg.c
index 0f6ea316e38e..7aa47069af0a 100644
--- a/drivers/net/wireless/intersil/orinoco/cfg.c
+++ b/drivers/net/wireless/intersil/orinoco/cfg.c
@@ -60,14 +60,14 @@ int orinoco_wiphy_register(struct wiphy *wiphy)
                 if (priv->channel_mask & (1 << i)) {
                         priv->channels[i].center_freq =
                                 ieee80211_channel_to_frequency(i + 1,
-                                                           IEEE80211_BAND_2GHZ);
+                                                           NL80211_BAND_2GHZ);
                         channels++;
                 }
         }
         priv->band.channels = priv->channels;
         priv->band.n_channels = channels;
 
-        wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
 
         i = 0;
@@ -175,7 +175,7 @@ static int orinoco_set_monitor_channel(struct wiphy *wiphy,
         if (cfg80211_get_chandef_type(chandef) != NL80211_CHAN_NO_HT)
                 return -EINVAL;
 
-        if (chandef->chan->band != IEEE80211_BAND_2GHZ)
+        if (chandef->chan->band != NL80211_BAND_2GHZ)
                 return -EINVAL;
 
         channel = ieee80211_frequency_to_channel(chandef->chan->center_freq);
diff --git a/drivers/net/wireless/intersil/orinoco/hw.c b/drivers/net/wireless/intersil/orinoco/hw.c
index e27e32851f1e..61af5a28f269 100644
--- a/drivers/net/wireless/intersil/orinoco/hw.c
+++ b/drivers/net/wireless/intersil/orinoco/hw.c
@@ -1193,7 +1193,7 @@ int orinoco_hw_get_freq(struct orinoco_private *priv)
                 goto out;
 
         }
-        freq = ieee80211_channel_to_frequency(channel, IEEE80211_BAND_2GHZ);
+        freq = ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
 
  out:
         orinoco_unlock(priv, &flags);
diff --git a/drivers/net/wireless/intersil/orinoco/scan.c b/drivers/net/wireless/intersil/orinoco/scan.c
index 2c66166add70..d0ceb06c72d0 100644
--- a/drivers/net/wireless/intersil/orinoco/scan.c
+++ b/drivers/net/wireless/intersil/orinoco/scan.c
@@ -111,7 +111,7 @@ static void orinoco_add_hostscan_result(struct orinoco_private *priv,
         }
 
         freq = ieee80211_channel_to_frequency(
-                le16_to_cpu(bss->a.channel), IEEE80211_BAND_2GHZ);
+                le16_to_cpu(bss->a.channel), NL80211_BAND_2GHZ);
         channel = ieee80211_get_channel(wiphy, freq);
         if (!channel) {
                 printk(KERN_DEBUG "Invalid channel designation %04X(%04X)",
@@ -148,7 +148,7 @@ void orinoco_add_extscan_result(struct orinoco_private *priv,
         ie_len = len - sizeof(*bss);
         ie = cfg80211_find_ie(WLAN_EID_DS_PARAMS, bss->data, ie_len);
         chan = ie ? ie[2] : 0;
-        freq = ieee80211_channel_to_frequency(chan, IEEE80211_BAND_2GHZ);
+        freq = ieee80211_channel_to_frequency(chan, NL80211_BAND_2GHZ);
         channel = ieee80211_get_channel(wiphy, freq);
 
         timestamp = le64_to_cpu(bss->timestamp);
diff --git a/drivers/net/wireless/intersil/p54/eeprom.c b/drivers/net/wireless/intersil/p54/eeprom.c
index 2fe713eda7ad..d4c73d39336f 100644
--- a/drivers/net/wireless/intersil/p54/eeprom.c
+++ b/drivers/net/wireless/intersil/p54/eeprom.c
@@ -76,14 +76,14 @@ struct p54_channel_entry {
         u16 data;
         int index;
         int max_power;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 };
 
 struct p54_channel_list {
         struct p54_channel_entry *channels;
         size_t entries;
         size_t max_entries;
-        size_t band_channel_num[IEEE80211_NUM_BANDS];
+        size_t band_channel_num[NUM_NL80211_BANDS];
 };
 
 static int p54_get_band_from_freq(u16 freq)
@@ -91,10 +91,10 @@ static int p54_get_band_from_freq(u16 freq)
         /* FIXME: sync these values with the 802.11 spec */
 
         if ((freq >= 2412) && (freq <= 2484))
-                return IEEE80211_BAND_2GHZ;
+                return NL80211_BAND_2GHZ;
 
         if ((freq >= 4920) && (freq <= 5825))
-                return IEEE80211_BAND_5GHZ;
+                return NL80211_BAND_5GHZ;
 
         return -1;
 }
@@ -124,16 +124,16 @@ static int p54_compare_rssichan(const void *_a,
 
 static int p54_fill_band_bitrates(struct ieee80211_hw *dev,
                                   struct ieee80211_supported_band *band_entry,
-                                  enum ieee80211_band band)
+                                  enum nl80211_band band)
 {
         /* TODO: generate rate array dynamically */
 
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 band_entry->bitrates = p54_bgrates;
                 band_entry->n_bitrates = ARRAY_SIZE(p54_bgrates);
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 band_entry->bitrates = p54_arates;
                 band_entry->n_bitrates = ARRAY_SIZE(p54_arates);
                 break;
@@ -147,7 +147,7 @@ static int p54_fill_band_bitrates(struct ieee80211_hw *dev,
 static int p54_generate_band(struct ieee80211_hw *dev,
                              struct p54_channel_list *list,
                              unsigned int *chan_num,
-                             enum ieee80211_band band)
+                             enum nl80211_band band)
 {
         struct p54_common *priv = dev->priv;
         struct ieee80211_supported_band *tmp, *old;
@@ -206,7 +206,7 @@ static int p54_generate_band(struct ieee80211_hw *dev,
 
         if (j == 0) {
                 wiphy_err(dev->wiphy, "Disabling totally damaged %d GHz band\n",
-                          (band == IEEE80211_BAND_2GHZ) ? 2 : 5);
+                          (band == NL80211_BAND_2GHZ) ? 2 : 5);
 
                 ret = -ENODATA;
                 goto err_out;
@@ -396,7 +396,7 @@ static int p54_generate_channel_lists(struct ieee80211_hw *dev)
              p54_compare_channels, NULL);
 
         k = 0;
-        for (i = 0, j = 0; i < IEEE80211_NUM_BANDS; i++) {
+        for (i = 0, j = 0; i < NUM_NL80211_BANDS; i++) {
                 if (p54_generate_band(dev, list, &k, i) == 0)
                         j++;
         }
@@ -573,10 +573,10 @@ static int p54_parse_rssical(struct ieee80211_hw *dev,
                 for (i = 0; i < entries; i++) {
                         u16 freq = 0;
                         switch (i) {
-                        case IEEE80211_BAND_2GHZ:
+                        case NL80211_BAND_2GHZ:
                                 freq = 2437;
                                 break;
-                        case IEEE80211_BAND_5GHZ:
+                        case NL80211_BAND_5GHZ:
                                 freq = 5240;
                                 break;
                         }
@@ -902,11 +902,11 @@ good_eeprom:
         if (priv->rxhw == PDR_SYNTH_FRONTEND_XBOW)
                 p54_init_xbow_synth(priv);
         if (!(synth & PDR_SYNTH_24_GHZ_DISABLED))
-                dev->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                        priv->band_table[IEEE80211_BAND_2GHZ];
+                dev->wiphy->bands[NL80211_BAND_2GHZ] =
+                        priv->band_table[NL80211_BAND_2GHZ];
         if (!(synth & PDR_SYNTH_5_GHZ_DISABLED))
-                dev->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                        priv->band_table[IEEE80211_BAND_5GHZ];
+                dev->wiphy->bands[NL80211_BAND_5GHZ] =
+                        priv->band_table[NL80211_BAND_5GHZ];
         if ((synth & PDR_SYNTH_RX_DIV_MASK) == PDR_SYNTH_RX_DIV_SUPPORTED)
                 priv->rx_diversity_mask = 3;
         if ((synth & PDR_SYNTH_TX_DIV_MASK) == PDR_SYNTH_TX_DIV_SUPPORTED)
diff --git a/drivers/net/wireless/intersil/p54/main.c b/drivers/net/wireless/intersil/p54/main.c
index 7805864e76f9..d5a3bf91a03e 100644
--- a/drivers/net/wireless/intersil/p54/main.c
+++ b/drivers/net/wireless/intersil/p54/main.c
@@ -477,7 +477,7 @@ static void p54_bss_info_changed(struct ieee80211_hw *dev,
                 p54_set_edcf(priv);
         }
         if (changed & BSS_CHANGED_BASIC_RATES) {
-                if (dev->conf.chandef.chan->band == IEEE80211_BAND_5GHZ)
+                if (dev->conf.chandef.chan->band == NL80211_BAND_5GHZ)
                         priv->basic_rate_mask = (info->basic_rates << 4);
                 else
                         priv->basic_rate_mask = info->basic_rates;
@@ -829,7 +829,7 @@ void p54_free_common(struct ieee80211_hw *dev)
         struct p54_common *priv = dev->priv;
         unsigned int i;
 
-        for (i = 0; i < IEEE80211_NUM_BANDS; i++)
+        for (i = 0; i < NUM_NL80211_BANDS; i++)
                 kfree(priv->band_table[i]);
 
         kfree(priv->iq_autocal);
diff --git a/drivers/net/wireless/intersil/p54/p54.h b/drivers/net/wireless/intersil/p54/p54.h
index 40b401ed6845..529939e611cd 100644
--- a/drivers/net/wireless/intersil/p54/p54.h
+++ b/drivers/net/wireless/intersil/p54/p54.h
@@ -223,7 +223,7 @@ struct p54_common {
         struct p54_cal_database *curve_data;
         struct p54_cal_database *output_limit;
         struct p54_cal_database *rssi_db;
-        struct ieee80211_supported_band *band_table[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band *band_table[NUM_NL80211_BANDS];
 
         /* BBP/MAC state */
         u8 mac_addr[ETH_ALEN];
diff --git a/drivers/net/wireless/intersil/p54/txrx.c b/drivers/net/wireless/intersil/p54/txrx.c
index 24e5ff9a9272..1af7da0b386e 100644
--- a/drivers/net/wireless/intersil/p54/txrx.c
+++ b/drivers/net/wireless/intersil/p54/txrx.c
@@ -353,7 +353,7 @@ static int p54_rx_data(struct p54_common *priv, struct sk_buff *skb)
         rx_status->signal = p54_rssi_to_dbm(priv, hdr->rssi);
         if (hdr->rate & 0x10)
                 rx_status->flag |= RX_FLAG_SHORTPRE;
-        if (priv->hw->conf.chandef.chan->band == IEEE80211_BAND_5GHZ)
+        if (priv->hw->conf.chandef.chan->band == NL80211_BAND_5GHZ)
                 rx_status->rate_idx = (rate < 4) ? 0 : rate - 4;
         else
                 rx_status->rate_idx = rate;
@@ -867,7 +867,7 @@ void p54_tx_80211(struct ieee80211_hw *dev,
         for (i = 0; i < nrates && ridx < 8; i++) {
                 /* we register the rates in perfect order */
                 rate = info->control.rates[i].idx;
-                if (info->band == IEEE80211_BAND_5GHZ)
+                if (info->band == NL80211_BAND_5GHZ)
                         rate += 4;
 
                 /* store the count we actually calculated for TX status */
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index e85e0737771c..c757f14c4c00 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -255,14 +255,14 @@ static struct class *hwsim_class;
 static struct net_device *hwsim_mon; /* global monitor netdev */
 
 #define CHAN2G(_freq)  { \
-        .band = IEEE80211_BAND_2GHZ, \
+        .band = NL80211_BAND_2GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_freq), \
         .max_power = 20, \
 }
 
 #define CHAN5G(_freq) { \
-        .band = IEEE80211_BAND_5GHZ, \
+        .band = NL80211_BAND_5GHZ, \
         .center_freq = (_freq), \
         .hw_value = (_freq), \
         .max_power = 20, \
@@ -479,7 +479,7 @@ struct mac80211_hwsim_data {
         struct list_head list;
         struct ieee80211_hw *hw;
         struct device *dev;
-        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
         struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
         struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
         struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
@@ -1909,6 +1909,7 @@ static void hw_scan_work(struct work_struct *work)
                 /* send probes */
                 for (i = 0; i < req->n_ssids; i++) {
                         struct sk_buff *probe;
+                        struct ieee80211_mgmt *mgmt;
 
                         probe = ieee80211_probereq_get(hwsim->hw,
                                                        hwsim->scan_addr,
@@ -1918,6 +1919,10 @@ static void hw_scan_work(struct work_struct *work)
                         if (!probe)
                                 continue;
 
+                        mgmt = (struct ieee80211_mgmt *) probe->data;
+                        memcpy(mgmt->da, req->bssid, ETH_ALEN);
+                        memcpy(mgmt->bssid, req->bssid, ETH_ALEN);
+
                         if (req->ie_len)
                                 memcpy(skb_put(probe, req->ie_len), req->ie,
                                        req->ie_len);
@@ -2342,7 +2347,7 @@ static int mac80211_hwsim_new_radio(struct genl_info *info,
         u8 addr[ETH_ALEN];
         struct mac80211_hwsim_data *data;
         struct ieee80211_hw *hw;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
         int idx;
 
@@ -2471,16 +2476,16 @@ static int mac80211_hwsim_new_radio(struct genl_info *info,
                 sizeof(hwsim_channels_5ghz));
         memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
 
-        for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
                 struct ieee80211_supported_band *sband = &data->bands[band];
                 switch (band) {
-                case IEEE80211_BAND_2GHZ:
+                case NL80211_BAND_2GHZ:
                         sband->channels = data->channels_2ghz;
                         sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz);
                         sband->bitrates = data->rates;
                         sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
                         break;
-                case IEEE80211_BAND_5GHZ:
+                case NL80211_BAND_5GHZ:
                         sband->channels = data->channels_5ghz;
                         sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz);
                         sband->bitrates = data->rates + 4;
diff --git a/drivers/net/wireless/marvell/libertas/cfg.c b/drivers/net/wireless/marvell/libertas/cfg.c
index 2eea76a340b7..776b44bfd93a 100644
--- a/drivers/net/wireless/marvell/libertas/cfg.c
+++ b/drivers/net/wireless/marvell/libertas/cfg.c
@@ -23,7 +23,7 @@
 
 
 #define CHAN2G(_channel, _freq, _flags) {        \
-        .band             = IEEE80211_BAND_2GHZ, \
+        .band             = NL80211_BAND_2GHZ, \
         .center_freq      = (_freq),             \
         .hw_value         = (_channel),          \
         .flags            = (_flags),            \
@@ -639,7 +639,7 @@ static int lbs_ret_scan(struct lbs_private *priv, unsigned long dummy,
                 if (chan_no != -1) {
                         struct wiphy *wiphy = priv->wdev->wiphy;
                         int freq = ieee80211_channel_to_frequency(chan_no,
-                                                        IEEE80211_BAND_2GHZ);
+                                                        NL80211_BAND_2GHZ);
                         struct ieee80211_channel *channel =
                                 ieee80211_get_channel(wiphy, freq);
 
@@ -1266,7 +1266,7 @@ _new_connect_scan_req(struct wiphy *wiphy, struct cfg80211_connect_params *sme)
 {
         struct cfg80211_scan_request *creq = NULL;
         int i, n_channels = ieee80211_get_num_supported_channels(wiphy);
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         creq = kzalloc(sizeof(*creq) + sizeof(struct cfg80211_ssid) +
                        n_channels * sizeof(void *),
@@ -1281,7 +1281,7 @@ _new_connect_scan_req(struct wiphy *wiphy, struct cfg80211_connect_params *sme)
 
         /* Scan all available channels */
         i = 0;
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 int j;
 
                 if (!wiphy->bands[band])
@@ -2200,7 +2200,7 @@ int lbs_cfg_register(struct lbs_private *priv)
         if (lbs_mesh_activated(priv))
                 wdev->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MESH_POINT);
 
-        wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &lbs_band_2ghz;
+        wdev->wiphy->bands[NL80211_BAND_2GHZ] = &lbs_band_2ghz;
 
         /*
          * We could check priv->fwcapinfo && FW_CAPINFO_WPA, but I have
diff --git a/drivers/net/wireless/marvell/libertas/cmd.c b/drivers/net/wireless/marvell/libertas/cmd.c
index 4ddd0e5a6b85..301170cccfff 100644
--- a/drivers/net/wireless/marvell/libertas/cmd.c
+++ b/drivers/net/wireless/marvell/libertas/cmd.c
@@ -743,7 +743,7 @@ int lbs_set_11d_domain_info(struct lbs_private *priv)
         struct cmd_ds_802_11d_domain_info cmd;
         struct mrvl_ie_domain_param_set *domain = &cmd.domain;
         struct ieee80211_country_ie_triplet *t;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_channel *ch;
         u8 num_triplet = 0;
         u8 num_parsed_chan = 0;
@@ -777,7 +777,7 @@ int lbs_set_11d_domain_info(struct lbs_private *priv)
          * etc.
          */
         for (band = 0;
-             (band < IEEE80211_NUM_BANDS) && (num_triplet < MAX_11D_TRIPLETS);
+             (band < NUM_NL80211_BANDS) && (num_triplet < MAX_11D_TRIPLETS);
              band++) {
 
                 if (!bands[band])
diff --git a/drivers/net/wireless/marvell/libertas_tf/main.c b/drivers/net/wireless/marvell/libertas_tf/main.c
index a47f0acc099a..0bf8916a02cf 100644
--- a/drivers/net/wireless/marvell/libertas_tf/main.c
+++ b/drivers/net/wireless/marvell/libertas_tf/main.c
@@ -570,7 +570,7 @@ int lbtf_rx(struct lbtf_private *priv, struct sk_buff *skb)
         if (!(prxpd->status & cpu_to_le16(MRVDRV_RXPD_STATUS_OK)))
                 stats.flag |= RX_FLAG_FAILED_FCS_CRC;
         stats.freq = priv->cur_freq;
-        stats.band = IEEE80211_BAND_2GHZ;
+        stats.band = NL80211_BAND_2GHZ;
         stats.signal = prxpd->snr;
         priv->noise = prxpd->nf;
         /* Marvell rate index has a hole at value 4 */
@@ -642,7 +642,7 @@ struct lbtf_private *lbtf_add_card(void *card, struct device *dmdev)
         priv->band.bitrates = priv->rates;
         priv->band.n_channels = ARRAY_SIZE(lbtf_channels);
         priv->band.channels = priv->channels;
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
         hw->wiphy->interface_modes =
                 BIT(NL80211_IFTYPE_STATION) |
                 BIT(NL80211_IFTYPE_ADHOC);
diff --git a/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c b/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
index 09578c6cde59..a74cc43b1953 100644
--- a/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
+++ b/drivers/net/wireless/marvell/mwifiex/11n_rxreorder.c
@@ -59,7 +59,10 @@ static int mwifiex_11n_dispatch_amsdu_pkt(struct mwifiex_private *priv,
                                                                   skb->len);
                         }
 
-                        ret = mwifiex_recv_packet(priv, rx_skb);
+                        if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
+                                ret = mwifiex_uap_recv_packet(priv, rx_skb);
+                        else
+                                ret = mwifiex_recv_packet(priv, rx_skb);
                         if (ret == -1)
                                 mwifiex_dbg(priv->adapter, ERROR,
                                             "Rx of A-MSDU failed");
diff --git a/drivers/net/wireless/marvell/mwifiex/cfg80211.c b/drivers/net/wireless/marvell/mwifiex/cfg80211.c
index bb7235e1b9d1..6db202fa7157 100644
--- a/drivers/net/wireless/marvell/mwifiex/cfg80211.c
+++ b/drivers/net/wireless/marvell/mwifiex/cfg80211.c
@@ -474,7 +474,7 @@ int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
         u8 no_of_parsed_chan = 0;
         u8 first_chan = 0, next_chan = 0, max_pwr = 0;
         u8 i, flag = 0;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
         struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
@@ -1410,7 +1410,7 @@ mwifiex_cfg80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
 {
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
         struct mwifiex_chan_stats *pchan_stats = priv->adapter->chan_stats;
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         mwifiex_dbg(priv->adapter, DUMP, "dump_survey idx=%d\n", idx);
 
@@ -1586,7 +1586,7 @@ static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
 {
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
         u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct mwifiex_adapter *adapter = priv->adapter;
 
         if (!priv->media_connected) {
@@ -1600,11 +1600,11 @@ static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
         memset(bitmap_rates, 0, sizeof(bitmap_rates));
 
         /* Fill HR/DSSS rates. */
-        if (band == IEEE80211_BAND_2GHZ)
+        if (band == NL80211_BAND_2GHZ)
                 bitmap_rates[0] = mask->control[band].legacy & 0x000f;
 
         /* Fill OFDM rates */
-        if (band == IEEE80211_BAND_2GHZ)
+        if (band == NL80211_BAND_2GHZ)
                 bitmap_rates[1] = (mask->control[band].legacy & 0x0ff0) >> 4;
         else
                 bitmap_rates[1] = mask->control[band].legacy;
@@ -1771,7 +1771,7 @@ mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
         } else {
                 struct ieee80211_sta_ht_cap *ht_info;
                 int rx_mcs_supp;
-                enum ieee80211_band band;
+                enum nl80211_band band;
 
                 if ((tx_ant == 0x1 && rx_ant == 0x1)) {
                         adapter->user_dev_mcs_support = HT_STREAM_1X1;
@@ -1785,7 +1785,7 @@ mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
                                                 MWIFIEX_11AC_MCS_MAP_2X2;
                 }
 
-                for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+                for (band = 0; band < NUM_NL80211_BANDS; band++) {
                         if (!adapter->wiphy->bands[band])
                                 continue;
 
@@ -1997,7 +1997,7 @@ static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
         struct cfg80211_bss *bss;
         int ie_len;
         u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         if (mwifiex_get_bss_info(priv, &bss_info))
                 return -1;
@@ -2271,7 +2271,7 @@ static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
         int index = 0, i;
         u8 config_bands = 0;
 
-        if (params->chandef.chan->band == IEEE80211_BAND_2GHZ) {
+        if (params->chandef.chan->band == NL80211_BAND_2GHZ) {
                 if (!params->basic_rates) {
                         config_bands = BAND_B | BAND_G;
                 } else {
@@ -2859,18 +2859,18 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
         mwifiex_init_priv_params(priv, dev);
         priv->netdev = dev;
 
-        mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);
+        mwifiex_setup_ht_caps(&wiphy->bands[NL80211_BAND_2GHZ]->ht_cap, priv);
         if (adapter->is_hw_11ac_capable)
                 mwifiex_setup_vht_caps(
-                        &wiphy->bands[IEEE80211_BAND_2GHZ]->vht_cap, priv);
+                        &wiphy->bands[NL80211_BAND_2GHZ]->vht_cap, priv);
 
         if (adapter->config_bands & BAND_A)
                 mwifiex_setup_ht_caps(
-                        &wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);
+                        &wiphy->bands[NL80211_BAND_5GHZ]->ht_cap, priv);
 
         if ((adapter->config_bands & BAND_A) && adapter->is_hw_11ac_capable)
                 mwifiex_setup_vht_caps(
-                        &wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap, priv);
+                        &wiphy->bands[NL80211_BAND_5GHZ]->vht_cap, priv);
 
         dev_net_set(dev, wiphy_net(wiphy));
         dev->ieee80211_ptr = &priv->wdev;
@@ -3272,8 +3272,11 @@ static int mwifiex_cfg80211_suspend(struct wiphy *wiphy,
 
         for (i = 0; i < adapter->priv_num; i++) {
                 priv = adapter->priv[i];
-                if (priv && priv->netdev)
+                if (priv && priv->netdev) {
                         mwifiex_stop_net_dev_queue(priv->netdev, adapter);
+                        if (netif_carrier_ok(priv->netdev))
+                                netif_carrier_off(priv->netdev);
+                }
         }
 
         for (i = 0; i < retry_num; i++) {
@@ -3344,8 +3347,11 @@ static int mwifiex_cfg80211_resume(struct wiphy *wiphy)
 
         for (i = 0; i < adapter->priv_num; i++) {
                 priv = adapter->priv[i];
-                if (priv && priv->netdev)
+                if (priv && priv->netdev) {
+                        if (!netif_carrier_ok(priv->netdev))
+                                netif_carrier_on(priv->netdev);
                         mwifiex_wake_up_net_dev_queue(priv->netdev, adapter);
+                }
         }
 
         priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
@@ -3384,6 +3390,10 @@ static int mwifiex_cfg80211_resume(struct wiphy *wiphy)
                 break;
         case    MANAGEMENT_FRAME_MATCHED:
                 break;
+        case GTK_REKEY_FAILURE:
+                if (wiphy->wowlan_config->gtk_rekey_failure)
+                        wakeup_report.gtk_rekey_failure = true;
+                break;
         default:
                 break;
         }
@@ -3410,6 +3420,16 @@ static void mwifiex_cfg80211_set_wakeup(struct wiphy *wiphy,
 
         device_set_wakeup_enable(adapter->dev, enabled);
 }
+
+static int mwifiex_set_rekey_data(struct wiphy *wiphy, struct net_device *dev,
+                                  struct cfg80211_gtk_rekey_data *data)
+{
+        struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
+
+        return mwifiex_send_cmd(priv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG,
+                                HostCmd_ACT_GEN_SET, 0, data, true);
+}
+
 #endif
 
 static int mwifiex_get_coalesce_pkt_type(u8 *byte_seq)
@@ -3801,7 +3821,7 @@ static int mwifiex_cfg80211_get_channel(struct wiphy *wiphy,
         struct ieee80211_channel *chan;
         u8 second_chan_offset;
         enum nl80211_channel_type chan_type;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         int freq;
         int ret = -ENODATA;
 
@@ -3932,6 +3952,7 @@ static struct cfg80211_ops mwifiex_cfg80211_ops = {
         .suspend = mwifiex_cfg80211_suspend,
         .resume = mwifiex_cfg80211_resume,
         .set_wakeup = mwifiex_cfg80211_set_wakeup,
+        .set_rekey_data = mwifiex_set_rekey_data,
 #endif
         .set_coalesce = mwifiex_cfg80211_set_coalesce,
         .tdls_mgmt = mwifiex_cfg80211_tdls_mgmt,
@@ -3948,7 +3969,8 @@ static struct cfg80211_ops mwifiex_cfg80211_ops = {
 #ifdef CONFIG_PM
 static const struct wiphy_wowlan_support mwifiex_wowlan_support = {
         .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT |
-                WIPHY_WOWLAN_NET_DETECT,
+                WIPHY_WOWLAN_NET_DETECT | WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
+                WIPHY_WOWLAN_GTK_REKEY_FAILURE,
         .n_patterns = MWIFIEX_MEF_MAX_FILTERS,
         .pattern_min_len = 1,
         .pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
@@ -4031,11 +4053,11 @@ int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
                                  BIT(NL80211_IFTYPE_P2P_GO) |
                                  BIT(NL80211_IFTYPE_AP);
 
-        wiphy->bands[IEEE80211_BAND_2GHZ] = &mwifiex_band_2ghz;
+        wiphy->bands[NL80211_BAND_2GHZ] = &mwifiex_band_2ghz;
         if (adapter->config_bands & BAND_A)
-                wiphy->bands[IEEE80211_BAND_5GHZ] = &mwifiex_band_5ghz;
+                wiphy->bands[NL80211_BAND_5GHZ] = &mwifiex_band_5ghz;
         else
-                wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
+                wiphy->bands[NL80211_BAND_5GHZ] = NULL;
 
         if (adapter->drcs_enabled && ISSUPP_DRCS_ENABLED(adapter->fw_cap_info))
                 wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta_drcs;
@@ -4086,6 +4108,7 @@ int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
 
         wiphy->features |= NL80211_FEATURE_HT_IBSS |
                            NL80211_FEATURE_INACTIVITY_TIMER |
+                           NL80211_FEATURE_LOW_PRIORITY_SCAN |
                            NL80211_FEATURE_NEED_OBSS_SCAN;
 
         if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
diff --git a/drivers/net/wireless/marvell/mwifiex/cfp.c b/drivers/net/wireless/marvell/mwifiex/cfp.c
index 09fae27140f7..1ff22055e54f 100644
--- a/drivers/net/wireless/marvell/mwifiex/cfp.c
+++ b/drivers/net/wireless/marvell/mwifiex/cfp.c
@@ -322,9 +322,9 @@ mwifiex_get_cfp(struct mwifiex_private *priv, u8 band, u16 channel, u32 freq)
                 return cfp;
 
         if (mwifiex_band_to_radio_type(band) == HostCmd_SCAN_RADIO_TYPE_BG)
-                sband = priv->wdev.wiphy->bands[IEEE80211_BAND_2GHZ];
+                sband = priv->wdev.wiphy->bands[NL80211_BAND_2GHZ];
         else
-                sband = priv->wdev.wiphy->bands[IEEE80211_BAND_5GHZ];
+                sband = priv->wdev.wiphy->bands[NL80211_BAND_5GHZ];
 
         if (!sband) {
                 mwifiex_dbg(priv->adapter, ERROR,
@@ -399,15 +399,15 @@ u32 mwifiex_get_rates_from_cfg80211(struct mwifiex_private *priv,
         int i;
 
         if (radio_type) {
-                sband = wiphy->bands[IEEE80211_BAND_5GHZ];
+                sband = wiphy->bands[NL80211_BAND_5GHZ];
                 if (WARN_ON_ONCE(!sband))
                         return 0;
-                rate_mask = request->rates[IEEE80211_BAND_5GHZ];
+                rate_mask = request->rates[NL80211_BAND_5GHZ];
         } else {
-                sband = wiphy->bands[IEEE80211_BAND_2GHZ];
+                sband = wiphy->bands[NL80211_BAND_2GHZ];
                 if (WARN_ON_ONCE(!sband))
                         return 0;
-                rate_mask = request->rates[IEEE80211_BAND_2GHZ];
+                rate_mask = request->rates[NL80211_BAND_2GHZ];
         }
 
         num_rates = 0;
diff --git a/drivers/net/wireless/marvell/mwifiex/fw.h b/drivers/net/wireless/marvell/mwifiex/fw.h
index c134cf865291..8e4145abdbfa 100644
--- a/drivers/net/wireless/marvell/mwifiex/fw.h
+++ b/drivers/net/wireless/marvell/mwifiex/fw.h
@@ -372,6 +372,7 @@ enum MWIFIEX_802_11_PRIVACY_FILTER {
 #define HostCmd_CMD_COALESCE_CFG                      0x010a
 #define HostCmd_CMD_MGMT_FRAME_REG                    0x010c
 #define HostCmd_CMD_REMAIN_ON_CHAN                    0x010d
+#define HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG             0x010f
 #define HostCmd_CMD_11AC_CFG                          0x0112
 #define HostCmd_CMD_HS_WAKEUP_REASON                  0x0116
 #define HostCmd_CMD_TDLS_CONFIG                       0x0100
@@ -619,6 +620,7 @@ enum HS_WAKEUP_REASON {
         MAGIC_PATTERN_MATCHED,
         CONTROL_FRAME_MATCHED,
         MANAGEMENT_FRAME_MATCHED,
+        GTK_REKEY_FAILURE,
         RESERVED
 };
 
@@ -2183,6 +2185,14 @@ struct host_cmd_ds_wakeup_reason {
         u16  wakeup_reason;
 } __packed;
 
+struct host_cmd_ds_gtk_rekey_params {
+        __le16 action;
+        u8 kck[NL80211_KCK_LEN];
+        u8 kek[NL80211_KEK_LEN];
+        __le32 replay_ctr_low;
+        __le32 replay_ctr_high;
+} __packed;
+
 struct host_cmd_ds_command {
         __le16 command;
         __le16 size;
@@ -2256,6 +2266,7 @@ struct host_cmd_ds_command {
                 struct host_cmd_ds_multi_chan_policy mc_policy;
                 struct host_cmd_ds_robust_coex coex;
                 struct host_cmd_ds_wakeup_reason hs_wakeup_reason;
+                struct host_cmd_ds_gtk_rekey_params rekey;
         } params;
 } __packed;
 
diff --git a/drivers/net/wireless/marvell/mwifiex/main.c b/drivers/net/wireless/marvell/mwifiex/main.c
index 3cfa94677a8e..04b975cbb330 100644
--- a/drivers/net/wireless/marvell/mwifiex/main.c
+++ b/drivers/net/wireless/marvell/mwifiex/main.c
@@ -1074,12 +1074,14 @@ void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter)
                              priv->netdev->name, priv->num_tx_timeout);
         }
 
-        if (adapter->iface_type == MWIFIEX_SDIO) {
-                p += sprintf(p, "\n=== SDIO register dump===\n");
+        if (adapter->iface_type == MWIFIEX_SDIO ||
+            adapter->iface_type == MWIFIEX_PCIE) {
+                p += sprintf(p, "\n=== %s register dump===\n",
+                             adapter->iface_type == MWIFIEX_SDIO ?
+                                                        "SDIO" : "PCIE");
                 if (adapter->if_ops.reg_dump)
                         p += adapter->if_ops.reg_dump(adapter, p);
         }
-
         p += sprintf(p, "\n=== more debug information\n");
         debug_info = kzalloc(sizeof(*debug_info), GFP_KERNEL);
         if (debug_info) {
diff --git a/drivers/net/wireless/marvell/mwifiex/main.h b/drivers/net/wireless/marvell/mwifiex/main.h
index aafc4ab4e5ae..a159fbef20cd 100644
--- a/drivers/net/wireless/marvell/mwifiex/main.h
+++ b/drivers/net/wireless/marvell/mwifiex/main.h
@@ -1019,6 +1019,8 @@ int mwifiex_shutdown_fw_complete(struct mwifiex_adapter *adapter);
 int mwifiex_dnld_fw(struct mwifiex_adapter *, struct mwifiex_fw_image *);
 
 int mwifiex_recv_packet(struct mwifiex_private *priv, struct sk_buff *skb);
+int mwifiex_uap_recv_packet(struct mwifiex_private *priv,
+                            struct sk_buff *skb);
 
 int mwifiex_process_mgmt_packet(struct mwifiex_private *priv,
                                 struct sk_buff *skb);
diff --git a/drivers/net/wireless/marvell/mwifiex/pcie.c b/drivers/net/wireless/marvell/mwifiex/pcie.c
index de364381fe7b..edf8b070f665 100644
--- a/drivers/net/wireless/marvell/mwifiex/pcie.c
+++ b/drivers/net/wireless/marvell/mwifiex/pcie.c
@@ -190,7 +190,6 @@ static int mwifiex_pcie_probe(struct pci_dev *pdev,
 
         if (ent->driver_data) {
                 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
-                card->pcie.firmware = data->firmware;
                 card->pcie.reg = data->reg;
                 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
                 card->pcie.tx_buf_size = data->tx_buf_size;
@@ -269,6 +268,11 @@ static const struct pci_device_id mwifiex_ids[] = {
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 .driver_data = (unsigned long)&mwifiex_pcie8997,
         },
+        {
+                PCIE_VENDOR_ID_V2_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8997,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                .driver_data = (unsigned long)&mwifiex_pcie8997,
+        },
         {},
 };
 
@@ -2351,6 +2355,47 @@ static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
         return 0;
 }
 
+/* Function to dump PCIE scratch registers in case of FW crash
+ */
+static int
+mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
+{
+        char *p = drv_buf;
+        char buf[256], *ptr;
+        int i;
+        u32 value;
+        struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
+        int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
+                                  PCIE_SCRATCH_13_REG,
+                                  PCIE_SCRATCH_14_REG};
+
+        if (!p)
+                return 0;
+
+        mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
+
+        if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
+                mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
+                return 0;
+        }
+
+        ptr = buf;
+        mwifiex_dbg(adapter, MSG, "pcie scratch register:");
+        for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
+                mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
+                ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
+                               pcie_scratch_reg[i], value);
+        }
+
+        mwifiex_dbg(adapter, MSG, "%s\n", buf);
+        p += sprintf(p, "%s\n", buf);
+
+        mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
+
+        return p - drv_buf;
+}
+
 /* This function read/write firmware */
 static enum rdwr_status
 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
@@ -2759,6 +2804,51 @@ static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
 }
 
 /*
+ * This function get firmare name for downloading by revision id
+ *
+ * Read revision id register to get revision id
+ */
+static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
+{
+        int revision_id = 0;
+        struct pcie_service_card *card = adapter->card;
+
+        switch (card->dev->device) {
+        case PCIE_DEVICE_ID_MARVELL_88W8766P:
+                strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
+                break;
+        case PCIE_DEVICE_ID_MARVELL_88W8897:
+                mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
+                mwifiex_read_reg(adapter, 0x0c58, &revision_id);
+                revision_id &= 0xff00;
+                switch (revision_id) {
+                case PCIE8897_A0:
+                        strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
+                        break;
+                case PCIE8897_B0:
+                        strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
+                        break;
+                default:
+                        break;
+                }
+        case PCIE_DEVICE_ID_MARVELL_88W8997:
+                mwifiex_read_reg(adapter, 0x0c48, &revision_id);
+                switch (revision_id) {
+                case PCIE8997_V2:
+                        strcpy(adapter->fw_name, PCIE8997_FW_NAME_V2);
+                        break;
+                case PCIE8997_Z:
+                        strcpy(adapter->fw_name, PCIE8997_FW_NAME_Z);
+                        break;
+                default:
+                        break;
+                }
+        default:
+                break;
+        }
+}
+
+/*
  * This function registers the PCIE device.
  *
  * PCIE IRQ is claimed, block size is set and driver data is initialized.
@@ -2778,8 +2868,8 @@ static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
         adapter->tx_buf_size = card->pcie.tx_buf_size;
         adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
         adapter->num_mem_types = card->pcie.num_mem_types;
-        strcpy(adapter->fw_name, card->pcie.firmware);
         adapter->ext_scan = card->pcie.can_ext_scan;
+        mwifiex_pcie_get_fw_name(adapter);
 
         return 0;
 }
@@ -2850,6 +2940,7 @@ static struct mwifiex_if_ops pcie_ops = {
         .cleanup_mpa_buf =              NULL,
         .init_fw_port =                 mwifiex_pcie_init_fw_port,
         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
+        .reg_dump =                     mwifiex_pcie_reg_dump,
         .device_dump =                  mwifiex_pcie_device_dump,
 };
 
@@ -2907,6 +2998,3 @@ MODULE_AUTHOR("Marvell International Ltd.");
 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
 MODULE_VERSION(PCIE_VERSION);
 MODULE_LICENSE("GPL v2");
-MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
-MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);
-MODULE_FIRMWARE(PCIE8997_DEFAULT_FW_NAME);
diff --git a/drivers/net/wireless/marvell/mwifiex/pcie.h b/drivers/net/wireless/marvell/mwifiex/pcie.h
index 29e58ce877e3..cc7a5df903be 100644
--- a/drivers/net/wireless/marvell/mwifiex/pcie.h
+++ b/drivers/net/wireless/marvell/mwifiex/pcie.h
@@ -30,14 +30,22 @@
 #include    "main.h"
 
 #define PCIE8766_DEFAULT_FW_NAME "mrvl/pcie8766_uapsta.bin"
-#define PCIE8897_DEFAULT_FW_NAME "mrvl/pcie8897_uapsta.bin"
-#define PCIE8997_DEFAULT_FW_NAME "mrvl/pcie8997_uapsta.bin"
+#define PCIE8897_A0_FW_NAME "mrvl/pcie8897_uapsta_a0.bin"
+#define PCIE8897_B0_FW_NAME "mrvl/pcie8897_uapsta.bin"
+#define PCIE8997_FW_NAME_Z "mrvl/pcieusb8997_combo.bin"
+#define PCIE8997_FW_NAME_V2 "mrvl/pcieusb8997_combo_v2.bin"
 
 #define PCIE_VENDOR_ID_MARVELL              (0x11ab)
+#define PCIE_VENDOR_ID_V2_MARVELL           (0x1b4b)
 #define PCIE_DEVICE_ID_MARVELL_88W8766P         (0x2b30)
 #define PCIE_DEVICE_ID_MARVELL_88W8897          (0x2b38)
 #define PCIE_DEVICE_ID_MARVELL_88W8997          (0x2b42)
 
+#define PCIE8897_A0     0x1100
+#define PCIE8897_B0     0x1200
+#define PCIE8997_Z      0x0
+#define PCIE8997_V2     0x471
+
 /* Constants for Buffer Descriptor (BD) rings */
 #define MWIFIEX_MAX_TXRX_BD                     0x20
 #define MWIFIEX_TXBD_MASK                       0x3F
@@ -65,6 +73,8 @@
 #define PCIE_SCRATCH_10_REG                             0xCE8
 #define PCIE_SCRATCH_11_REG                             0xCEC
 #define PCIE_SCRATCH_12_REG                             0xCF0
+#define PCIE_SCRATCH_13_REG                             0xCF8
+#define PCIE_SCRATCH_14_REG                             0xCFC
 #define PCIE_RD_DATA_PTR_Q0_Q1                          0xC08C
 #define PCIE_WR_DATA_PTR_Q0_Q1                          0xC05C
 
@@ -263,7 +273,6 @@ static struct memory_type_mapping mem_type_mapping_tbl_w8997[] = {
 };
 
 struct mwifiex_pcie_device {
-        const char *firmware;
         const struct mwifiex_pcie_card_reg *reg;
         u16 blksz_fw_dl;
         u16 tx_buf_size;
@@ -274,7 +283,6 @@ struct mwifiex_pcie_device {
 };
 
 static const struct mwifiex_pcie_device mwifiex_pcie8766 = {
-        .firmware       = PCIE8766_DEFAULT_FW_NAME,
         .reg            = &mwifiex_reg_8766,
         .blksz_fw_dl = MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD,
         .tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K,
@@ -283,7 +291,6 @@ static const struct mwifiex_pcie_device mwifiex_pcie8766 = {
 };
 
 static const struct mwifiex_pcie_device mwifiex_pcie8897 = {
-        .firmware       = PCIE8897_DEFAULT_FW_NAME,
         .reg            = &mwifiex_reg_8897,
         .blksz_fw_dl = MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD,
         .tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K,
@@ -294,7 +301,6 @@ static const struct mwifiex_pcie_device mwifiex_pcie8897 = {
 };
 
 static const struct mwifiex_pcie_device mwifiex_pcie8997 = {
-        .firmware       = PCIE8997_DEFAULT_FW_NAME,
         .reg            = &mwifiex_reg_8997,
         .blksz_fw_dl = MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD,
         .tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_4K,
diff --git a/drivers/net/wireless/marvell/mwifiex/scan.c b/drivers/net/wireless/marvell/mwifiex/scan.c
index 489f7a911a83..624b0a95c64e 100644
--- a/drivers/net/wireless/marvell/mwifiex/scan.c
+++ b/drivers/net/wireless/marvell/mwifiex/scan.c
@@ -494,13 +494,13 @@ mwifiex_scan_create_channel_list(struct mwifiex_private *priv,
                                                         *scan_chan_list,
                                  u8 filtered_scan)
 {
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
         struct mwifiex_adapter *adapter = priv->adapter;
         int chan_idx = 0, i;
 
-        for (band = 0; (band < IEEE80211_NUM_BANDS) ; band++) {
+        for (band = 0; (band < NUM_NL80211_BANDS) ; band++) {
 
                 if (!priv->wdev.wiphy->bands[band])
                         continue;
@@ -557,13 +557,13 @@ mwifiex_bgscan_create_channel_list(struct mwifiex_private *priv,
                                    struct mwifiex_chan_scan_param_set
                                                 *scan_chan_list)
 {
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
         struct mwifiex_adapter *adapter = priv->adapter;
         int chan_idx = 0, i;
 
-        for (band = 0; (band < IEEE80211_NUM_BANDS); band++) {
+        for (band = 0; (band < NUM_NL80211_BANDS); band++) {
                 if (!priv->wdev.wiphy->bands[band])
                         continue;
 
diff --git a/drivers/net/wireless/marvell/mwifiex/sdio.c b/drivers/net/wireless/marvell/mwifiex/sdio.c
index b2c839ae2c3c..a0aec3e00457 100644
--- a/drivers/net/wireless/marvell/mwifiex/sdio.c
+++ b/drivers/net/wireless/marvell/mwifiex/sdio.c
@@ -1123,8 +1123,8 @@ static void mwifiex_deaggr_sdio_pkt(struct mwifiex_adapter *adapter,
                                     __func__, pkt_len, blk_size);
                         break;
                 }
-                skb_deaggr = mwifiex_alloc_dma_align_buf(pkt_len,
-                                                         GFP_KERNEL | GFP_DMA);
+
+                skb_deaggr = mwifiex_alloc_dma_align_buf(pkt_len, GFP_KERNEL);
                 if (!skb_deaggr)
                         break;
                 skb_put(skb_deaggr, pkt_len);
@@ -1373,8 +1373,7 @@ static int mwifiex_sdio_card_to_host_mp_aggr(struct mwifiex_adapter *adapter,
 
                         /* copy pkt to deaggr buf */
                         skb_deaggr = mwifiex_alloc_dma_align_buf(len_arr[pind],
-                                                                 GFP_KERNEL |
-                                                                 GFP_DMA);
+                                                                 GFP_KERNEL);
                         if (!skb_deaggr) {
                                 mwifiex_dbg(adapter, ERROR, "skb allocation failure\t"
                                             "drop pkt len=%d type=%d\n",
diff --git a/drivers/net/wireless/marvell/mwifiex/sta_cmd.c b/drivers/net/wireless/marvell/mwifiex/sta_cmd.c
index 30f152601c57..8cb895b7f2ee 100644
--- a/drivers/net/wireless/marvell/mwifiex/sta_cmd.c
+++ b/drivers/net/wireless/marvell/mwifiex/sta_cmd.c
@@ -1558,6 +1558,30 @@ static int mwifiex_cmd_robust_coex(struct mwifiex_private *priv,
         return 0;
 }
 
+static int mwifiex_cmd_gtk_rekey_offload(struct mwifiex_private *priv,
+                                         struct host_cmd_ds_command *cmd,
+                                         u16 cmd_action,
+                                         struct cfg80211_gtk_rekey_data *data)
+{
+        struct host_cmd_ds_gtk_rekey_params *rekey = &cmd->params.rekey;
+        u64 rekey_ctr;
+
+        cmd->command = cpu_to_le16(HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG);
+        cmd->size = cpu_to_le16(sizeof(*rekey) + S_DS_GEN);
+
+        rekey->action = cpu_to_le16(cmd_action);
+        if (cmd_action == HostCmd_ACT_GEN_SET) {
+                memcpy(rekey->kek, data->kek, NL80211_KEK_LEN);
+                memcpy(rekey->kck, data->kck, NL80211_KCK_LEN);
+                rekey_ctr = be64_to_cpup((__be64 *)data->replay_ctr);
+                rekey->replay_ctr_low = cpu_to_le32((u32)rekey_ctr);
+                rekey->replay_ctr_high =
+                        cpu_to_le32((u32)((u64)rekey_ctr >> 32));
+        }
+
+        return 0;
+}
+
 static int
 mwifiex_cmd_coalesce_cfg(struct mwifiex_private *priv,
                          struct host_cmd_ds_command *cmd,
@@ -2094,6 +2118,10 @@ int mwifiex_sta_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,
                 ret = mwifiex_cmd_robust_coex(priv, cmd_ptr, cmd_action,
                                               data_buf);
                 break;
+        case HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG:
+                ret = mwifiex_cmd_gtk_rekey_offload(priv, cmd_ptr, cmd_action,
+                                                    data_buf);
+                break;
         default:
                 mwifiex_dbg(priv->adapter, ERROR,
                             "PREP_CMD: unknown cmd- %#x\n", cmd_no);
diff --git a/drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c b/drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c
index d96523e10eb4..434b9776db45 100644
--- a/drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c
+++ b/drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c
@@ -1244,6 +1244,8 @@ int mwifiex_process_sta_cmdresp(struct mwifiex_private *priv, u16 cmdresp_no,
         case HostCmd_CMD_ROBUST_COEX:
                 ret = mwifiex_ret_robust_coex(priv, resp, data_buf);
                 break;
+        case HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG:
+                break;
         default:
                 mwifiex_dbg(adapter, ERROR,
                             "CMD_RESP: unknown cmd response %#x\n",
diff --git a/drivers/net/wireless/marvell/mwifiex/sta_event.c b/drivers/net/wireless/marvell/mwifiex/sta_event.c
index 070bce401151..0104108b4ea2 100644
--- a/drivers/net/wireless/marvell/mwifiex/sta_event.c
+++ b/drivers/net/wireless/marvell/mwifiex/sta_event.c
@@ -147,6 +147,9 @@ mwifiex_reset_connect_state(struct mwifiex_private *priv, u16 reason_code)
         mwifiex_stop_net_dev_queue(priv->netdev, adapter);
         if (netif_carrier_ok(priv->netdev))
                 netif_carrier_off(priv->netdev);
+
+        mwifiex_send_cmd(priv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG,
+                         HostCmd_ACT_GEN_REMOVE, 0, NULL, false);
 }
 
 static int mwifiex_parse_tdls_event(struct mwifiex_private *priv,
diff --git a/drivers/net/wireless/marvell/mwifiex/sta_ioctl.c b/drivers/net/wireless/marvell/mwifiex/sta_ioctl.c
index d5c56eb9e985..d8de432d46a2 100644
--- a/drivers/net/wireless/marvell/mwifiex/sta_ioctl.c
+++ b/drivers/net/wireless/marvell/mwifiex/sta_ioctl.c
@@ -509,7 +509,8 @@ int mwifiex_enable_hs(struct mwifiex_adapter *adapter)
 
         if (priv && priv->sched_scanning) {
 #ifdef CONFIG_PM
-                if (!priv->wdev.wiphy->wowlan_config->nd_config) {
+                if (priv->wdev.wiphy->wowlan_config &&
+                    !priv->wdev.wiphy->wowlan_config->nd_config) {
 #endif
                         mwifiex_dbg(adapter, CMD, "aborting bgscan!\n");
                         mwifiex_stop_bg_scan(priv);
diff --git a/drivers/net/wireless/marvell/mwifiex/tdls.c b/drivers/net/wireless/marvell/mwifiex/tdls.c
index 150649602e98..df9704de0715 100644
--- a/drivers/net/wireless/marvell/mwifiex/tdls.c
+++ b/drivers/net/wireless/marvell/mwifiex/tdls.c
@@ -285,7 +285,7 @@ static int mwifiex_tdls_add_vht_oper(struct mwifiex_private *priv,
         else
                 usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_bg;
 
-        /* find the minmum bandwith between AP/TDLS peers */
+        /* find the minimum bandwidth between AP/TDLS peers */
         vht_cap = &sta_ptr->tdls_cap.vhtcap;
         supp_chwd_set = GET_VHTCAP_CHWDSET(usr_vht_cap_info);
         peer_supp_chwd_set =
diff --git a/drivers/net/wireless/marvell/mwifiex/uap_cmd.c b/drivers/net/wireless/marvell/mwifiex/uap_cmd.c
index 16d95b22fe5c..f79d00d1e294 100644
--- a/drivers/net/wireless/marvell/mwifiex/uap_cmd.c
+++ b/drivers/net/wireless/marvell/mwifiex/uap_cmd.c
@@ -694,7 +694,7 @@ static int mwifiex_uap_custom_ie_prepare(u8 *tlv, void *cmd_buf, u16 *ie_size)
         struct mwifiex_ie_list *ap_ie = cmd_buf;
         struct mwifiex_ie_types_header *tlv_ie = (void *)tlv;
 
-        if (!ap_ie || !ap_ie->len || !ap_ie->ie_list)
+        if (!ap_ie || !ap_ie->len)
                 return -1;
 
         *ie_size += le16_to_cpu(ap_ie->len) +
@@ -816,7 +816,7 @@ void mwifiex_uap_set_channel(struct mwifiex_private *priv,
                                                      chandef.chan->center_freq);
 
         /* Set appropriate bands */
-        if (chandef.chan->band == IEEE80211_BAND_2GHZ) {
+        if (chandef.chan->band == NL80211_BAND_2GHZ) {
                 bss_cfg->band_cfg = BAND_CONFIG_BG;
                 config_bands = BAND_B | BAND_G;
 
diff --git a/drivers/net/wireless/marvell/mwifiex/uap_txrx.c b/drivers/net/wireless/marvell/mwifiex/uap_txrx.c
index 52f7981a8afc..c95b61dc87c2 100644
--- a/drivers/net/wireless/marvell/mwifiex/uap_txrx.c
+++ b/drivers/net/wireless/marvell/mwifiex/uap_txrx.c
@@ -212,6 +212,8 @@ static void mwifiex_uap_queue_bridged_pkt(struct mwifiex_private *priv,
         atomic_inc(&adapter->tx_pending);
         atomic_inc(&adapter->pending_bridged_pkts);
 
+        mwifiex_queue_main_work(priv->adapter);
+
         return;
 }
 
@@ -263,6 +265,96 @@ int mwifiex_handle_uap_rx_forward(struct mwifiex_private *priv,
         return mwifiex_process_rx_packet(priv, skb);
 }
 
+int mwifiex_uap_recv_packet(struct mwifiex_private *priv,
+                            struct sk_buff *skb)
+{
+        struct mwifiex_adapter *adapter = adapter;
+        struct mwifiex_sta_node *src_node;
+        struct ethhdr *p_ethhdr;
+        struct sk_buff *skb_uap;
+        struct mwifiex_txinfo *tx_info;
+
+        if (!skb)
+                return -1;
+
+        p_ethhdr = (void *)skb->data;
+        src_node = mwifiex_get_sta_entry(priv, p_ethhdr->h_source);
+        if (src_node) {
+                src_node->stats.last_rx = jiffies;
+                src_node->stats.rx_bytes += skb->len;
+                src_node->stats.rx_packets++;
+        }
+
+        skb->dev = priv->netdev;
+        skb->protocol = eth_type_trans(skb, priv->netdev);
+        skb->ip_summed = CHECKSUM_NONE;
+
+        /* This is required only in case of 11n and USB/PCIE as we alloc
+         * a buffer of 4K only if its 11N (to be able to receive 4K
+         * AMSDU packets). In case of SD we allocate buffers based
+         * on the size of packet and hence this is not needed.
+         *
+         * Modifying the truesize here as our allocation for each
+         * skb is 4K but we only receive 2K packets and this cause
+         * the kernel to start dropping packets in case where
+         * application has allocated buffer based on 2K size i.e.
+         * if there a 64K packet received (in IP fragments and
+         * application allocates 64K to receive this packet but
+         * this packet would almost double up because we allocate
+         * each 1.5K fragment in 4K and pass it up. As soon as the
+         * 64K limit hits kernel will start to drop rest of the
+         * fragments. Currently we fail the Filesndl-ht.scr script
+         * for UDP, hence this fix
+         */
+        if ((adapter->iface_type == MWIFIEX_USB ||
+             adapter->iface_type == MWIFIEX_PCIE) &&
+            (skb->truesize > MWIFIEX_RX_DATA_BUF_SIZE))
+                skb->truesize += (skb->len - MWIFIEX_RX_DATA_BUF_SIZE);
+
+        if (is_multicast_ether_addr(p_ethhdr->h_dest) ||
+            mwifiex_get_sta_entry(priv, p_ethhdr->h_dest)) {
+                if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN)
+                        skb_uap =
+                        skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
+                else
+                        skb_uap = skb_copy(skb, GFP_ATOMIC);
+
+                if (likely(skb_uap)) {
+                        tx_info = MWIFIEX_SKB_TXCB(skb_uap);
+                        memset(tx_info, 0, sizeof(*tx_info));
+                        tx_info->bss_num = priv->bss_num;
+                        tx_info->bss_type = priv->bss_type;
+                        tx_info->flags |= MWIFIEX_BUF_FLAG_BRIDGED_PKT;
+                        __net_timestamp(skb_uap);
+                        mwifiex_wmm_add_buf_txqueue(priv, skb_uap);
+                        atomic_inc(&adapter->tx_pending);
+                        atomic_inc(&adapter->pending_bridged_pkts);
+                        if ((atomic_read(&adapter->pending_bridged_pkts) >=
+                                        MWIFIEX_BRIDGED_PKTS_THR_HIGH)) {
+                                mwifiex_dbg(adapter, ERROR,
+                                            "Tx: Bridge packet limit reached. Drop packet!\n");
+                                mwifiex_uap_cleanup_tx_queues(priv);
+                        }
+
+                } else {
+                        mwifiex_dbg(adapter, ERROR, "failed to allocate skb_uap");
+                }
+
+                mwifiex_queue_main_work(adapter);
+                /* Don't forward Intra-BSS unicast packet to upper layer*/
+                if (mwifiex_get_sta_entry(priv, p_ethhdr->h_dest))
+                        return 0;
+        }
+
+        /* Forward multicast/broadcast packet to upper layer*/
+        if (in_interrupt())
+                netif_rx(skb);
+        else
+                netif_rx_ni(skb);
+
+        return 0;
+}
+
 /*
  * This function processes the packet received on AP interface.
  *
diff --git a/drivers/net/wireless/marvell/mwl8k.c b/drivers/net/wireless/marvell/mwl8k.c
index 088429d0a634..b1b400b59d86 100644
--- a/drivers/net/wireless/marvell/mwl8k.c
+++ b/drivers/net/wireless/marvell/mwl8k.c
@@ -346,20 +346,20 @@ struct mwl8k_sta {
 #define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))
 
 static const struct ieee80211_channel mwl8k_channels_24[] = {
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2412, .hw_value = 1, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2417, .hw_value = 2, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2422, .hw_value = 3, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2427, .hw_value = 4, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2432, .hw_value = 5, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2437, .hw_value = 6, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2442, .hw_value = 7, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2447, .hw_value = 8, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2452, .hw_value = 9, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2457, .hw_value = 10, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2462, .hw_value = 11, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2467, .hw_value = 12, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2472, .hw_value = 13, },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2484, .hw_value = 14, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2412, .hw_value = 1, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2417, .hw_value = 2, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2422, .hw_value = 3, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2427, .hw_value = 4, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2432, .hw_value = 5, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2437, .hw_value = 6, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2442, .hw_value = 7, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2447, .hw_value = 8, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2452, .hw_value = 9, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2457, .hw_value = 10, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2462, .hw_value = 11, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2467, .hw_value = 12, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2472, .hw_value = 13, },
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2484, .hw_value = 14, },
 };
 
 static const struct ieee80211_rate mwl8k_rates_24[] = {
@@ -379,10 +379,10 @@ static const struct ieee80211_rate mwl8k_rates_24[] = {
 };
 
 static const struct ieee80211_channel mwl8k_channels_50[] = {
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5180, .hw_value = 36, },
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5200, .hw_value = 40, },
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5220, .hw_value = 44, },
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5240, .hw_value = 48, },
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5180, .hw_value = 36, },
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5200, .hw_value = 40, },
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5220, .hw_value = 44, },
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5240, .hw_value = 48, },
 };
 
 static const struct ieee80211_rate mwl8k_rates_50[] = {
@@ -1010,11 +1010,11 @@ mwl8k_rxd_ap_process(void *_rxd, struct ieee80211_rx_status *status,
         }
 
         if (rxd->channel > 14) {
-                status->band = IEEE80211_BAND_5GHZ;
+                status->band = NL80211_BAND_5GHZ;
                 if (!(status->flag & RX_FLAG_HT))
                         status->rate_idx -= 5;
         } else {
-                status->band = IEEE80211_BAND_2GHZ;
+                status->band = NL80211_BAND_2GHZ;
         }
         status->freq = ieee80211_channel_to_frequency(rxd->channel,
                                                       status->band);
@@ -1118,11 +1118,11 @@ mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
                 status->flag |= RX_FLAG_HT;
 
         if (rxd->channel > 14) {
-                status->band = IEEE80211_BAND_5GHZ;
+                status->band = NL80211_BAND_5GHZ;
                 if (!(status->flag & RX_FLAG_HT))
                         status->rate_idx -= 5;
         } else {
-                status->band = IEEE80211_BAND_2GHZ;
+                status->band = NL80211_BAND_2GHZ;
         }
         status->freq = ieee80211_channel_to_frequency(rxd->channel,
                                                       status->band);
@@ -2300,13 +2300,13 @@ static void mwl8k_setup_2ghz_band(struct ieee80211_hw *hw)
         BUILD_BUG_ON(sizeof(priv->rates_24) != sizeof(mwl8k_rates_24));
         memcpy(priv->rates_24, mwl8k_rates_24, sizeof(mwl8k_rates_24));
 
-        priv->band_24.band = IEEE80211_BAND_2GHZ;
+        priv->band_24.band = NL80211_BAND_2GHZ;
         priv->band_24.channels = priv->channels_24;
         priv->band_24.n_channels = ARRAY_SIZE(mwl8k_channels_24);
         priv->band_24.bitrates = priv->rates_24;
         priv->band_24.n_bitrates = ARRAY_SIZE(mwl8k_rates_24);
 
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band_24;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band_24;
 }
 
 static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw)
@@ -2319,13 +2319,13 @@ static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw)
         BUILD_BUG_ON(sizeof(priv->rates_50) != sizeof(mwl8k_rates_50));
         memcpy(priv->rates_50, mwl8k_rates_50, sizeof(mwl8k_rates_50));
 
-        priv->band_50.band = IEEE80211_BAND_5GHZ;
+        priv->band_50.band = NL80211_BAND_5GHZ;
         priv->band_50.channels = priv->channels_50;
         priv->band_50.n_channels = ARRAY_SIZE(mwl8k_channels_50);
         priv->band_50.bitrates = priv->rates_50;
         priv->band_50.n_bitrates = ARRAY_SIZE(mwl8k_rates_50);
 
-        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &priv->band_50;
+        hw->wiphy->bands[NL80211_BAND_5GHZ] = &priv->band_50;
 }
 
 /*
@@ -2876,9 +2876,9 @@ static int mwl8k_cmd_tx_power(struct ieee80211_hw *hw,
         cmd->header.length = cpu_to_le16(sizeof(*cmd));
         cmd->action = cpu_to_le16(MWL8K_CMD_SET_LIST);
 
-        if (channel->band == IEEE80211_BAND_2GHZ)
+        if (channel->band == NL80211_BAND_2GHZ)
                 cmd->band = cpu_to_le16(0x1);
-        else if (channel->band == IEEE80211_BAND_5GHZ)
+        else if (channel->band == NL80211_BAND_5GHZ)
                 cmd->band = cpu_to_le16(0x4);
 
         cmd->channel = cpu_to_le16(channel->hw_value);
@@ -3067,7 +3067,7 @@ static int freq_to_idx(struct mwl8k_priv *priv, int freq)
         struct ieee80211_supported_band *sband;
         int band, ch, idx = 0;
 
-        for (band = IEEE80211_BAND_2GHZ; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
                 sband = priv->hw->wiphy->bands[band];
                 if (!sband)
                         continue;
@@ -3149,9 +3149,9 @@ static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
         cmd->action = cpu_to_le16(MWL8K_CMD_SET);
         cmd->current_channel = channel->hw_value;
 
-        if (channel->band == IEEE80211_BAND_2GHZ)
+        if (channel->band == NL80211_BAND_2GHZ)
                 cmd->channel_flags |= cpu_to_le32(0x00000001);
-        else if (channel->band == IEEE80211_BAND_5GHZ)
+        else if (channel->band == NL80211_BAND_5GHZ)
                 cmd->channel_flags |= cpu_to_le32(0x00000004);
 
         if (!priv->sw_scan_start) {
@@ -4094,10 +4094,10 @@ static int mwl8k_cmd_set_new_stn_add(struct ieee80211_hw *hw,
         memcpy(cmd->mac_addr, sta->addr, ETH_ALEN);
         cmd->stn_id = cpu_to_le16(sta->aid);
         cmd->action = cpu_to_le16(MWL8K_STA_ACTION_ADD);
-        if (hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ)
-                rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
+        if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ)
+                rates = sta->supp_rates[NL80211_BAND_2GHZ];
         else
-                rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+                rates = sta->supp_rates[NL80211_BAND_5GHZ] << 5;
         cmd->legacy_rates = cpu_to_le32(rates);
         if (sta->ht_cap.ht_supported) {
                 cmd->ht_rates[0] = sta->ht_cap.mcs.rx_mask[0];
@@ -4529,10 +4529,10 @@ static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw,
         p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
         p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
                 ((sta->ht_cap.ampdu_density & 7) << 2);
-        if (hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ)
-                rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
+        if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ)
+                rates = sta->supp_rates[NL80211_BAND_2GHZ];
         else
-                rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+                rates = sta->supp_rates[NL80211_BAND_5GHZ] << 5;
         legacy_rate_mask_to_array(p->legacy_rates, rates);
         memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
         p->interop = 1;
@@ -5010,11 +5010,11 @@ mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                         goto out;
                 }
 
-                if (hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ) {
-                        ap_legacy_rates = ap->supp_rates[IEEE80211_BAND_2GHZ];
+                if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) {
+                        ap_legacy_rates = ap->supp_rates[NL80211_BAND_2GHZ];
                 } else {
                         ap_legacy_rates =
-                                ap->supp_rates[IEEE80211_BAND_5GHZ] << 5;
+                                ap->supp_rates[NL80211_BAND_5GHZ] << 5;
                 }
                 memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
 
@@ -5042,7 +5042,7 @@ mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                                         idx--;
 
                                 if (hw->conf.chandef.chan->band ==
-                                    IEEE80211_BAND_2GHZ)
+                                    NL80211_BAND_2GHZ)
                                         rate = mwl8k_rates_24[idx].hw_value;
                                 else
                                         rate = mwl8k_rates_50[idx].hw_value;
@@ -5116,7 +5116,7 @@ mwl8k_bss_info_changed_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                 if (idx)
                         idx--;
 
-                if (hw->conf.chandef.chan->band == IEEE80211_BAND_2GHZ)
+                if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ)
                         rate = mwl8k_rates_24[idx].hw_value;
                 else
                         rate = mwl8k_rates_50[idx].hw_value;
@@ -5388,7 +5388,7 @@ static int mwl8k_get_survey(struct ieee80211_hw *hw, int idx,
         struct ieee80211_supported_band *sband;
 
         if (priv->ap_fw) {
-                sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
+                sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
 
                 if (sband && idx >= sband->n_channels) {
                         idx -= sband->n_channels;
@@ -5396,7 +5396,7 @@ static int mwl8k_get_survey(struct ieee80211_hw *hw, int idx,
                 }
 
                 if (!sband)
-                        sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
+                        sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
 
                 if (!sband || idx >= sband->n_channels)
                         return -ENOENT;
diff --git a/drivers/net/wireless/mediatek/mt7601u/init.c b/drivers/net/wireless/mediatek/mt7601u/init.c
index 26190fd33407..8fa78d7156be 100644
--- a/drivers/net/wireless/mediatek/mt7601u/init.c
+++ b/drivers/net/wireless/mediatek/mt7601u/init.c
@@ -469,7 +469,7 @@ struct mt7601u_dev *mt7601u_alloc_device(struct device *pdev)
 }
 
 #define CHAN2G(_idx, _freq) {                   \
-        .band = IEEE80211_BAND_2GHZ,            \
+        .band = NL80211_BAND_2GHZ,              \
         .center_freq = (_freq),                 \
         .hw_value = (_idx),                     \
         .max_power = 30,                        \
@@ -563,7 +563,7 @@ mt76_init_sband_2g(struct mt7601u_dev *dev)
 {
         dev->sband_2g = devm_kzalloc(dev->dev, sizeof(*dev->sband_2g),
                                      GFP_KERNEL);
-        dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = dev->sband_2g;
+        dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = dev->sband_2g;
 
         WARN_ON(dev->ee->reg.start - 1 + dev->ee->reg.num >
                 ARRAY_SIZE(mt76_channels_2ghz));
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2800lib.c b/drivers/net/wireless/ralink/rt2x00/rt2800lib.c
index 7fa0128de7e3..c36fa4e03fb6 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2800lib.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2800lib.c
@@ -777,7 +777,7 @@ static int rt2800_agc_to_rssi(struct rt2x00_dev *rt2x00dev, u32 rxwi_w2)
         u8 offset1;
         u8 offset2;
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_2GHZ) {
                 rt2800_eeprom_read(rt2x00dev, EEPROM_RSSI_BG, &eeprom);
                 offset0 = rt2x00_get_field16(eeprom, EEPROM_RSSI_BG_OFFSET0);
                 offset1 = rt2x00_get_field16(eeprom, EEPROM_RSSI_BG_OFFSET1);
@@ -1174,7 +1174,7 @@ static void rt2800_brightness_set(struct led_classdev *led_cdev,
             container_of(led_cdev, struct rt2x00_led, led_dev);
         unsigned int enabled = brightness != LED_OFF;
         unsigned int bg_mode =
-            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_2GHZ);
+            (enabled && led->rt2x00dev->curr_band == NL80211_BAND_2GHZ);
         unsigned int polarity =
                 rt2x00_get_field16(led->rt2x00dev->led_mcu_reg,
                                    EEPROM_FREQ_LED_POLARITY);
@@ -1741,7 +1741,7 @@ static void rt2800_config_3572bt_ant(struct rt2x00_dev *rt2x00dev)
         u8 led_ctrl, led_g_mode, led_r_mode;
 
         rt2800_register_read(rt2x00dev, GPIO_SWITCH, &reg);
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 rt2x00_set_field32(&reg, GPIO_SWITCH_0, 1);
                 rt2x00_set_field32(&reg, GPIO_SWITCH_1, 1);
         } else {
@@ -1844,7 +1844,7 @@ void rt2800_config_ant(struct rt2x00_dev *rt2x00dev, struct antenna_setup *ant)
                     rt2x00_has_cap_bt_coexist(rt2x00dev)) {
                         rt2x00_set_field8(&r3, BBP3_RX_ADC, 1);
                         rt2x00_set_field8(&r3, BBP3_RX_ANTENNA,
-                                rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
+                                rt2x00dev->curr_band == NL80211_BAND_5GHZ);
                         rt2800_set_ant_diversity(rt2x00dev, ANTENNA_B);
                 } else {
                         rt2x00_set_field8(&r3, BBP3_RX_ANTENNA, 1);
@@ -3451,7 +3451,7 @@ static int rt2800_get_gain_calibration_delta(struct rt2x00_dev *rt2x00dev)
          * Matching Delta value   -4   -3   -2   -1    0   +1   +2   +3   +4
          * Example TSSI bounds  0xF0 0xD0 0xB5 0xA0 0x88 0x45 0x25 0x15 0x00
          */
-        if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_2GHZ) {
                 rt2800_eeprom_read(rt2x00dev, EEPROM_TSSI_BOUND_BG1, &eeprom);
                 tssi_bounds[0] = rt2x00_get_field16(eeprom,
                                         EEPROM_TSSI_BOUND_BG1_MINUS4);
@@ -3546,7 +3546,7 @@ static int rt2800_get_gain_calibration_delta(struct rt2x00_dev *rt2x00dev)
 }
 
 static int rt2800_get_txpower_bw_comp(struct rt2x00_dev *rt2x00dev,
-                                      enum ieee80211_band band)
+                                      enum nl80211_band band)
 {
         u16 eeprom;
         u8 comp_en;
@@ -3562,7 +3562,7 @@ static int rt2800_get_txpower_bw_comp(struct rt2x00_dev *rt2x00dev,
             !test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags))
                 return 0;
 
-        if (band == IEEE80211_BAND_2GHZ) {
+        if (band == NL80211_BAND_2GHZ) {
                 comp_en = rt2x00_get_field16(eeprom,
                                  EEPROM_TXPOWER_DELTA_ENABLE_2G);
                 if (comp_en) {
@@ -3611,7 +3611,7 @@ static int rt2800_get_txpower_reg_delta(struct rt2x00_dev *rt2x00dev,
 }
 
 static u8 rt2800_compensate_txpower(struct rt2x00_dev *rt2x00dev, int is_rate_b,
-                                   enum ieee80211_band band, int power_level,
+                                   enum nl80211_band band, int power_level,
                                    u8 txpower, int delta)
 {
         u16 eeprom;
@@ -3639,7 +3639,7 @@ static u8 rt2800_compensate_txpower(struct rt2x00_dev *rt2x00dev, int is_rate_b,
                 rt2800_eeprom_read(rt2x00dev, EEPROM_EIRP_MAX_TX_POWER,
                                    &eeprom);
 
-                if (band == IEEE80211_BAND_2GHZ)
+                if (band == NL80211_BAND_2GHZ)
                         eirp_txpower_criterion = rt2x00_get_field16(eeprom,
                                                  EEPROM_EIRP_MAX_TX_POWER_2GHZ);
                 else
@@ -3686,7 +3686,7 @@ static void rt2800_config_txpower_rt3593(struct rt2x00_dev *rt2x00dev,
         u16 eeprom;
         u32 regs[TX_PWR_CFG_IDX_COUNT];
         unsigned int offset;
-        enum ieee80211_band band = chan->band;
+        enum nl80211_band band = chan->band;
         int delta;
         int i;
 
@@ -3697,7 +3697,7 @@ static void rt2800_config_txpower_rt3593(struct rt2x00_dev *rt2x00dev,
         /* calculate temperature compensation delta */
         delta = rt2800_get_gain_calibration_delta(rt2x00dev);
 
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 offset = 16;
         else
                 offset = 0;
@@ -4055,7 +4055,7 @@ static void rt2800_config_txpower_rt3593(struct rt2x00_dev *rt2x00dev,
         for (i = 0; i < TX_PWR_CFG_IDX_COUNT; i++)
                 rt2x00_dbg(rt2x00dev,
                            "band:%cGHz, BW:%c0MHz, TX_PWR_CFG_%d%s = %08lx\n",
-                           (band == IEEE80211_BAND_5GHZ) ? '5' : '2',
+                           (band == NL80211_BAND_5GHZ) ? '5' : '2',
                            (test_bit(CONFIG_CHANNEL_HT40, &rt2x00dev->flags)) ?
                                                                 '4' : '2',
                            (i > TX_PWR_CFG_9_IDX) ?
@@ -4081,7 +4081,7 @@ static void rt2800_config_txpower_rt28xx(struct rt2x00_dev *rt2x00dev,
         u16 eeprom;
         u32 reg, offset;
         int i, is_rate_b, delta, power_ctrl;
-        enum ieee80211_band band = chan->band;
+        enum nl80211_band band = chan->band;
 
         /*
          * Calculate HT40 compensation. For 40MHz we need to add or subtract
@@ -4436,7 +4436,7 @@ static u8 rt2800_get_default_vgc(struct rt2x00_dev *rt2x00dev)
 {
         u8 vgc;
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_2GHZ) {
                 if (rt2x00_rt(rt2x00dev, RT3070) ||
                     rt2x00_rt(rt2x00dev, RT3071) ||
                     rt2x00_rt(rt2x00dev, RT3090) ||
@@ -4511,7 +4511,7 @@ void rt2800_link_tuner(struct rt2x00_dev *rt2x00dev, struct link_qual *qual,
         case RT3572:
         case RT3593:
                 if (qual->rssi > -65) {
-                        if (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ)
+                        if (rt2x00dev->curr_band == NL80211_BAND_2GHZ)
                                 vgc += 0x20;
                         else
                                 vgc += 0x10;
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00.h b/drivers/net/wireless/ralink/rt2x00/rt2x00.h
index 6418620f95ff..f68d492129c6 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00.h
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00.h
@@ -38,6 +38,7 @@
 #include <linux/kfifo.h>
 #include <linux/hrtimer.h>
 #include <linux/average.h>
+#include <linux/usb.h>
 
 #include <net/mac80211.h>
 
@@ -752,8 +753,8 @@ struct rt2x00_dev {
          * IEEE80211 control structure.
          */
         struct ieee80211_hw *hw;
-        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
-        enum ieee80211_band curr_band;
+        struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
+        enum nl80211_band curr_band;
         int curr_freq;
 
         /*
@@ -1002,6 +1003,8 @@ struct rt2x00_dev {
 
         /* Extra TX headroom required for alignment purposes. */
         unsigned int extra_tx_headroom;
+
+        struct usb_anchor *anchor;
 };
 
 struct rt2x00_bar_list_entry {
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00dev.c b/drivers/net/wireless/ralink/rt2x00/rt2x00dev.c
index 5639ed816813..4e0c5653054b 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00dev.c
@@ -911,7 +911,7 @@ static void rt2x00lib_channel(struct ieee80211_channel *entry,
                               const int value)
 {
         /* XXX: this assumption about the band is wrong for 802.11j */
-        entry->band = channel <= 14 ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
+        entry->band = channel <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
         entry->center_freq = ieee80211_channel_to_frequency(channel,
                                                             entry->band);
         entry->hw_value = value;
@@ -975,13 +975,13 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
          * Channels: 2.4 GHz
          */
         if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
-                rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
-                rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
-                rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
-                rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                    &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
-                memcpy(&rt2x00dev->bands[IEEE80211_BAND_2GHZ].ht_cap,
+                rt2x00dev->bands[NL80211_BAND_2GHZ].n_channels = 14;
+                rt2x00dev->bands[NL80211_BAND_2GHZ].n_bitrates = num_rates;
+                rt2x00dev->bands[NL80211_BAND_2GHZ].channels = channels;
+                rt2x00dev->bands[NL80211_BAND_2GHZ].bitrates = rates;
+                hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                    &rt2x00dev->bands[NL80211_BAND_2GHZ];
+                memcpy(&rt2x00dev->bands[NL80211_BAND_2GHZ].ht_cap,
                        &spec->ht, sizeof(spec->ht));
         }
 
@@ -991,15 +991,15 @@ static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
          * Channels: OFDM, UNII, HiperLAN2.
          */
         if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
-                rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
+                rt2x00dev->bands[NL80211_BAND_5GHZ].n_channels =
                     spec->num_channels - 14;
-                rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
+                rt2x00dev->bands[NL80211_BAND_5GHZ].n_bitrates =
                     num_rates - 4;
-                rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
-                rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                    &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
-                memcpy(&rt2x00dev->bands[IEEE80211_BAND_5GHZ].ht_cap,
+                rt2x00dev->bands[NL80211_BAND_5GHZ].channels = &channels[14];
+                rt2x00dev->bands[NL80211_BAND_5GHZ].bitrates = &rates[4];
+                hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                    &rt2x00dev->bands[NL80211_BAND_5GHZ];
+                memcpy(&rt2x00dev->bands[NL80211_BAND_5GHZ].ht_cap,
                        &spec->ht, sizeof(spec->ht));
         }
 
@@ -1016,11 +1016,11 @@ static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
         if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
                 ieee80211_unregister_hw(rt2x00dev->hw);
 
-        if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
-                kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
-                kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
-                rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
-                rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
+        if (likely(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ])) {
+                kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels);
+                kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->bitrates);
+                rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
+                rt2x00dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
         }
 
         kfree(rt2x00dev->spec.channels_info);
@@ -1422,11 +1422,14 @@ void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
         cancel_work_sync(&rt2x00dev->intf_work);
         cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
         cancel_work_sync(&rt2x00dev->sleep_work);
+#ifdef CONFIG_RT2X00_LIB_USB
         if (rt2x00_is_usb(rt2x00dev)) {
+                usb_kill_anchored_urbs(rt2x00dev->anchor);
                 hrtimer_cancel(&rt2x00dev->txstatus_timer);
                 cancel_work_sync(&rt2x00dev->rxdone_work);
                 cancel_work_sync(&rt2x00dev->txdone_work);
         }
+#endif
         if (rt2x00dev->workqueue)
                 destroy_workqueue(rt2x00dev->workqueue);
 
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c b/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c
index 7627af6098eb..7cf26c6124d1 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00usb.c
@@ -171,8 +171,11 @@ static void rt2x00usb_register_read_async_cb(struct urb *urb)
 {
         struct rt2x00_async_read_data *rd = urb->context;
         if (rd->callback(rd->rt2x00dev, urb->status, le32_to_cpu(rd->reg))) {
-                if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
+                usb_anchor_urb(urb, rd->rt2x00dev->anchor);
+                if (usb_submit_urb(urb, GFP_ATOMIC) < 0) {
+                        usb_unanchor_urb(urb);
                         kfree(rd);
+                }
         } else
                 kfree(rd);
 }
@@ -206,8 +209,11 @@ void rt2x00usb_register_read_async(struct rt2x00_dev *rt2x00dev,
         usb_fill_control_urb(urb, usb_dev, usb_rcvctrlpipe(usb_dev, 0),
                              (unsigned char *)(&rd->cr), &rd->reg, sizeof(rd->reg),
                              rt2x00usb_register_read_async_cb, rd);
-        if (usb_submit_urb(urb, GFP_ATOMIC) < 0)
+        usb_anchor_urb(urb, rt2x00dev->anchor);
+        if (usb_submit_urb(urb, GFP_ATOMIC) < 0) {
+                usb_unanchor_urb(urb);
                 kfree(rd);
+        }
         usb_free_urb(urb);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_register_read_async);
@@ -313,8 +319,10 @@ static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void *data)
                           entry->skb->data, length,
                           rt2x00usb_interrupt_txdone, entry);
 
+        usb_anchor_urb(entry_priv->urb, rt2x00dev->anchor);
         status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
         if (status) {
+                usb_unanchor_urb(entry_priv->urb);
                 if (status == -ENODEV)
                         clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
                 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
@@ -402,8 +410,10 @@ static bool rt2x00usb_kick_rx_entry(struct queue_entry *entry, void *data)
                           entry->skb->data, entry->skb->len,
                           rt2x00usb_interrupt_rxdone, entry);
 
+        usb_anchor_urb(entry_priv->urb, rt2x00dev->anchor);
         status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
         if (status) {
+                usb_unanchor_urb(entry_priv->urb);
                 if (status == -ENODEV)
                         clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
                 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
@@ -818,6 +828,13 @@ int rt2x00usb_probe(struct usb_interface *usb_intf,
         if (retval)
                 goto exit_free_reg;
 
+        rt2x00dev->anchor = devm_kmalloc(&usb_dev->dev,
+                                        sizeof(struct usb_anchor),
+                                        GFP_KERNEL);
+        if (!rt2x00dev->anchor)
+                goto exit_free_reg;
+
+        init_usb_anchor(rt2x00dev->anchor);
         return 0;
 
 exit_free_reg:
diff --git a/drivers/net/wireless/ralink/rt2x00/rt61pci.c b/drivers/net/wireless/ralink/rt2x00/rt61pci.c
index 24a3436ef952..03013eb2f642 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt61pci.c
@@ -252,9 +252,9 @@ static void rt61pci_brightness_set(struct led_classdev *led_cdev,
             container_of(led_cdev, struct rt2x00_led, led_dev);
         unsigned int enabled = brightness != LED_OFF;
         unsigned int a_mode =
-            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
+            (enabled && led->rt2x00dev->curr_band == NL80211_BAND_5GHZ);
         unsigned int bg_mode =
-            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_2GHZ);
+            (enabled && led->rt2x00dev->curr_band == NL80211_BAND_2GHZ);
 
         if (led->type == LED_TYPE_RADIO) {
                 rt2x00_set_field16(&led->rt2x00dev->led_mcu_reg,
@@ -643,12 +643,12 @@ static void rt61pci_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END,
-                                  (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ));
+                                  (rt2x00dev->curr_band != NL80211_BAND_5GHZ));
                 break;
         case ANTENNA_A:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
+                if (rt2x00dev->curr_band == NL80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
@@ -657,7 +657,7 @@ static void rt61pci_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         default:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
+                if (rt2x00dev->curr_band == NL80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
@@ -808,7 +808,7 @@ static void rt61pci_config_ant(struct rt2x00_dev *rt2x00dev,
         BUG_ON(ant->rx == ANTENNA_SW_DIVERSITY ||
                ant->tx == ANTENNA_SW_DIVERSITY);
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
                 lna = rt2x00_has_cap_external_lna_a(rt2x00dev);
         } else {
@@ -822,9 +822,9 @@ static void rt61pci_config_ant(struct rt2x00_dev *rt2x00dev,
         rt2x00mmio_register_read(rt2x00dev, PHY_CSR0, &reg);
 
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_BG,
-                           rt2x00dev->curr_band == IEEE80211_BAND_2GHZ);
+                           rt2x00dev->curr_band == NL80211_BAND_2GHZ);
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_A,
-                           rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
+                           rt2x00dev->curr_band == NL80211_BAND_5GHZ);
 
         rt2x00mmio_register_write(rt2x00dev, PHY_CSR0, reg);
 
@@ -846,7 +846,7 @@ static void rt61pci_config_lna_gain(struct rt2x00_dev *rt2x00dev,
         u16 eeprom;
         short lna_gain = 0;
 
-        if (libconf->conf->chandef.chan->band == IEEE80211_BAND_2GHZ) {
+        if (libconf->conf->chandef.chan->band == NL80211_BAND_2GHZ) {
                 if (rt2x00_has_cap_external_lna_bg(rt2x00dev))
                         lna_gain += 14;
 
@@ -1048,7 +1048,7 @@ static void rt61pci_link_tuner(struct rt2x00_dev *rt2x00dev,
         /*
          * Determine r17 bounds.
          */
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
                 if (rt2x00_has_cap_external_lna_a(rt2x00dev)) {
@@ -2077,7 +2077,7 @@ static int rt61pci_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
                 return 0;
         }
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 if (lna == 3 || lna == 2)
                         offset += 10;
         }
diff --git a/drivers/net/wireless/ralink/rt2x00/rt73usb.c b/drivers/net/wireless/ralink/rt2x00/rt73usb.c
index 7bbc86931168..c1397a6d3cee 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt73usb.c
@@ -197,9 +197,9 @@ static void rt73usb_brightness_set(struct led_classdev *led_cdev,
            container_of(led_cdev, struct rt2x00_led, led_dev);
         unsigned int enabled = brightness != LED_OFF;
         unsigned int a_mode =
-            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_5GHZ);
+            (enabled && led->rt2x00dev->curr_band == NL80211_BAND_5GHZ);
         unsigned int bg_mode =
-            (enabled && led->rt2x00dev->curr_band == IEEE80211_BAND_2GHZ);
+            (enabled && led->rt2x00dev->curr_band == NL80211_BAND_2GHZ);
 
         if (led->type == LED_TYPE_RADIO) {
                 rt2x00_set_field16(&led->rt2x00dev->led_mcu_reg,
@@ -593,13 +593,13 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         case ANTENNA_HW_DIVERSITY:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 2);
                 temp = !rt2x00_has_cap_frame_type(rt2x00dev) &&
-                       (rt2x00dev->curr_band != IEEE80211_BAND_5GHZ);
+                       (rt2x00dev->curr_band != NL80211_BAND_5GHZ);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, temp);
                 break;
         case ANTENNA_A:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
+                if (rt2x00dev->curr_band == NL80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
@@ -608,7 +608,7 @@ static void rt73usb_config_antenna_5x(struct rt2x00_dev *rt2x00dev,
         default:
                 rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA_CONTROL, 1);
                 rt2x00_set_field8(&r4, BBP_R4_RX_FRAME_END, 0);
-                if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ)
+                if (rt2x00dev->curr_band == NL80211_BAND_5GHZ)
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 3);
                 else
                         rt2x00_set_field8(&r77, BBP_R77_RX_ANTENNA, 0);
@@ -704,7 +704,7 @@ static void rt73usb_config_ant(struct rt2x00_dev *rt2x00dev,
         BUG_ON(ant->rx == ANTENNA_SW_DIVERSITY ||
                ant->tx == ANTENNA_SW_DIVERSITY);
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 sel = antenna_sel_a;
                 lna = rt2x00_has_cap_external_lna_a(rt2x00dev);
         } else {
@@ -718,9 +718,9 @@ static void rt73usb_config_ant(struct rt2x00_dev *rt2x00dev,
         rt2x00usb_register_read(rt2x00dev, PHY_CSR0, &reg);
 
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_BG,
-                           (rt2x00dev->curr_band == IEEE80211_BAND_2GHZ));
+                           (rt2x00dev->curr_band == NL80211_BAND_2GHZ));
         rt2x00_set_field32(&reg, PHY_CSR0_PA_PE_A,
-                           (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ));
+                           (rt2x00dev->curr_band == NL80211_BAND_5GHZ));
 
         rt2x00usb_register_write(rt2x00dev, PHY_CSR0, reg);
 
@@ -736,7 +736,7 @@ static void rt73usb_config_lna_gain(struct rt2x00_dev *rt2x00dev,
         u16 eeprom;
         short lna_gain = 0;
 
-        if (libconf->conf->chandef.chan->band == IEEE80211_BAND_2GHZ) {
+        if (libconf->conf->chandef.chan->band == NL80211_BAND_2GHZ) {
                 if (rt2x00_has_cap_external_lna_bg(rt2x00dev))
                         lna_gain += 14;
 
@@ -923,7 +923,7 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev,
         /*
          * Determine r17 bounds.
          */
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 low_bound = 0x28;
                 up_bound = 0x48;
 
@@ -1657,7 +1657,7 @@ static int rt73usb_agc_to_rssi(struct rt2x00_dev *rt2x00dev, int rxd_w1)
                 return 0;
         }
 
-        if (rt2x00dev->curr_band == IEEE80211_BAND_5GHZ) {
+        if (rt2x00dev->curr_band == NL80211_BAND_5GHZ) {
                 if (rt2x00_has_cap_external_lna_a(rt2x00dev)) {
                         if (lna == 3 || lna == 2)
                                 offset += 10;
diff --git a/drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c b/drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c
index a43a16fde59d..ba242d0160ec 100644
--- a/drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c
+++ b/drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c
@@ -526,7 +526,7 @@ static void rtl8180_tx(struct ieee80211_hw *dev,
                  * ieee80211_generic_frame_duration
                  */
                 duration = ieee80211_generic_frame_duration(dev, priv->vif,
-                                        IEEE80211_BAND_2GHZ, skb->len,
+                                        NL80211_BAND_2GHZ, skb->len,
                                         ieee80211_get_tx_rate(dev, info));
 
                 frame_duration =  priv->ack_time + le16_to_cpu(duration);
@@ -1529,7 +1529,7 @@ static void rtl8180_bss_info_changed(struct ieee80211_hw *dev,
                 priv->ack_time =
                         le16_to_cpu(ieee80211_generic_frame_duration(dev,
                                         priv->vif,
-                                        IEEE80211_BAND_2GHZ, 10,
+                                        NL80211_BAND_2GHZ, 10,
                                         &priv->rates[0])) - 10;
 
                 rtl8180_conf_erp(dev, info);
@@ -1736,7 +1736,7 @@ static int rtl8180_probe(struct pci_dev *pdev,
         if (err) {
                 printk(KERN_ERR "%s (rtl8180): Cannot obtain PCI resources\n",
                        pci_name(pdev));
-                return err;
+                goto err_disable_dev;
         }
 
         io_addr = pci_resource_start(pdev, 0);
@@ -1795,12 +1795,12 @@ static int rtl8180_probe(struct pci_dev *pdev,
         memcpy(priv->channels, rtl818x_channels, sizeof(rtl818x_channels));
         memcpy(priv->rates, rtl818x_rates, sizeof(rtl818x_rates));
 
-        priv->band.band = IEEE80211_BAND_2GHZ;
+        priv->band.band = NL80211_BAND_2GHZ;
         priv->band.channels = priv->channels;
         priv->band.n_channels = ARRAY_SIZE(rtl818x_channels);
         priv->band.bitrates = priv->rates;
         priv->band.n_bitrates = 4;
-        dev->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        dev->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
 
         ieee80211_hw_set(dev, HOST_BROADCAST_PS_BUFFERING);
         ieee80211_hw_set(dev, RX_INCLUDES_FCS);
@@ -1938,6 +1938,8 @@ static int rtl8180_probe(struct pci_dev *pdev,
 
  err_free_reg:
         pci_release_regions(pdev);
+
+ err_disable_dev:
         pci_disable_device(pdev);
         return err;
 }
diff --git a/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c b/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c
index b7f72f9c7988..231f84db9ab0 100644
--- a/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c
+++ b/drivers/net/wireless/realtek/rtl818x/rtl8187/dev.c
@@ -1470,12 +1470,12 @@ static int rtl8187_probe(struct usb_interface *intf,
         memcpy(priv->rates, rtl818x_rates, sizeof(rtl818x_rates));
         priv->map = (struct rtl818x_csr *)0xFF00;
 
-        priv->band.band = IEEE80211_BAND_2GHZ;
+        priv->band.band = NL80211_BAND_2GHZ;
         priv->band.channels = priv->channels;
         priv->band.n_channels = ARRAY_SIZE(rtl818x_channels);
         priv->band.bitrates = priv->rates;
         priv->band.n_bitrates = ARRAY_SIZE(rtl818x_rates);
-        dev->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        dev->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
 
 
         ieee80211_hw_set(dev, RX_INCLUDES_FCS);
diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.c b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.c
index abdff458b80f..db8433a9efe2 100644
--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.c
+++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.c
@@ -91,33 +91,33 @@ static struct ieee80211_rate rtl8xxxu_rates[] = {
 };
 
 static struct ieee80211_channel rtl8xxxu_channels_2g[] = {
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2412,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2412,
           .hw_value = 1, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2417,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2417,
           .hw_value = 2, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2422,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2422,
           .hw_value = 3, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2427,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2427,
           .hw_value = 4, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2432,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2432,
           .hw_value = 5, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2437,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2437,
           .hw_value = 6, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2442,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2442,
           .hw_value = 7, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2447,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2447,
           .hw_value = 8, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2452,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2452,
           .hw_value = 9, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2457,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2457,
           .hw_value = 10, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2462,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2462,
           .hw_value = 11, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2467,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2467,
           .hw_value = 12, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2472,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2472,
           .hw_value = 13, .max_power = 30 },
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2484,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2484,
           .hw_value = 14, .max_power = 30 }
 };
 
@@ -1574,7 +1574,7 @@ static void rtl8723a_enable_rf(struct rtl8xxxu_priv *priv)
         val32 &= ~OFDM_RF_PATH_TX_MASK;
         if (priv->tx_paths == 2)
                 val32 |= OFDM_RF_PATH_TX_A | OFDM_RF_PATH_TX_B;
-        else if (priv->rtlchip == 0x8192c || priv->rtlchip == 0x8191c)
+        else if (priv->rtl_chip == RTL8192C || priv->rtl_chip == RTL8191C)
                 val32 |= OFDM_RF_PATH_TX_B;
         else
                 val32 |= OFDM_RF_PATH_TX_A;
@@ -2199,11 +2199,11 @@ static int rtl8xxxu_identify_chip(struct rtl8xxxu_priv *priv)
         if (val32 & SYS_CFG_BT_FUNC) {
                 if (priv->chip_cut >= 3) {
                         sprintf(priv->chip_name, "8723BU");
-                        priv->rtlchip = 0x8723b;
+                        priv->rtl_chip = RTL8723B;
                 } else {
                         sprintf(priv->chip_name, "8723AU");
                         priv->usb_interrupts = 1;
-                        priv->rtlchip = 0x8723a;
+                        priv->rtl_chip = RTL8723A;
                 }
 
                 priv->rf_paths = 1;
@@ -2221,19 +2221,19 @@ static int rtl8xxxu_identify_chip(struct rtl8xxxu_priv *priv)
         } else if (val32 & SYS_CFG_TYPE_ID) {
                 bonding = rtl8xxxu_read32(priv, REG_HPON_FSM);
                 bonding &= HPON_FSM_BONDING_MASK;
-                if (priv->chip_cut >= 3) {
+                if (priv->fops->has_s0s1) {
                         if (bonding == HPON_FSM_BONDING_1T2R) {
                                 sprintf(priv->chip_name, "8191EU");
                                 priv->rf_paths = 2;
                                 priv->rx_paths = 2;
                                 priv->tx_paths = 1;
-                                priv->rtlchip = 0x8191e;
+                                priv->rtl_chip = RTL8191E;
                         } else {
                                 sprintf(priv->chip_name, "8192EU");
                                 priv->rf_paths = 2;
                                 priv->rx_paths = 2;
                                 priv->tx_paths = 2;
-                                priv->rtlchip = 0x8192e;
+                                priv->rtl_chip = RTL8192E;
                         }
                 } else if (bonding == HPON_FSM_BONDING_1T2R) {
                         sprintf(priv->chip_name, "8191CU");
@@ -2241,14 +2241,14 @@ static int rtl8xxxu_identify_chip(struct rtl8xxxu_priv *priv)
                         priv->rx_paths = 2;
                         priv->tx_paths = 1;
                         priv->usb_interrupts = 1;
-                        priv->rtlchip = 0x8191c;
+                        priv->rtl_chip = RTL8191C;
                 } else {
                         sprintf(priv->chip_name, "8192CU");
                         priv->rf_paths = 2;
                         priv->rx_paths = 2;
                         priv->tx_paths = 2;
                         priv->usb_interrupts = 1;
-                        priv->rtlchip = 0x8192c;
+                        priv->rtl_chip = RTL8192C;
                 }
                 priv->has_wifi = 1;
         } else {
@@ -2256,15 +2256,15 @@ static int rtl8xxxu_identify_chip(struct rtl8xxxu_priv *priv)
                 priv->rf_paths = 1;
                 priv->rx_paths = 1;
                 priv->tx_paths = 1;
-                priv->rtlchip = 0x8188c;
+                priv->rtl_chip = RTL8188C;
                 priv->usb_interrupts = 1;
                 priv->has_wifi = 1;
         }
 
-        switch (priv->rtlchip) {
-        case 0x8188e:
-        case 0x8192e:
-        case 0x8723b:
+        switch (priv->rtl_chip) {
+        case RTL8188E:
+        case RTL8192E:
+        case RTL8723B:
                 switch (val32 & SYS_CFG_VENDOR_EXT_MASK) {
                 case SYS_CFG_VENDOR_ID_TSMC:
                         sprintf(priv->chip_vendor, "TSMC");
@@ -2814,7 +2814,7 @@ static int rtl8xxxu_start_firmware(struct rtl8xxxu_priv *priv)
         /*
          * Init H2C command
          */
-        if (priv->rtlchip == 0x8723b)
+        if (priv->rtl_chip == RTL8723B)
                 rtl8xxxu_write8(priv, REG_HMTFR, 0x0f);
 exit:
         return ret;
@@ -2997,7 +2997,7 @@ static int rtl8192cu_load_firmware(struct rtl8xxxu_priv *priv)
 
         if (!priv->vendor_umc)
                 fw_name = "rtlwifi/rtl8192cufw_TMSC.bin";
-        else if (priv->chip_cut || priv->rtlchip == 0x8192c)
+        else if (priv->chip_cut || priv->rtl_chip == RTL8192C)
                 fw_name = "rtlwifi/rtl8192cufw_B.bin";
         else
                 fw_name = "rtlwifi/rtl8192cufw_A.bin";
@@ -3108,7 +3108,7 @@ rtl8xxxu_init_mac(struct rtl8xxxu_priv *priv, struct rtl8xxxu_reg8val *array)
                 }
         }
 
-        if (priv->rtlchip != 0x8723b)
+        if (priv->rtl_chip != RTL8723B)
                 rtl8xxxu_write8(priv, REG_MAX_AGGR_NUM, 0x0a);
 
         return 0;
@@ -3154,7 +3154,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
          *       addresses, which is initialized here. Do we need this?
          */
 
-        if (priv->rtlchip == 0x8723b) {
+        if (priv->rtl_chip == RTL8723B) {
                 val16 = rtl8xxxu_read16(priv, REG_SYS_FUNC);
                 val16 |= SYS_FUNC_BB_GLB_RSTN | SYS_FUNC_BBRSTB |
                         SYS_FUNC_DIO_RF;
@@ -3176,7 +3176,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
                 rtl8xxxu_write16(priv, REG_SYS_FUNC, val16);
         }
 
-        if (priv->rtlchip != 0x8723b) {
+        if (priv->rtl_chip != RTL8723B) {
                 /* AFE_XTAL_RF_GATE (bit 14) if addressing as 32 bit register */
                 val32 = rtl8xxxu_read32(priv, REG_AFE_XTAL_CTRL);
                 val32 &= ~AFE_XTAL_RF_GATE;
@@ -3193,7 +3193,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
                 rtl8xxxu_init_phy_regs(priv, rtl8188ru_phy_1t_highpa_table);
         else if (priv->tx_paths == 2)
                 rtl8xxxu_init_phy_regs(priv, rtl8192cu_phy_2t_init_table);
-        else if (priv->rtlchip == 0x8723b) {
+        else if (priv->rtl_chip == RTL8723B) {
                 /*
                  * Why?
                  */
@@ -3204,7 +3204,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
                 rtl8xxxu_init_phy_regs(priv, rtl8723a_phy_1t_init_table);
 
 
-        if (priv->rtlchip == 0x8188c && priv->hi_pa &&
+        if (priv->rtl_chip == RTL8188C && priv->hi_pa &&
             priv->vendor_umc && priv->chip_cut == 1)
                 rtl8xxxu_write8(priv, REG_OFDM0_AGC_PARM1 + 2, 0x50);
 
@@ -3266,7 +3266,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
                 rtl8xxxu_write32(priv, REG_TX_TO_TX, val32);
         }
 
-        if (priv->rtlchip == 0x8723b)
+        if (priv->rtl_chip == RTL8723B)
                 rtl8xxxu_init_phy_regs(priv, rtl8xxx_agc_8723bu_table);
         else if (priv->hi_pa)
                 rtl8xxxu_init_phy_regs(priv, rtl8xxx_agc_highpa_table);
@@ -3283,7 +3283,7 @@ static int rtl8xxxu_init_phy_bb(struct rtl8xxxu_priv *priv)
                 rtl8xxxu_write32(priv, REG_MAC_PHY_CTRL, val32);
         }
 
-        if (priv->rtlchip != 0x8723bu) {
+        if (priv->rtl_chip != RTL8723B && priv->rtl_chip != RTL8192E) {
                 ldoa15 = LDOA15_ENABLE | LDOA15_OBUF;
                 ldov12d = LDOV12D_ENABLE | BIT(2) | (2 << LDOV12D_VADJ_SHIFT);
                 ldohci12 = 0x57;
@@ -5955,7 +5955,7 @@ static int rtl8192cu_power_on(struct rtl8xxxu_priv *priv)
         /*
          * Workaround for 8188RU LNA power leakage problem.
          */
-        if (priv->rtlchip == 0x8188c && priv->hi_pa) {
+        if (priv->rtl_chip == RTL8188C && priv->hi_pa) {
                 val32 = rtl8xxxu_read32(priv, REG_FPGA0_XCD_RF_PARM);
                 val32 &= ~BIT(1);
                 rtl8xxxu_write32(priv, REG_FPGA0_XCD_RF_PARM, val32);
@@ -6020,7 +6020,7 @@ static void rtl8xxxu_power_off(struct rtl8xxxu_priv *priv)
         /*
          * Workaround for 8188RU LNA power leakage problem.
          */
-        if (priv->rtlchip == 0x8188c && priv->hi_pa) {
+        if (priv->rtl_chip == RTL8188C && priv->hi_pa) {
                 val32 = rtl8xxxu_read32(priv, REG_FPGA0_XCD_RF_PARM);
                 val32 |= BIT(1);
                 rtl8xxxu_write32(priv, REG_FPGA0_XCD_RF_PARM, val32);
@@ -6313,7 +6313,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
                  * Presumably this is for 8188EU as well
                  * Enable TX report and TX report timer
                  */
-                if (priv->rtlchip == 0x8723bu) {
+                if (priv->rtl_chip == RTL8723B) {
                         val8 = rtl8xxxu_read8(priv, REG_TX_REPORT_CTRL);
                         val8 |= TX_REPORT_CTRL_TIMER_ENABLE;
                         rtl8xxxu_write8(priv, REG_TX_REPORT_CTRL, val8);
@@ -6340,9 +6340,9 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
 
         /* Solve too many protocol error on USB bus */
         /* Can't do this for 8188/8192 UMC A cut parts */
-        if (priv->rtlchip == 0x8723a ||
-            ((priv->rtlchip == 0x8192c || priv->rtlchip == 0x8191c ||
-              priv->rtlchip == 0x8188c) &&
+        if (priv->rtl_chip == RTL8723A ||
+            ((priv->rtl_chip == RTL8192C || priv->rtl_chip == RTL8191C ||
+              priv->rtl_chip == RTL8188C) &&
              (priv->chip_cut || !priv->vendor_umc))) {
                 rtl8xxxu_write8(priv, 0xfe40, 0xe6);
                 rtl8xxxu_write8(priv, 0xfe41, 0x94);
@@ -6361,7 +6361,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
                 rtl8xxxu_write8(priv, 0xfe42, 0x80);
         }
 
-        if (priv->rtlchip == 0x8192e) {
+        if (priv->rtl_chip == RTL8192E) {
                 rtl8xxxu_write32(priv, REG_HIMR0, 0x00);
                 rtl8xxxu_write32(priv, REG_HIMR1, 0x00);
         }
@@ -6369,7 +6369,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         if (priv->fops->phy_init_antenna_selection)
                 priv->fops->phy_init_antenna_selection(priv);
 
-        if (priv->rtlchip == 0x8723b)
+        if (priv->rtl_chip == RTL8723B)
                 ret = rtl8xxxu_init_mac(priv, rtl8723b_mac_init_table);
         else
                 ret = rtl8xxxu_init_mac(priv, rtl8723a_mac_init_table);
@@ -6383,12 +6383,12 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         if (ret)
                 goto exit;
 
-        switch(priv->rtlchip) {
-        case 0x8723a:
+        switch(priv->rtl_chip) {
+        case RTL8723A:
                 rftable = rtl8723au_radioa_1t_init_table;
                 ret = rtl8xxxu_init_phy_rf(priv, rftable, RF_A);
                 break;
-        case 0x8723b:
+        case RTL8723B:
                 rftable = rtl8723bu_radioa_1t_init_table;
                 ret = rtl8xxxu_init_phy_rf(priv, rftable, RF_A);
                 /*
@@ -6399,18 +6399,18 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
                 msleep(200);
                 rtl8xxxu_write_rfreg(priv, RF_A, 0xb0, 0xdffe0);
                 break;
-        case 0x8188c:
+        case RTL8188C:
                 if (priv->hi_pa)
                         rftable = rtl8188ru_radioa_1t_highpa_table;
                 else
                         rftable = rtl8192cu_radioa_1t_init_table;
                 ret = rtl8xxxu_init_phy_rf(priv, rftable, RF_A);
                 break;
-        case 0x8191c:
+        case RTL8191C:
                 rftable = rtl8192cu_radioa_1t_init_table;
                 ret = rtl8xxxu_init_phy_rf(priv, rftable, RF_A);
                 break;
-        case 0x8192c:
+        case RTL8192C:
                 rftable = rtl8192cu_radioa_2t_init_table;
                 ret = rtl8xxxu_init_phy_rf(priv, rftable, RF_A);
                 if (ret)
@@ -6428,7 +6428,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         /*
          * Chip specific quirks
          */
-        if (priv->rtlchip == 0x8723a) {
+        if (priv->rtl_chip == RTL8723A) {
                 /* Fix USB interface interference issue */
                 rtl8xxxu_write8(priv, 0xfe40, 0xe0);
                 rtl8xxxu_write8(priv, 0xfe41, 0x8d);
@@ -6468,7 +6468,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
                  */
                 val8 = TX_TOTAL_PAGE_NUM + 1;
 
-                if (priv->rtlchip == 0x8723b)
+                if (priv->rtl_chip == RTL8723B)
                         val8 -= 1;
 
                 rtl8xxxu_write8(priv, REG_TXPKTBUF_BCNQ_BDNY, val8);
@@ -6484,7 +6484,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
                 goto exit;
 
         /* RFSW Control - clear bit 14 ?? */
-        if (priv->rtlchip != 0x8723b)
+        if (priv->rtl_chip != RTL8723B)
                 rtl8xxxu_write32(priv, REG_FPGA0_TX_INFO, 0x00000003);
         /* 0x07000760 */
         val32 = FPGA0_RF_TRSW | FPGA0_RF_TRSWB | FPGA0_RF_ANTSW |
@@ -6501,14 +6501,14 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         /*
          * Set RX page boundary
          */
-        if (priv->rtlchip == 0x8723b)
+        if (priv->rtl_chip == RTL8723B)
                 rtl8xxxu_write16(priv, REG_TRXFF_BNDY + 2, 0x3f7f);
         else
                 rtl8xxxu_write16(priv, REG_TRXFF_BNDY + 2, 0x27ff);
         /*
          * Transfer page size is always 128
          */
-        if (priv->rtlchip == 0x8723b)
+        if (priv->rtl_chip == RTL8723B)
                 val8 = (PBP_PAGE_SIZE_256 << PBP_PAGE_SIZE_RX_SHIFT) |
                         (PBP_PAGE_SIZE_256 << PBP_PAGE_SIZE_TX_SHIFT);
         else
@@ -6600,7 +6600,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         /*
          * Initialize burst parameters
          */
-        if (priv->rtlchip == 0x8723b) {
+        if (priv->rtl_chip == RTL8723B) {
                 /*
                  * For USB high speed set 512B packets
                  */
@@ -6682,7 +6682,7 @@ static int rtl8xxxu_init_device(struct ieee80211_hw *hw)
         val8 = ((30000 + NAV_UPPER_UNIT - 1) / NAV_UPPER_UNIT);
         rtl8xxxu_write8(priv, REG_NAV_UPPER, val8);
 
-        if (priv->rtlchip == 0x8723a) {
+        if (priv->rtl_chip == RTL8723A) {
                 /*
                  * 2011/03/09 MH debug only, UMC-B cut pass 2500 S5 test,
                  * but we need to find root cause.
@@ -7014,7 +7014,7 @@ static u32 rtl8xxxu_queue_select(struct ieee80211_hw *hw, struct sk_buff *skb)
  * format. The descriptor checksum is still only calculated over the
  * initial 32 bytes of the descriptor!
  */
-static void rtl8xxxu_calc_tx_desc_csum(struct rtl8723au_tx_desc *tx_desc)
+static void rtl8xxxu_calc_tx_desc_csum(struct rtl8xxxu_txdesc32 *tx_desc)
 {
         __le16 *ptr = (__le16 *)tx_desc;
         u16 csum = 0;
@@ -7026,7 +7026,7 @@ static void rtl8xxxu_calc_tx_desc_csum(struct rtl8723au_tx_desc *tx_desc)
          */
         tx_desc->csum = cpu_to_le16(0);
 
-        for (i = 0; i < (sizeof(struct rtl8723au_tx_desc) / sizeof(u16)); i++)
+        for (i = 0; i < (sizeof(struct rtl8xxxu_txdesc32) / sizeof(u16)); i++)
                 csum = csum ^ le16_to_cpu(ptr[i]);
 
         tx_desc->csum |= cpu_to_le16(csum);
@@ -7164,8 +7164,8 @@ static void rtl8xxxu_tx(struct ieee80211_hw *hw,
         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
         struct ieee80211_rate *tx_rate = ieee80211_get_tx_rate(hw, tx_info);
         struct rtl8xxxu_priv *priv = hw->priv;
-        struct rtl8723au_tx_desc *tx_desc;
-        struct rtl8723bu_tx_desc *tx_desc40;
+        struct rtl8xxxu_txdesc32 *tx_desc;
+        struct rtl8xxxu_txdesc40 *tx_desc40;
         struct rtl8xxxu_tx_urb *tx_urb;
         struct ieee80211_sta *sta = NULL;
         struct ieee80211_vif *vif = tx_info->control.vif;
@@ -7210,7 +7210,7 @@ static void rtl8xxxu_tx(struct ieee80211_hw *hw,
         if (control && control->sta)
                 sta = control->sta;
 
-        tx_desc = (struct rtl8723au_tx_desc *)skb_push(skb, tx_desc_size);
+        tx_desc = (struct rtl8xxxu_txdesc32 *)skb_push(skb, tx_desc_size);
 
         memset(tx_desc, 0, tx_desc_size);
         tx_desc->pkt_size = cpu_to_le16(pktlen);
@@ -7267,37 +7267,35 @@ static void rtl8xxxu_tx(struct ieee80211_hw *hw,
                         tx_desc->txdw5 |= cpu_to_le32(0x0001ff00);
 
                 tx_desc->txdw3 =
-                        cpu_to_le32((u32)seq_number << TXDESC_SEQ_SHIFT_8723A);
+                        cpu_to_le32((u32)seq_number << TXDESC32_SEQ_SHIFT);
 
                 if (ampdu_enable)
-                        tx_desc->txdw1 |= cpu_to_le32(TXDESC_AGG_ENABLE_8723A);
+                        tx_desc->txdw1 |= cpu_to_le32(TXDESC32_AGG_ENABLE);
                 else
-                        tx_desc->txdw1 |= cpu_to_le32(TXDESC_AGG_BREAK_8723A);
+                        tx_desc->txdw1 |= cpu_to_le32(TXDESC32_AGG_BREAK);
 
                 if (ieee80211_is_mgmt(hdr->frame_control)) {
                         tx_desc->txdw5 = cpu_to_le32(tx_rate->hw_value);
                         tx_desc->txdw4 |=
-                                cpu_to_le32(TXDESC_USE_DRIVER_RATE_8723A);
+                                cpu_to_le32(TXDESC32_USE_DRIVER_RATE);
                         tx_desc->txdw5 |=
-                                cpu_to_le32(6 <<
-                                            TXDESC_RETRY_LIMIT_SHIFT_8723A);
+                                cpu_to_le32(6 << TXDESC32_RETRY_LIMIT_SHIFT);
                         tx_desc->txdw5 |=
-                                cpu_to_le32(TXDESC_RETRY_LIMIT_ENABLE_8723A);
+                                cpu_to_le32(TXDESC32_RETRY_LIMIT_ENABLE);
                 }
 
                 if (ieee80211_is_data_qos(hdr->frame_control))
-                        tx_desc->txdw4 |= cpu_to_le32(TXDESC_QOS_8723A);
+                        tx_desc->txdw4 |= cpu_to_le32(TXDESC32_QOS);
 
                 if (rate_flag & IEEE80211_TX_RC_USE_SHORT_PREAMBLE ||
                     (sta && vif && vif->bss_conf.use_short_preamble))
-                        tx_desc->txdw4 |=
-                                cpu_to_le32(TXDESC_SHORT_PREAMBLE_8723A);
+                        tx_desc->txdw4 |= cpu_to_le32(TXDESC32_SHORT_PREAMBLE);
 
                 if (rate_flag & IEEE80211_TX_RC_SHORT_GI ||
                     (ieee80211_is_data_qos(hdr->frame_control) &&
                      sta && sta->ht_cap.cap &
                      (IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_SGI_20))) {
-                        tx_desc->txdw5 |= cpu_to_le32(TXDESC_SHORT_GI);
+                        tx_desc->txdw5 |= cpu_to_le32(TXDESC32_SHORT_GI);
                 }
 
                 if (rate_flag & IEEE80211_TX_RC_USE_RTS_CTS) {
@@ -7307,46 +7305,43 @@ static void rtl8xxxu_tx(struct ieee80211_hw *hw,
                          */
                         tx_desc->txdw4 |=
                                 cpu_to_le32(DESC_RATE_24M <<
-                                            TXDESC_RTS_RATE_SHIFT_8723A);
+                                            TXDESC32_RTS_RATE_SHIFT);
                         tx_desc->txdw4 |=
-                                cpu_to_le32(TXDESC_RTS_CTS_ENABLE_8723A);
-                        tx_desc->txdw4 |=
-                                cpu_to_le32(TXDESC_HW_RTS_ENABLE_8723A);
+                                cpu_to_le32(TXDESC32_RTS_CTS_ENABLE);
+                        tx_desc->txdw4 |= cpu_to_le32(TXDESC32_HW_RTS_ENABLE);
                 }
         } else {
-                tx_desc40 = (struct rtl8723bu_tx_desc *)tx_desc;
+                tx_desc40 = (struct rtl8xxxu_txdesc40 *)tx_desc;
 
                 tx_desc40->txdw4 = cpu_to_le32(rate);
                 if (ieee80211_is_data(hdr->frame_control)) {
                         tx_desc->txdw4 |=
                                 cpu_to_le32(0x1f <<
-                                            TXDESC_DATA_RATE_FB_SHIFT_8723B);
+                                            TXDESC40_DATA_RATE_FB_SHIFT);
                 }
 
                 tx_desc40->txdw9 =
-                        cpu_to_le32((u32)seq_number << TXDESC_SEQ_SHIFT_8723B);
+                        cpu_to_le32((u32)seq_number << TXDESC40_SEQ_SHIFT);
 
                 if (ampdu_enable)
-                        tx_desc40->txdw2 |=
-                                cpu_to_le32(TXDESC_AGG_ENABLE_8723B);
+                        tx_desc40->txdw2 |= cpu_to_le32(TXDESC40_AGG_ENABLE);
                 else
-                        tx_desc40->txdw2 |= cpu_to_le32(TXDESC_AGG_BREAK_8723B);
+                        tx_desc40->txdw2 |= cpu_to_le32(TXDESC40_AGG_BREAK);
 
                 if (ieee80211_is_mgmt(hdr->frame_control)) {
                         tx_desc40->txdw4 = cpu_to_le32(tx_rate->hw_value);
                         tx_desc40->txdw3 |=
-                                cpu_to_le32(TXDESC_USE_DRIVER_RATE_8723B);
+                                cpu_to_le32(TXDESC40_USE_DRIVER_RATE);
                         tx_desc40->txdw4 |=
-                                cpu_to_le32(6 <<
-                                            TXDESC_RETRY_LIMIT_SHIFT_8723B);
+                                cpu_to_le32(6 << TXDESC40_RETRY_LIMIT_SHIFT);
                         tx_desc40->txdw4 |=
-                                cpu_to_le32(TXDESC_RETRY_LIMIT_ENABLE_8723B);
+                                cpu_to_le32(TXDESC40_RETRY_LIMIT_ENABLE);
                 }
 
                 if (rate_flag & IEEE80211_TX_RC_USE_SHORT_PREAMBLE ||
                     (sta && vif && vif->bss_conf.use_short_preamble))
                         tx_desc40->txdw5 |=
-                                cpu_to_le32(TXDESC_SHORT_PREAMBLE_8723B);
+                                cpu_to_le32(TXDESC40_SHORT_PREAMBLE);
 
                 if (rate_flag & IEEE80211_TX_RC_USE_RTS_CTS) {
                         /*
@@ -7355,11 +7350,9 @@ static void rtl8xxxu_tx(struct ieee80211_hw *hw,
                          */
                         tx_desc->txdw4 |=
                                 cpu_to_le32(DESC_RATE_24M <<
-                                            TXDESC_RTS_RATE_SHIFT_8723B);
-                        tx_desc->txdw3 |=
-                                cpu_to_le32(TXDESC_RTS_CTS_ENABLE_8723B);
-                        tx_desc->txdw3 |=
-                                cpu_to_le32(TXDESC_HW_RTS_ENABLE_8723B);
+                                            TXDESC40_RTS_RATE_SHIFT);
+                        tx_desc->txdw3 |= cpu_to_le32(TXDESC40_RTS_CTS_ENABLE);
+                        tx_desc->txdw3 |= cpu_to_le32(TXDESC40_HW_RTS_ENABLE);
                 }
         }
 
@@ -8385,7 +8378,7 @@ static int rtl8xxxu_probe(struct usb_interface *interface,
                 dev_info(&udev->dev, "Enabling HT_20_40 on the 2.4GHz band\n");
                 sband->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
         }
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = sband;
 
         hw->wiphy->rts_threshold = 2347;
 
@@ -8454,7 +8447,7 @@ static struct rtl8xxxu_fileops rtl8723au_fops = {
         .writeN_block_size = 1024,
         .mbox_ext_reg = REG_HMBOX_EXT_0,
         .mbox_ext_width = 2,
-        .tx_desc_size = sizeof(struct rtl8723au_tx_desc),
+        .tx_desc_size = sizeof(struct rtl8xxxu_txdesc32),
         .adda_1t_init = 0x0b1b25a0,
         .adda_1t_path_on = 0x0bdb25a0,
         .adda_2t_path_on_a = 0x04db25a4,
@@ -8482,7 +8475,7 @@ static struct rtl8xxxu_fileops rtl8723bu_fops = {
         .writeN_block_size = 1024,
         .mbox_ext_reg = REG_HMBOX_EXT0_8723B,
         .mbox_ext_width = 4,
-        .tx_desc_size = sizeof(struct rtl8723bu_tx_desc),
+        .tx_desc_size = sizeof(struct rtl8xxxu_txdesc40),
         .has_s0s1 = 1,
         .adda_1t_init = 0x01c00014,
         .adda_1t_path_on = 0x01c00014,
@@ -8510,7 +8503,7 @@ static struct rtl8xxxu_fileops rtl8192cu_fops = {
         .writeN_block_size = 128,
         .mbox_ext_reg = REG_HMBOX_EXT_0,
         .mbox_ext_width = 2,
-        .tx_desc_size = sizeof(struct rtl8723au_tx_desc),
+        .tx_desc_size = sizeof(struct rtl8xxxu_txdesc32),
         .adda_1t_init = 0x0b1b25a0,
         .adda_1t_path_on = 0x0bdb25a0,
         .adda_2t_path_on_a = 0x04db25a4,
@@ -8532,12 +8525,12 @@ static struct rtl8xxxu_fileops rtl8192eu_fops = {
         .enable_rf = rtl8723b_enable_rf,
         .disable_rf = rtl8723b_disable_rf,
         .set_tx_power = rtl8723b_set_tx_power,
-        .update_rate_mask = rtl8723au_update_rate_mask,
-        .report_connect = rtl8723au_report_connect,
+        .update_rate_mask = rtl8723bu_update_rate_mask,
+        .report_connect = rtl8723bu_report_connect,
         .writeN_block_size = 128,
         .mbox_ext_reg = REG_HMBOX_EXT0_8723B,
         .mbox_ext_width = 4,
-        .tx_desc_size = sizeof(struct rtl8723au_tx_desc),
+        .tx_desc_size = sizeof(struct rtl8xxxu_txdesc40),
         .has_s0s1 = 1,
         .adda_1t_init = 0x0fc01616,
         .adda_1t_path_on = 0x0fc01616,
diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h
index 7b73654e1368..455e1122dbb5 100644
--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h
+++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h
@@ -65,6 +65,30 @@
 #define EFUSE_BT_MAP_LEN_8723A          1024
 #define EFUSE_MAX_WORD_UNIT             4
 
+enum rtl8xxxu_rtl_chip {
+        RTL8192S = 0x81920,
+        RTL8191S = 0x81910,
+        RTL8192C = 0x8192c,
+        RTL8191C = 0x8191c,
+        RTL8188C = 0x8188c,
+        RTL8188R = 0x81889,
+        RTL8192D = 0x8192d,
+        RTL8723A = 0x8723a,
+        RTL8188E = 0x8188e,
+        RTL8812  = 0x88120,
+        RTL8821  = 0x88210,
+        RTL8192E = 0x8192e,
+        RTL8191E = 0x8191e,
+        RTL8723B = 0x8723b,
+        RTL8814A = 0x8814a,
+        RTL8881A = 0x8881a,
+        RTL8821B = 0x8821b,
+        RTL8822B = 0x8822b,
+        RTL8703B = 0x8703b,
+        RTL8195A = 0x8195a,
+        RTL8188F = 0x8188f
+};
+
 enum rtl8xxxu_rx_type {
         RX_TYPE_DATA_PKT = 0,
         RX_TYPE_C2H = 1,
@@ -332,7 +356,7 @@ struct rtl8723bu_rx_desc {
         __le32 tsfl;
 };
 
-struct rtl8723au_tx_desc {
+struct rtl8xxxu_txdesc32 {
         __le16 pkt_size;
         u8 pkt_offset;
         u8 txdw0;
@@ -346,7 +370,7 @@ struct rtl8723au_tx_desc {
         __le16 txdw7;
 };
 
-struct rtl8723bu_tx_desc {
+struct rtl8xxxu_txdesc40 {
         __le16 pkt_size;
         u8 pkt_offset;
         u8 txdw0;
@@ -422,10 +446,10 @@ struct rtl8723bu_tx_desc {
  * aggregation enable and break respectively. For 8723bu, bits 0-7 are macid.
  */
 #define TXDESC_PKT_OFFSET_SZ            0
-#define TXDESC_AGG_ENABLE_8723A         BIT(5)
-#define TXDESC_AGG_BREAK_8723A          BIT(6)
-#define TXDESC_MACID_SHIFT_8723B        0
-#define TXDESC_MACID_MASK_8723B         0x00f0
+#define TXDESC32_AGG_ENABLE             BIT(5)
+#define TXDESC32_AGG_BREAK              BIT(6)
+#define TXDESC40_MACID_SHIFT            0
+#define TXDESC40_MACID_MASK             0x00f0
 #define TXDESC_QUEUE_SHIFT              8
 #define TXDESC_QUEUE_MASK               0x1f00
 #define TXDESC_QUEUE_BK                 0x2
@@ -437,9 +461,9 @@ struct rtl8723bu_tx_desc {
 #define TXDESC_QUEUE_MGNT               0x12
 #define TXDESC_QUEUE_CMD                0x13
 #define TXDESC_QUEUE_MAX                (TXDESC_QUEUE_CMD + 1)
-#define TXDESC_RDG_NAV_EXT_8723B        BIT(13)
-#define TXDESC_LSIG_TXOP_ENABLE_8723B   BIT(14)
-#define TXDESC_PIFS_8723B               BIT(15)
+#define TXDESC40_RDG_NAV_EXT            BIT(13)
+#define TXDESC40_LSIG_TXOP_ENABLE       BIT(14)
+#define TXDESC40_PIFS                   BIT(15)
 
 #define DESC_RATE_ID_SHIFT              16
 #define DESC_RATE_ID_MASK               0xf
@@ -451,71 +475,71 @@ struct rtl8723bu_tx_desc {
 #define TXDESC_HWPC                     BIT(31)
 
 /* Word 2 */
-#define TXDESC_PAID_SHIFT_8723B         0
-#define TXDESC_PAID_MASK_8723B          0x1ff
-#define TXDESC_CCA_RTS_SHIFT_8723B      10
-#define TXDESC_CCA_RTS_MASK_8723B       0xc00
-#define TXDESC_AGG_ENABLE_8723B         BIT(12)
-#define TXDESC_RDG_ENABLE_8723B         BIT(13)
-#define TXDESC_AGG_BREAK_8723B          BIT(16)
-#define TXDESC_MORE_FRAG_8723B          BIT(17)
-#define TXDESC_RAW_8723B                BIT(18)
-#define TXDESC_ACK_REPORT_8723A         BIT(19)
-#define TXDESC_SPE_RPT_8723B            BIT(19)
+#define TXDESC40_PAID_SHIFT             0
+#define TXDESC40_PAID_MASK              0x1ff
+#define TXDESC40_CCA_RTS_SHIFT          10
+#define TXDESC40_CCA_RTS_MASK           0xc00
+#define TXDESC40_AGG_ENABLE             BIT(12)
+#define TXDESC40_RDG_ENABLE             BIT(13)
+#define TXDESC40_AGG_BREAK              BIT(16)
+#define TXDESC40_MORE_FRAG              BIT(17)
+#define TXDESC40_RAW                    BIT(18)
+#define TXDESC32_ACK_REPORT             BIT(19)
+#define TXDESC40_SPE_RPT                BIT(19)
 #define TXDESC_AMPDU_DENSITY_SHIFT      20
-#define TXDESC_BT_INT_8723B             BIT(23)
-#define TXDESC_GID_8723B                BIT(24)
+#define TXDESC40_BT_INT                 BIT(23)
+#define TXDESC40_GID_SHIFT              24
 
 /* Word 3 */
-#define TXDESC_USE_DRIVER_RATE_8723B    BIT(8)
-#define TXDESC_CTS_SELF_ENABLE_8723B    BIT(11)
-#define TXDESC_RTS_CTS_ENABLE_8723B     BIT(12)
-#define TXDESC_HW_RTS_ENABLE_8723B      BIT(13)
-#define TXDESC_SEQ_SHIFT_8723A          16
-#define TXDESC_SEQ_MASK_8723A           0x0fff0000
+#define TXDESC40_USE_DRIVER_RATE        BIT(8)
+#define TXDESC40_CTS_SELF_ENABLE        BIT(11)
+#define TXDESC40_RTS_CTS_ENABLE         BIT(12)
+#define TXDESC40_HW_RTS_ENABLE          BIT(13)
+#define TXDESC32_SEQ_SHIFT              16
+#define TXDESC32_SEQ_MASK               0x0fff0000
 
 /* Word 4 */
-#define TXDESC_RTS_RATE_SHIFT_8723A     0
-#define TXDESC_RTS_RATE_MASK_8723A      0x3f
-#define TXDESC_QOS_8723A                BIT(6)
-#define TXDESC_HW_SEQ_ENABLE_8723A      BIT(7)
-#define TXDESC_USE_DRIVER_RATE_8723A    BIT(8)
+#define TXDESC32_RTS_RATE_SHIFT         0
+#define TXDESC32_RTS_RATE_MASK          0x3f
+#define TXDESC32_QOS                    BIT(6)
+#define TXDESC32_HW_SEQ_ENABLE          BIT(7)
+#define TXDESC32_USE_DRIVER_RATE        BIT(8)
 #define TXDESC_DISABLE_DATA_FB          BIT(10)
-#define TXDESC_CTS_SELF_ENABLE_8723A    BIT(11)
-#define TXDESC_RTS_CTS_ENABLE_8723A     BIT(12)
-#define TXDESC_HW_RTS_ENABLE_8723A      BIT(13)
+#define TXDESC32_CTS_SELF_ENABLE        BIT(11)
+#define TXDESC32_RTS_CTS_ENABLE         BIT(12)
+#define TXDESC32_HW_RTS_ENABLE          BIT(13)
 #define TXDESC_PRIME_CH_OFF_LOWER       BIT(20)
 #define TXDESC_PRIME_CH_OFF_UPPER       BIT(21)
-#define TXDESC_SHORT_PREAMBLE_8723A     BIT(24)
+#define TXDESC32_SHORT_PREAMBLE         BIT(24)
 #define TXDESC_DATA_BW                  BIT(25)
 #define TXDESC_RTS_DATA_BW              BIT(27)
 #define TXDESC_RTS_PRIME_CH_OFF_LOWER   BIT(28)
 #define TXDESC_RTS_PRIME_CH_OFF_UPPER   BIT(29)
-#define TXDESC_DATA_RATE_FB_SHIFT_8723B 8
-#define TXDESC_DATA_RATE_FB_MASK_8723B  0x00001f00
-#define TXDESC_RETRY_LIMIT_ENABLE_8723B BIT(17)
-#define TXDESC_RETRY_LIMIT_SHIFT_8723B  18
-#define TXDESC_RETRY_LIMIT_MASK_8723B   0x00fc0000
-#define TXDESC_RTS_RATE_SHIFT_8723B     24
-#define TXDESC_RTS_RATE_MASK_8723B      0x3f000000
+#define TXDESC40_DATA_RATE_FB_SHIFT     8
+#define TXDESC40_DATA_RATE_FB_MASK      0x00001f00
+#define TXDESC40_RETRY_LIMIT_ENABLE     BIT(17)
+#define TXDESC40_RETRY_LIMIT_SHIFT      18
+#define TXDESC40_RETRY_LIMIT_MASK       0x00fc0000
+#define TXDESC40_RTS_RATE_SHIFT         24
+#define TXDESC40_RTS_RATE_MASK          0x3f000000
 
 /* Word 5 */
-#define TXDESC_SHORT_PREAMBLE_8723B     BIT(4)
-#define TXDESC_SHORT_GI                 BIT(6)
+#define TXDESC40_SHORT_PREAMBLE         BIT(4)
+#define TXDESC32_SHORT_GI               BIT(6)
 #define TXDESC_CCX_TAG                  BIT(7)
-#define TXDESC_RETRY_LIMIT_ENABLE_8723A BIT(17)
-#define TXDESC_RETRY_LIMIT_SHIFT_8723A  18
-#define TXDESC_RETRY_LIMIT_MASK_8723A   0x00fc0000
+#define TXDESC32_RETRY_LIMIT_ENABLE     BIT(17)
+#define TXDESC32_RETRY_LIMIT_SHIFT      18
+#define TXDESC32_RETRY_LIMIT_MASK       0x00fc0000
 
 /* Word 6 */
 #define TXDESC_MAX_AGG_SHIFT            11
 
 /* Word 8 */
-#define TXDESC_HW_SEQ_ENABLE_8723B      BIT(15)
+#define TXDESC40_HW_SEQ_ENABLE          BIT(15)
 
 /* Word 9 */
-#define TXDESC_SEQ_SHIFT_8723B          12
-#define TXDESC_SEQ_MASK_8723B           0x00fff000
+#define TXDESC40_SEQ_SHIFT              12
+#define TXDESC40_SEQ_MASK               0x00fff000
 
 struct phy_rx_agc_info {
 #ifdef __LITTLE_ENDIAN
@@ -1236,7 +1260,7 @@ struct rtl8xxxu_priv {
         u32 mac_backup[RTL8XXXU_MAC_REGS];
         u32 bb_backup[RTL8XXXU_BB_REGS];
         u32 bb_recovery_backup[RTL8XXXU_BB_REGS];
-        u32 rtlchip;
+        enum rtl8xxxu_rtl_chip rtl_chip;
         u8 pi_enabled:1;
         u8 int_buf[USB_INTR_CONTENT_LENGTH];
 };
diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_regs.h b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_regs.h
index e545e849f5a3..ade42fe7e742 100644
--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_regs.h
+++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_regs.h
@@ -417,13 +417,20 @@
 
 /*  spec version 11 */
 /* 0x0400 ~ 0x047F      Protocol Configuration */
-#define REG_VOQ_INFORMATION             0x0400
-#define REG_VIQ_INFORMATION             0x0404
-#define REG_BEQ_INFORMATION             0x0408
-#define REG_BKQ_INFORMATION             0x040c
-#define REG_MGQ_INFORMATION             0x0410
-#define REG_HGQ_INFORMATION             0x0414
-#define REG_BCNQ_INFORMATION            0x0418
+/* 8192c, 8192d */
+#define REG_VOQ_INFO                    0x0400
+#define REG_VIQ_INFO                    0x0404
+#define REG_BEQ_INFO                    0x0408
+#define REG_BKQ_INFO                    0x040c
+/* 8188e, 8723a, 8812a, 8821a, 8192e, 8723b */
+#define REG_Q0_INFO                     0x400
+#define REG_Q1_INFO                     0x404
+#define REG_Q2_INFO                     0x408
+#define REG_Q3_INFO                     0x40c
+
+#define REG_MGQ_INFO                    0x0410
+#define REG_HGQ_INFO                    0x0414
+#define REG_BCNQ_INFO                   0x0418
 
 #define REG_CPU_MGQ_INFORMATION         0x041c
 #define REG_FWHW_TXQ_CTRL               0x0420
@@ -494,6 +501,9 @@
 #define REG_DATA_SUBCHANNEL             0x0483
 /* 8723au */
 #define REG_INIDATA_RATE_SEL            0x0484
+/* MACID_SLEEP_1/3 for 8723b, 8192e, 8812a, 8821a */
+#define REG_MACID_SLEEP_3_8732B         0x0484
+#define REG_MACID_SLEEP_1_8732B         0x0488
 
 #define REG_POWER_STATUS                0x04a4
 #define REG_POWER_STAGE1                0x04b4
@@ -508,6 +518,13 @@
 #define REG_RTS_MAX_AGGR_NUM            0x04cb
 #define REG_BAR_MODE_CTRL               0x04cc
 #define REG_RA_TRY_RATE_AGG_LMT         0x04cf
+/* MACID_DROP for 8723a */
+#define REG_MACID_DROP_8732A            0x04d0
+/* EARLY_MODE_CONTROL 8188e */
+#define REG_EARLY_MODE_CONTROL_8188E    0x04d0
+/* MACID_SLEEP_2 for 8723b, 8192e, 8812a, 8821a */
+#define REG_MACID_SLEEP_2_8732B         0x04d0
+#define REG_MACID_SLEEP                 0x04d4
 #define REG_NQOS_SEQ                    0x04dc
 #define REG_QOS_SEQ                     0x04de
 #define REG_NEED_CPU_HANDLE             0x04e0
diff --git a/drivers/net/wireless/realtek/rtlwifi/base.c b/drivers/net/wireless/realtek/rtlwifi/base.c
index 0517a4f2d3f2..c74eb139bfa1 100644
--- a/drivers/net/wireless/realtek/rtlwifi/base.c
+++ b/drivers/net/wireless/realtek/rtlwifi/base.c
@@ -131,7 +131,7 @@ static struct ieee80211_rate rtl_ratetable_5g[] = {
 };
 
 static const struct ieee80211_supported_band rtl_band_2ghz = {
-        .band = IEEE80211_BAND_2GHZ,
+        .band = NL80211_BAND_2GHZ,
 
         .channels = rtl_channeltable_2g,
         .n_channels = ARRAY_SIZE(rtl_channeltable_2g),
@@ -143,7 +143,7 @@ static const struct ieee80211_supported_band rtl_band_2ghz = {
 };
 
 static struct ieee80211_supported_band rtl_band_5ghz = {
-        .band = IEEE80211_BAND_5GHZ,
+        .band = NL80211_BAND_5GHZ,
 
         .channels = rtl_channeltable_5g,
         .n_channels = ARRAY_SIZE(rtl_channeltable_5g),
@@ -197,7 +197,7 @@ static void _rtl_init_hw_ht_capab(struct ieee80211_hw *hw,
 
         ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
 
-        /*hw->wiphy->bands[IEEE80211_BAND_2GHZ]
+        /*hw->wiphy->bands[NL80211_BAND_2GHZ]
          *base on ant_num
          *rx_mask: RX mask
          *if rx_ant = 1 rx_mask[0]= 0xff;==>MCS0-MCS7
@@ -328,26 +328,26 @@ static void _rtl_init_mac80211(struct ieee80211_hw *hw)
             rtlhal->bandset == BAND_ON_BOTH) {
                 /* 1: 2.4 G bands */
                 /* <1> use  mac->bands as mem for hw->wiphy->bands */
-                sband = &(rtlmac->bands[IEEE80211_BAND_2GHZ]);
+                sband = &(rtlmac->bands[NL80211_BAND_2GHZ]);
 
-                /* <2> set hw->wiphy->bands[IEEE80211_BAND_2GHZ]
+                /* <2> set hw->wiphy->bands[NL80211_BAND_2GHZ]
                  * to default value(1T1R) */
-                memcpy(&(rtlmac->bands[IEEE80211_BAND_2GHZ]), &rtl_band_2ghz,
+                memcpy(&(rtlmac->bands[NL80211_BAND_2GHZ]), &rtl_band_2ghz,
                                 sizeof(struct ieee80211_supported_band));
 
                 /* <3> init ht cap base on ant_num */
                 _rtl_init_hw_ht_capab(hw, &sband->ht_cap);
 
                 /* <4> set mac->sband to wiphy->sband */
-                hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
+                hw->wiphy->bands[NL80211_BAND_2GHZ] = sband;
 
                 /* 2: 5 G bands */
                 /* <1> use  mac->bands as mem for hw->wiphy->bands */
-                sband = &(rtlmac->bands[IEEE80211_BAND_5GHZ]);
+                sband = &(rtlmac->bands[NL80211_BAND_5GHZ]);
 
-                /* <2> set hw->wiphy->bands[IEEE80211_BAND_5GHZ]
+                /* <2> set hw->wiphy->bands[NL80211_BAND_5GHZ]
                  * to default value(1T1R) */
-                memcpy(&(rtlmac->bands[IEEE80211_BAND_5GHZ]), &rtl_band_5ghz,
+                memcpy(&(rtlmac->bands[NL80211_BAND_5GHZ]), &rtl_band_5ghz,
                                 sizeof(struct ieee80211_supported_band));
 
                 /* <3> init ht cap base on ant_num */
@@ -355,15 +355,15 @@ static void _rtl_init_mac80211(struct ieee80211_hw *hw)
 
                 _rtl_init_hw_vht_capab(hw, &sband->vht_cap);
                 /* <4> set mac->sband to wiphy->sband */
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
+                hw->wiphy->bands[NL80211_BAND_5GHZ] = sband;
         } else {
                 if (rtlhal->current_bandtype == BAND_ON_2_4G) {
                         /* <1> use  mac->bands as mem for hw->wiphy->bands */
-                        sband = &(rtlmac->bands[IEEE80211_BAND_2GHZ]);
+                        sband = &(rtlmac->bands[NL80211_BAND_2GHZ]);
 
-                        /* <2> set hw->wiphy->bands[IEEE80211_BAND_2GHZ]
+                        /* <2> set hw->wiphy->bands[NL80211_BAND_2GHZ]
                          * to default value(1T1R) */
-                        memcpy(&(rtlmac->bands[IEEE80211_BAND_2GHZ]),
+                        memcpy(&(rtlmac->bands[NL80211_BAND_2GHZ]),
                                &rtl_band_2ghz,
                                sizeof(struct ieee80211_supported_band));
 
@@ -371,14 +371,14 @@ static void _rtl_init_mac80211(struct ieee80211_hw *hw)
                         _rtl_init_hw_ht_capab(hw, &sband->ht_cap);
 
                         /* <4> set mac->sband to wiphy->sband */
-                        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
+                        hw->wiphy->bands[NL80211_BAND_2GHZ] = sband;
                 } else if (rtlhal->current_bandtype == BAND_ON_5G) {
                         /* <1> use  mac->bands as mem for hw->wiphy->bands */
-                        sband = &(rtlmac->bands[IEEE80211_BAND_5GHZ]);
+                        sband = &(rtlmac->bands[NL80211_BAND_5GHZ]);
 
-                        /* <2> set hw->wiphy->bands[IEEE80211_BAND_5GHZ]
+                        /* <2> set hw->wiphy->bands[NL80211_BAND_5GHZ]
                          * to default value(1T1R) */
-                        memcpy(&(rtlmac->bands[IEEE80211_BAND_5GHZ]),
+                        memcpy(&(rtlmac->bands[NL80211_BAND_5GHZ]),
                                &rtl_band_5ghz,
                                sizeof(struct ieee80211_supported_band));
 
@@ -387,7 +387,7 @@ static void _rtl_init_mac80211(struct ieee80211_hw *hw)
 
                         _rtl_init_hw_vht_capab(hw, &sband->vht_cap);
                         /* <4> set mac->sband to wiphy->sband */
-                        hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
+                        hw->wiphy->bands[NL80211_BAND_5GHZ] = sband;
                 } else {
                         RT_TRACE(rtlpriv, COMP_INIT, DBG_EMERG, "Err BAND %d\n",
                                  rtlhal->current_bandtype);
@@ -861,7 +861,7 @@ static u8 _rtl_get_highest_n_rate(struct ieee80211_hw *hw,
 
 /* mac80211's rate_idx is like this:
  *
- * 2.4G band:rx_status->band == IEEE80211_BAND_2GHZ
+ * 2.4G band:rx_status->band == NL80211_BAND_2GHZ
  *
  * B/G rate:
  * (rx_status->flag & RX_FLAG_HT) = 0,
@@ -871,7 +871,7 @@ static u8 _rtl_get_highest_n_rate(struct ieee80211_hw *hw,
  * (rx_status->flag & RX_FLAG_HT) = 1,
  * DESC_RATEMCS0-->DESC_RATEMCS15 ==> idx is 0-->15
  *
- * 5G band:rx_status->band == IEEE80211_BAND_5GHZ
+ * 5G band:rx_status->band == NL80211_BAND_5GHZ
  * A rate:
  * (rx_status->flag & RX_FLAG_HT) = 0,
  * DESC_RATE6M-->DESC_RATE54M ==> idx is 0-->7,
@@ -958,7 +958,7 @@ int rtlwifi_rate_mapping(struct ieee80211_hw *hw, bool isht, bool isvht,
                 return rate_idx;
         }
         if (false == isht) {
-                if (IEEE80211_BAND_2GHZ == hw->conf.chandef.chan->band) {
+                if (NL80211_BAND_2GHZ == hw->conf.chandef.chan->band) {
                         switch (desc_rate) {
                         case DESC_RATE1M:
                                 rate_idx = 0;
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8192e2ant.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8192e2ant.c
index 451456835f87..a30af6cc21f3 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8192e2ant.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8192e2ant.c
@@ -70,83 +70,83 @@ static u8 halbtc8192e2ant_btrssi_state(u8 level_num, u8 rssi_thresh,
         if (level_num == 2) {
                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "BT Rssi pre state = LOW\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "BT Rssi pre state = LOW\n");
                         if (btrssi >= (rssi_thresh +
                                        BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 btrssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to High\n");
                         } else {
                                 btrssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state stay at Low\n");
                         }
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "BT Rssi pre state = HIGH\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "BT Rssi pre state = HIGH\n");
                         if (btrssi < rssi_thresh) {
                                 btrssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to Low\n");
                         } else {
                                 btrssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "BT Rssi thresh error!!\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "BT Rssi thresh error!!\n");
                         return coex_sta->pre_bt_rssi_state;
                 }
 
                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "BT Rssi pre state = LOW\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "BT Rssi pre state = LOW\n");
                         if (btrssi >= (rssi_thresh +
                                       BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 btrssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to Medium\n");
                         } else {
                                 btrssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_bt_rssi_state ==
                             BTC_RSSI_STATE_MEDIUM) ||
                            (coex_sta->pre_bt_rssi_state ==
                             BTC_RSSI_STATE_STAY_MEDIUM)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "[BTCoex], BT Rssi pre state = MEDIUM\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "[BTCoex], BT Rssi pre state = MEDIUM\n");
                         if (btrssi >= (rssi_thresh1 +
                                        BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 btrssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to High\n");
                         } else if (btrssi < rssi_thresh) {
                                 btrssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to Low\n");
                         } else {
                                 btrssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state stay at Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state stay at Medium\n");
                         }
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "BT Rssi pre state = HIGH\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "BT Rssi pre state = HIGH\n");
                         if (btrssi < rssi_thresh1) {
                                 btrssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state switch to Medium\n");
                         } else {
                                 btrssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "BT Rssi state stay at High\n");
                         }
                 }
         }
@@ -173,32 +173,28 @@ static u8 halbtc8192e2ant_wifirssi_state(struct btc_coexist *btcoexist,
                         if (wifirssi >= (rssi_thresh +
                                          BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 wifirssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to High\n");
                         } else {
                                 wifirssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state stay at Low\n");
                         }
                 } else {
                         if (wifirssi < rssi_thresh) {
                                 wifirssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to Low\n");
                         } else {
                                 wifirssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
-                                  "wifi RSSI thresh error!!\n");
+                        btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                    "wifi RSSI thresh error!!\n");
                         return coex_sta->pre_wifi_rssi_state[index];
                 }
 
@@ -209,14 +205,12 @@ static u8 halbtc8192e2ant_wifirssi_state(struct btc_coexist *btcoexist,
                         if (wifirssi >= (rssi_thresh +
                                          BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 wifirssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to Medium\n");
                         } else {
                                 wifirssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
                             BTC_RSSI_STATE_MEDIUM) ||
@@ -225,31 +219,26 @@ static u8 halbtc8192e2ant_wifirssi_state(struct btc_coexist *btcoexist,
                         if (wifirssi >= (rssi_thresh1 +
                                          BTC_RSSI_COEX_THRESH_TOL_8192E_2ANT)) {
                                 wifirssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to High\n");
                         } else if (wifirssi < rssi_thresh) {
                                 wifirssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to Low\n");
                         } else {
                                 wifirssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state stay at Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state stay at Medium\n");
                         }
                 } else {
                         if (wifirssi < rssi_thresh1) {
                                 wifirssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state switch to Medium\n");
                         } else {
                                 wifirssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "wifi RSSI state stay at High\n");
                         }
                 }
         }
@@ -284,26 +273,26 @@ static void btc8192e2ant_monitor_bt_enable_dis(struct btc_coexist *btcoexist)
                 bt_disabled = false;
                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                    &bt_disabled);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is enabled !!\n");
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is enabled !!\n");
         } else {
                 bt_disable_cnt++;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], bt all counters = 0, %d times!!\n",
-                          bt_disable_cnt);
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], bt all counters = 0, %d times!!\n",
+                            bt_disable_cnt);
                 if (bt_disable_cnt >= 2) {
                         bt_disabled = true;
                         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                            &bt_disabled);
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                                  "[BTCoex], BT is disabled !!\n");
+                        btc_alg_dbg(ALGO_BT_MONITOR,
+                                    "[BTCoex], BT is disabled !!\n");
                 }
         }
         if (pre_bt_disabled != bt_disabled) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is from %s to %s!!\n",
-                          (pre_bt_disabled ? "disabled" : "enabled"),
-                          (bt_disabled ? "disabled" : "enabled"));
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is from %s to %s!!\n",
+                            (pre_bt_disabled ? "disabled" : "enabled"),
+                            (bt_disabled ? "disabled" : "enabled"));
                 pre_bt_disabled = bt_disabled;
         }
 }
@@ -499,12 +488,12 @@ static void halbtc8192e2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
         coex_sta->low_priority_tx = reg_lp_tx;
         coex_sta->low_priority_rx = reg_lp_rx;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex] High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
-                  reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex] Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
-                  reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex] High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
+                    reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex] Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
+                    reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 
         /* reset counter */
         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
@@ -518,9 +507,9 @@ static void halbtc8192e2ant_querybt_info(struct btc_coexist *btcoexist)
 
         h2c_parameter[0] |= BIT0;       /* trigger */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 }
@@ -592,8 +581,8 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hson);
 
         if (!bt_link_info->bt_link_exist) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "No BT link exists!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "No BT link exists!!!\n");
                 return algorithm;
         }
 
@@ -608,27 +597,27 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
 
         if (numdiffprofile == 1) {
                 if (bt_link_info->sco_exist) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "SCO only\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "SCO only\n");
                         algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
                 } else {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "HID only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "HID only\n");
                                 algorithm = BT_8192E_2ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "A2DP only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "A2DP only\n");
                                 algorithm = BT_8192E_2ANT_COEX_ALGO_A2DP;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "PAN(HS) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "PAN(HS) only\n");
                                         algorithm =
                                                 BT_8192E_2ANT_COEX_ALGO_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "PAN(EDR) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "PAN(EDR) only\n");
                                         algorithm =
                                                 BT_8192E_2ANT_COEX_ALGO_PANEDR;
                                 }
@@ -637,21 +626,21 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
         } else if (numdiffprofile == 2) {
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "SCO + HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "SCO + HID\n");
                                 algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "SCO + A2DP ==> SCO\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "SCO + A2DP ==> SCO\n");
                                 algorithm = BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + PAN(HS)\n");
                                         algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + PAN(EDR)\n");
                                         algorithm =
                                                 BT_8192E_2ANT_COEX_ALGO_SCO_PAN;
                                 }
@@ -660,38 +649,38 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (stack_info->num_of_hid >= 2) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID*2 + A2DP\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID*2 + A2DP\n");
                                         algorithm =
                                         BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID + A2DP\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID + A2DP\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_HID_A2DP;
                                 }
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID + PAN(HS)\n");
                                         algorithm = BT_8192E_2ANT_COEX_ALGO_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID + PAN(EDR)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_A2DP_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "A2DP + PAN(EDR)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_PANEDR_A2DP;
                                 }
@@ -701,30 +690,30 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "SCO + HID + A2DP ==> HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "SCO + HID + A2DP ==> HID\n");
                                 algorithm = BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + HID + PAN(HS)\n");
                                         algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + HID + PAN(EDR)\n");
                                         algorithm =
                                                 BT_8192E_2ANT_COEX_ALGO_SCO_PAN;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + A2DP + PAN(HS)\n");
                                         algorithm = BT_8192E_2ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO + A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO + A2DP + PAN(EDR)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -734,13 +723,13 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID + A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "HID + A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "HID + A2DP + PAN(EDR)\n");
                                         algorithm =
                                         BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 }
@@ -752,12 +741,12 @@ static u8 halbtc8192e2ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hson) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "ErrorSCO+HID+A2DP+PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "ErrorSCO+HID+A2DP+PAN(HS)\n");
 
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "SCO+HID+A2DP+PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "SCO+HID+A2DP+PAN(EDR)\n");
                                         algorithm =
                                             BT_8192E_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -778,10 +767,10 @@ static void halbtc8192e2ant_setfw_dac_swinglevel(struct btc_coexist *btcoexist,
          */
         h2c_parameter[0] = dac_swinglvl;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swinglvl);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swinglvl);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 }
@@ -793,9 +782,9 @@ static void halbtc8192e2ant_set_fwdec_btpwr(struct btc_coexist *btcoexist,
 
         h2c_parameter[0] = dec_btpwr_lvl;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex] decrease Bt Power level = %d, FW write 0x62 = 0x%x\n",
-                  dec_btpwr_lvl, h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex] decrease Bt Power level = %d, FW write 0x62 = 0x%x\n",
+                    dec_btpwr_lvl, h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 }
@@ -803,15 +792,15 @@ static void halbtc8192e2ant_set_fwdec_btpwr(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_dec_btpwr(struct btc_coexist *btcoexist,
                                       bool force_exec, u8 dec_btpwr_lvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s Dec BT power level = %d\n",
-                  (force_exec ? "force to" : ""), dec_btpwr_lvl);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s Dec BT power level = %d\n",
+                    (force_exec ? "force to" : ""), dec_btpwr_lvl);
         coex_dm->cur_dec_bt_pwr = dec_btpwr_lvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], preBtDecPwrLvl=%d, curBtDecPwrLvl=%d\n",
-                          coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], preBtDecPwrLvl=%d, curBtDecPwrLvl=%d\n",
+                            coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
         }
         halbtc8192e2ant_set_fwdec_btpwr(btcoexist, coex_dm->cur_dec_bt_pwr);
 
@@ -828,10 +817,10 @@ static void halbtc8192e2ant_set_bt_autoreport(struct btc_coexist *btcoexist,
         if (enable_autoreport)
                 h2c_parameter[0] |= BIT0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
-                  (enable_autoreport ? "Enabled!!" : "Disabled!!"),
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
+                    (enable_autoreport ? "Enabled!!" : "Disabled!!"),
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 }
@@ -840,17 +829,17 @@ static void halbtc8192e2ant_bt_autoreport(struct btc_coexist *btcoexist,
                                           bool force_exec,
                                           bool enable_autoreport)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s BT Auto report = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((enable_autoreport) ? "Enabled" : "Disabled"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s BT Auto report = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((enable_autoreport) ? "Enabled" : "Disabled"));
         coex_dm->cur_bt_auto_report = enable_autoreport;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex] bPreBtAutoReport=%d, bCurBtAutoReport=%d\n",
-                          coex_dm->pre_bt_auto_report,
-                          coex_dm->cur_bt_auto_report);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex] bPreBtAutoReport=%d, bCurBtAutoReport=%d\n",
+                            coex_dm->pre_bt_auto_report,
+                            coex_dm->cur_bt_auto_report);
 
                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
                         return;
@@ -864,16 +853,16 @@ static void halbtc8192e2ant_bt_autoreport(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_fw_dac_swinglvl(struct btc_coexist *btcoexist,
                                             bool force_exec, u8 fw_dac_swinglvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s set FW Dac Swing level = %d\n",
-                  (force_exec ? "force to" : ""), fw_dac_swinglvl);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s set FW Dac Swing level = %d\n",
+                    (force_exec ? "force to" : ""), fw_dac_swinglvl);
         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swinglvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex] preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
-                          coex_dm->pre_fw_dac_swing_lvl,
-                          coex_dm->cur_fw_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex] preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
+                            coex_dm->pre_fw_dac_swing_lvl,
+                            coex_dm->cur_fw_dac_swing_lvl);
 
                 if (coex_dm->pre_fw_dac_swing_lvl ==
                     coex_dm->cur_fw_dac_swing_lvl)
@@ -891,8 +880,8 @@ static void btc8192e2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 {
         if (rx_rf_shrink_on) {
                 /* Shrink RF Rx LPF corner */
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Shrink RF Rx LPF corner!!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Shrink RF Rx LPF corner!!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
                                           0xfffff, 0xffffc);
         } else {
@@ -900,8 +889,8 @@ static void btc8192e2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
                  * After initialized, we can use coex_dm->btRf0x1eBackup
                  */
                 if (btcoexist->initilized) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                                  "[BTCoex], Resume RF Rx LPF corner!!\n");
+                        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                                    "[BTCoex], Resume RF Rx LPF corner!!\n");
                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
                                                   0xfffff,
                                                   coex_dm->bt_rf0x1e_backup);
@@ -912,17 +901,17 @@ static void btc8192e2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_rf_shrink(struct btc_coexist *btcoexist,
                                       bool force_exec, bool rx_rf_shrink_on)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn Rx RF Shrink = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((rx_rf_shrink_on) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn Rx RF Shrink = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((rx_rf_shrink_on) ? "ON" : "OFF"));
         coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex]bPreRfRxLpfShrink=%d,bCurRfRxLpfShrink=%d\n",
-                          coex_dm->pre_rf_rx_lpf_shrink,
-                          coex_dm->cur_rf_rx_lpf_shrink);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex]bPreRfRxLpfShrink=%d,bCurRfRxLpfShrink=%d\n",
+                            coex_dm->pre_rf_rx_lpf_shrink,
+                            coex_dm->cur_rf_rx_lpf_shrink);
 
                 if (coex_dm->pre_rf_rx_lpf_shrink ==
                     coex_dm->cur_rf_rx_lpf_shrink)
@@ -939,8 +928,8 @@ static void halbtc8192e2ant_set_dac_swingreg(struct btc_coexist *btcoexist,
 {
         u8 val = (u8)level;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], Write SwDacSwing = 0x%x\n", level);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], Write SwDacSwing = 0x%x\n", level);
         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
 }
 
@@ -958,22 +947,22 @@ static void halbtc8192e2ant_DacSwing(struct btc_coexist *btcoexist,
                                      bool force_exec, bool dac_swingon,
                                      u32 dac_swinglvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn DacSwing=%s, dac_swinglvl = 0x%x\n",
-                  (force_exec ? "force to" : ""),
-                  ((dac_swingon) ? "ON" : "OFF"), dac_swinglvl);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn DacSwing=%s, dac_swinglvl = 0x%x\n",
+                    (force_exec ? "force to" : ""),
+                    ((dac_swingon) ? "ON" : "OFF"), dac_swinglvl);
         coex_dm->cur_dac_swing_on = dac_swingon;
         coex_dm->cur_dac_swing_lvl = dac_swinglvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl = 0x%x, ",
-                          coex_dm->pre_dac_swing_on,
-                          coex_dm->pre_dac_swing_lvl);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "bCurDacSwingOn=%d, curDacSwingLvl = 0x%x\n",
-                          coex_dm->cur_dac_swing_on,
-                          coex_dm->cur_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl = 0x%x, ",
+                            coex_dm->pre_dac_swing_on,
+                            coex_dm->pre_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "bCurDacSwingOn=%d, curDacSwingLvl = 0x%x\n",
+                            coex_dm->cur_dac_swing_on,
+                            coex_dm->cur_dac_swing_lvl);
 
                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
                     (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
@@ -991,8 +980,8 @@ static void halbtc8192e2ant_set_agc_table(struct btc_coexist *btcoexist,
 {
         /* BB AGC Gain Table */
         if (agc_table_en) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB Agc Table On!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB Agc Table On!\n");
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x0a1A0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x091B0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x081C0001);
@@ -1000,8 +989,8 @@ static void halbtc8192e2ant_set_agc_table(struct btc_coexist *btcoexist,
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x061E0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x051F0001);
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB Agc Table Off!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB Agc Table Off!\n");
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
@@ -1014,16 +1003,17 @@ static void halbtc8192e2ant_set_agc_table(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_AgcTable(struct btc_coexist *btcoexist,
                                      bool force_exec, bool agc_table_en)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s %s Agc Table\n",
-                  (force_exec ? "force to" : ""),
-                  ((agc_table_en) ? "Enable" : "Disable"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s %s Agc Table\n",
+                    (force_exec ? "force to" : ""),
+                    ((agc_table_en) ? "Enable" : "Disable"));
         coex_dm->cur_agc_table_en = agc_table_en;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
-                          coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
+                            coex_dm->pre_agc_table_en,
+                            coex_dm->cur_agc_table_en);
 
                 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
                         return;
@@ -1037,20 +1027,20 @@ static void halbtc8192e2ant_set_coex_table(struct btc_coexist *btcoexist,
                                            u32 val0x6c0, u32 val0x6c4,
                                            u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 }
 
@@ -1059,30 +1049,30 @@ static void halbtc8192e2ant_coex_table(struct btc_coexist *btcoexist,
                                        u32 val0x6c0, u32 val0x6c4,
                                        u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, ",
-                  (force_exec ? "force to" : ""), val0x6c0);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
-                  val0x6c4, val0x6c8, val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, ",
+                    (force_exec ? "force to" : ""), val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
+                    val0x6c4, val0x6c8, val0x6cc);
         coex_dm->cur_val0x6c0 = val0x6c0;
         coex_dm->cur_val0x6c4 = val0x6c4;
         coex_dm->cur_val0x6c8 = val0x6c8;
         coex_dm->cur_val0x6cc = val0x6cc;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, ",
-                          coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n",
-                          coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x,\n",
-                          coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n",
-                          coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, ",
+                            coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n",
+                            coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x\n",
+                            coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n",
+                            coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
 
                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
@@ -1136,9 +1126,9 @@ static void halbtc8192e2ant_set_fw_ignore_wlanact(struct btc_coexist *btcoexist,
         if (enable)
                 h2c_parameter[0] |= BIT0; /* function enable */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex]set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex]set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 }
@@ -1146,18 +1136,18 @@ static void halbtc8192e2ant_set_fw_ignore_wlanact(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_IgnoreWlanAct(struct btc_coexist *btcoexist,
                                           bool force_exec, bool enable)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn Ignore WlanAct %s\n",
-                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn Ignore WlanAct %s\n",
+                    (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
         coex_dm->cur_ignore_wlan_act = enable;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPreIgnoreWlanAct = %d ",
-                          coex_dm->pre_ignore_wlan_act);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "bCurIgnoreWlanAct = %d!!\n",
-                          coex_dm->cur_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPreIgnoreWlanAct = %d ",
+                            coex_dm->pre_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "bCurIgnoreWlanAct = %d!!\n",
+                            coex_dm->cur_ignore_wlan_act);
 
                 if (coex_dm->pre_ignore_wlan_act ==
                     coex_dm->cur_ignore_wlan_act)
@@ -1185,11 +1175,11 @@ static void halbtc8192e2ant_SetFwPstdma(struct btc_coexist *btcoexist, u8 byte1,
         coex_dm->ps_tdma_para[3] = byte4;
         coex_dm->ps_tdma_para[4] = byte5;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
-                  h2c_parameter[0],
-                  h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
-                  h2c_parameter[3] << 8 | h2c_parameter[4]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
+                    h2c_parameter[0],
+                    h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
+                    h2c_parameter[3] << 8 | h2c_parameter[4]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 }
@@ -1213,20 +1203,20 @@ static void btc8192e2ant_sw_mec2(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_ps_tdma(struct btc_coexist *btcoexist,
                                     bool force_exec, bool turn_on, u8 type)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn %s PS TDMA, type=%d\n",
-                  (force_exec ? "force to" : ""),
-                  (turn_on ? "ON" : "OFF"), type);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn %s PS TDMA, type=%d\n",
+                    (force_exec ? "force to" : ""),
+                    (turn_on ? "ON" : "OFF"), type);
         coex_dm->cur_ps_tdma_on = turn_on;
         coex_dm->cur_ps_tdma = type;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
-                          coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
-                          coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
+                            coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
+                            coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
 
                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
@@ -1353,8 +1343,8 @@ static void halbtc8192e2ant_set_switch_sstype(struct btc_coexist *btcoexist,
         u8 mimops = BTC_MIMO_PS_DYNAMIC;
         u32 disra_mask = 0x0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], REAL set SS Type = %d\n", sstype);
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], REAL set SS Type = %d\n", sstype);
 
         disra_mask = halbtc8192e2ant_decidera_mask(btcoexist, sstype,
                                                    coex_dm->curra_masktype);
@@ -1386,9 +1376,9 @@ static void halbtc8192e2ant_set_switch_sstype(struct btc_coexist *btcoexist,
 static void halbtc8192e2ant_switch_sstype(struct btc_coexist *btcoexist,
                                           bool force_exec, u8 new_sstype)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], %s Switch SS Type = %d\n",
-                  (force_exec ? "force to" : ""), new_sstype);
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], %s Switch SS Type = %d\n",
+                    (force_exec ? "force to" : ""), new_sstype);
         coex_dm->cur_sstype = new_sstype;
 
         if (!force_exec) {
@@ -1469,8 +1459,8 @@ static bool halbtc8192e2ant_is_common_action(struct btc_coexist *btcoexist)
                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
                                    &low_pwr_disable);
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non-connected idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non-connected idle!!\n");
 
                 if ((BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
                      coex_dm->bt_status) ||
@@ -1506,8 +1496,8 @@ static bool halbtc8192e2ant_is_common_action(struct btc_coexist *btcoexist)
                                            BTC_SET_ACT_DISABLE_LOW_POWER,
                                            &low_pwr_disable);
 
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Wifi connected + BT non connected-idle!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Wifi connected + BT non connected-idle!!\n");
 
                         halbtc8192e2ant_switch_sstype(btcoexist,
                                                       NORMAL_EXEC, 2);
@@ -1534,8 +1524,8 @@ static bool halbtc8192e2ant_is_common_action(struct btc_coexist *btcoexist)
 
                         if (bt_hson)
                                 return false;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Wifi connected + BT connected-idle!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Wifi connected + BT connected-idle!!\n");
 
                         halbtc8192e2ant_switch_sstype(btcoexist,
                                                       NORMAL_EXEC, 2);
@@ -1560,12 +1550,12 @@ static bool halbtc8192e2ant_is_common_action(struct btc_coexist *btcoexist)
                                            &low_pwr_disable);
 
                         if (wifi_busy) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "Wifi Connected-Busy + BT Busy!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "Wifi Connected-Busy + BT Busy!!\n");
                                 common = false;
                         } else {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "Wifi Connected-Idle + BT Busy!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "Wifi Connected-Idle + BT Busy!!\n");
 
                                 halbtc8192e2ant_switch_sstype(btcoexist,
                                                               NORMAL_EXEC, 1);
@@ -1592,9 +1582,8 @@ static void btc8192e_int1(struct btc_coexist *btcoexist, bool tx_pause,
                           int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
 
                 if (coex_dm->cur_ps_tdma == 71) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
@@ -1689,9 +1678,8 @@ static void btc8192e_int1(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 71);
@@ -1795,9 +1783,8 @@ static void btc8192e_int2(struct btc_coexist *btcoexist, bool tx_pause,
                           int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 6);
@@ -1886,9 +1873,8 @@ static void btc8192e_int2(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 2);
@@ -1983,9 +1969,8 @@ static void btc8192e_int3(struct btc_coexist *btcoexist, bool tx_pause,
                           int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 7);
@@ -2074,9 +2059,8 @@ static void btc8192e_int3(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8192e2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 3);
@@ -2178,13 +2162,13 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
         int result;
         u8 retry_cnt = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], TdmaDurationAdjust()\n");
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], TdmaDurationAdjust()\n");
 
         if (!coex_dm->auto_tdma_adjust) {
                 coex_dm->auto_tdma_adjust = true;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], first run TdmaDurationAdjust()!!\n");
                 if (sco_hid) {
                         if (tx_pause) {
                                 if (max_interval == 1) {
@@ -2288,11 +2272,11 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
         } else {
                 /* accquire the BT TRx retry count from BT_Info byte2 */
                 retry_cnt = coex_sta->bt_retry_cnt;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], retry_cnt = %d\n", retry_cnt);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_cnt=%d\n",
-                          up, dn, m, n, wait_cnt);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], retry_cnt = %d\n", retry_cnt);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_cnt=%d\n",
+                            up, dn, m, n, wait_cnt);
                 result = 0;
                 wait_cnt++;
                 /* no retry in the last 2-second duration */
@@ -2309,9 +2293,8 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                                 up = 0;
                                 dn = 0;
                                 result = 1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex]Increase wifi duration!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex]Increase wifi duration!!\n");
                         }
                 } else if (retry_cnt <= 3) {
                         up--;
@@ -2334,9 +2317,8 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                                 dn = 0;
                                 wait_cnt = 0;
                                 result = -1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "Reduce wifi duration for retry<3\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "Reduce wifi duration for retry<3\n");
                         }
                 } else {
                         if (wait_cnt == 1)
@@ -2352,12 +2334,12 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                         dn = 0;
                         wait_cnt = 0;
                         result = -1;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "Decrease wifi duration for retryCounter>3!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "Decrease wifi duration for retryCounter>3!!\n");
                 }
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], max Interval = %d\n", max_interval);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], max Interval = %d\n", max_interval);
                 if (max_interval == 1)
                         btc8192e_int1(btcoexist, tx_pause, result);
                 else if (max_interval == 2)
@@ -2373,11 +2355,11 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
         if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
                 bool scan = false, link = false, roam = false;
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], PsTdma type dismatch!!!, ");
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "curPsTdma=%d, recordPsTdma=%d\n",
-                          coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], PsTdma type dismatch!!!, ");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "curPsTdma=%d, recordPsTdma=%d\n",
+                            coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
@@ -2388,9 +2370,8 @@ static void halbtc8192e2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                                                 true,
                                                 coex_dm->tdma_adj_type);
                 else
-                        BTC_PRINT(BTC_MSG_ALGORITHM,
-                                  ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
         }
 }
 
@@ -2594,8 +2575,8 @@ static void halbtc8192e2ant_action_a2dp(struct btc_coexist *btcoexist)
              btrssi_state == BTC_RSSI_STATE_STAY_LOW) &&
             (wifirssi_state == BTC_RSSI_STATE_LOW ||
              wifirssi_state == BTC_RSSI_STATE_STAY_LOW)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], A2dp, wifi/bt rssi both LOW!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], A2dp, wifi/bt rssi both LOW!!\n");
                 long_dist = true;
         }
         if (long_dist) {
@@ -3100,105 +3081,105 @@ static void halbtc8192e2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
 {
         u8 algorithm = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], RunCoexistMechanism()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], RunCoexistMechanism()===>\n");
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], return for Manual CTRL <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], return for Manual CTRL <===\n");
                 return;
         }
 
         if (coex_sta->under_ips) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is under IPS !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is under IPS !!!\n");
                 return;
         }
 
         algorithm = halbtc8192e2ant_action_algorithm(btcoexist);
         if (coex_sta->c2h_bt_inquiry_page &&
             (BT_8192E_2ANT_COEX_ALGO_PANHS != algorithm)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BT is under inquiry/page scan !!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BT is under inquiry/page scan !!\n");
                 halbtc8192e2ant_action_bt_inquiry(btcoexist);
                 return;
         }
 
         coex_dm->cur_algorithm = algorithm;
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
 
         if (halbtc8192e2ant_is_common_action(btcoexist)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Action 2-Ant common.\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Action 2-Ant common\n");
                 coex_dm->auto_tdma_adjust = false;
         } else {
                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex] preAlgorithm=%d, curAlgorithm=%d\n",
-                                  coex_dm->pre_algorithm,
-                                  coex_dm->cur_algorithm);
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex] preAlgorithm=%d, curAlgorithm=%d\n",
+                                    coex_dm->pre_algorithm,
+                                    coex_dm->cur_algorithm);
                         coex_dm->auto_tdma_adjust = false;
                 }
                 switch (coex_dm->cur_algorithm) {
                 case BT_8192E_2ANT_COEX_ALGO_SCO:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = SCO.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = SCO\n");
                         halbtc8192e2ant_action_sco(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_SCO_PAN:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = SCO+PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = SCO+PAN(EDR)\n");
                         halbtc8192e2ant_action_sco_pan(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = HID\n");
                         halbtc8192e2ant_action_hid(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = A2DP\n");
                         halbtc8192e2ant_action_a2dp(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_A2DP_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
                         halbtc8192e2ant_action_a2dp_pan_hs(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = PAN(EDR)\n");
                         halbtc8192e2ant_action_pan_edr(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = HS mode.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = HS mode\n");
                         halbtc8192e2ant_action_pan_hs(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_PANEDR_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = PAN+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = PAN+A2DP\n");
                         halbtc8192e2ant_action_pan_edr_a2dp(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_PANEDR_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = PAN(EDR)+HID\n");
                         halbtc8192e2ant_action_pan_edr_hid(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = HID+A2DP+PAN\n");
                         btc8192e2ant_action_hid_a2dp_pan_edr(btcoexist);
                         break;
                 case BT_8192E_2ANT_COEX_ALGO_HID_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = HID+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = HID+A2DP\n");
                         halbtc8192e2ant_action_hid_a2dp(btcoexist);
                         break;
                 default:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "Action 2-Ant, algorithm = unknown!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "Action 2-Ant, algorithm = unknown!!\n");
                         /* halbtc8192e2ant_coex_alloff(btcoexist); */
                         break;
                 }
@@ -3212,8 +3193,8 @@ static void halbtc8192e2ant_init_hwconfig(struct btc_coexist *btcoexist,
         u16 u16tmp = 0;
         u8 u8tmp = 0;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], 2Ant Init HW Config!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], 2Ant Init HW Config!!\n");
 
         if (backup) {
                 /* backup rf 0x1e value */
@@ -3296,8 +3277,8 @@ void ex_halbtc8192e2ant_init_hwconfig(struct btc_coexist *btcoexist)
 
 void ex_halbtc8192e2ant_init_coex_dm(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], Coex Mechanism Init!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], Coex Mechanism Init!!\n");
         halbtc8192e2ant_init_coex_dm(btcoexist);
 }
 
@@ -3525,13 +3506,13 @@ void ex_halbtc8192e2ant_display_coex_info(struct btc_coexist *btcoexist)
 void ex_halbtc8192e2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_IPS_ENTER == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS ENTER notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS ENTER notify\n");
                 coex_sta->under_ips = true;
                 halbtc8192e2ant_coex_alloff(btcoexist);
         } else if (BTC_IPS_LEAVE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS LEAVE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS LEAVE notify\n");
                 coex_sta->under_ips = false;
         }
 }
@@ -3539,12 +3520,12 @@ void ex_halbtc8192e2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_halbtc8192e2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_LPS_ENABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS ENABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS ENABLE notify\n");
                 coex_sta->under_lps = true;
         } else if (BTC_LPS_DISABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS DISABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS DISABLE notify\n");
                 coex_sta->under_lps = false;
         }
 }
@@ -3552,21 +3533,21 @@ void ex_halbtc8192e2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_halbtc8192e2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_SCAN_START == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN START notify\n");
         else if (BTC_SCAN_FINISH == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN FINISH notify\n");
 }
 
 void ex_halbtc8192e2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_ASSOCIATE_START == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT START notify\n");
         else if (BTC_ASSOCIATE_FINISH == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT FINISH notify\n");
 }
 
 void ex_halbtc8192e2ant_media_status_notify(struct btc_coexist *btcoexist,
@@ -3582,11 +3563,11 @@ void ex_halbtc8192e2ant_media_status_notify(struct btc_coexist *btcoexist,
                 return;
 
         if (BTC_MEDIA_CONNECT == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA connect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA connect notify\n");
         else
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA disconnect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA disconnect notify\n");
 
         /* only 2.4G we need to inform bt the chnl mask */
         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
@@ -3606,10 +3587,10 @@ void ex_halbtc8192e2ant_media_status_notify(struct btc_coexist *btcoexist,
         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x66 = 0x%x\n",
-                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
-                  h2c_parameter[2]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x66 = 0x%x\n",
+                    h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
+                    h2c_parameter[2]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 }
@@ -3618,8 +3599,8 @@ void ex_halbtc8192e2ant_special_packet_notify(struct btc_coexist *btcoexist,
                                               u8 type)
 {
         if (type == BTC_PACKET_DHCP)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], DHCP Packet notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], DHCP Packet notify\n");
 }
 
 void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
@@ -3637,19 +3618,19 @@ void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
                 rsp_source = BT_INFO_SRC_8192E_2ANT_WIFI_FW;
         coex_sta->bt_info_c2h_cnt[rsp_source]++;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Bt info[%d], length=%d, hex data = [",
-                  rsp_source, length);
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Bt info[%d], length=%d, hex data = [",
+                      rsp_source, length);
         for (i = 0; i < length; i++) {
                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
                 if (i == 1)
                         bt_info = tmp_buf[i];
                 if (i == length-1)
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x]\n", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x]\n", tmp_buf[i]);
                 else
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x, ", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x, ", tmp_buf[i]);
         }
 
         if (BT_INFO_SRC_8192E_2ANT_WIFI_FW != rsp_source) {
@@ -3666,8 +3647,8 @@ void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
                  * because bt is reset and loss of the info.
                  */
                 if ((coex_sta->bt_info_ext & BIT1)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "bit1, send wifi BW&Chnl to BT!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "bit1, send wifi BW&Chnl to BT!!\n");
                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
                                            &wifi_connected);
                         if (wifi_connected)
@@ -3683,8 +3664,8 @@ void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
                 if ((coex_sta->bt_info_ext & BIT3)) {
                         if (!btcoexist->manual_control &&
                             !btcoexist->stop_coex_dm) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "bit3, BT NOT ignore Wlan active!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "bit3, BT NOT ignore Wlan active!\n");
                                 halbtc8192e2ant_IgnoreWlanAct(btcoexist,
                                                               FORCE_EXEC,
                                                               false);
@@ -3742,25 +3723,25 @@ void ex_halbtc8192e2ant_bt_info_notify(struct btc_coexist *btcoexist,
 
         if (!(bt_info&BT_INFO_8192E_2ANT_B_CONNECTION)) {
                 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BT Non-Connected idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BT Non-Connected idle!!!\n");
         } else if (bt_info == BT_INFO_8192E_2ANT_B_CONNECTION) {
                 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], bt_infoNotify(), BT Connected-idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], bt_infoNotify(), BT Connected-idle!!!\n");
         } else if ((bt_info&BT_INFO_8192E_2ANT_B_SCO_ESCO) ||
                    (bt_info&BT_INFO_8192E_2ANT_B_SCO_BUSY)) {
                 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_SCO_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], bt_infoNotify(), BT SCO busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], bt_infoNotify(), BT SCO busy!!!\n");
         } else if (bt_info&BT_INFO_8192E_2ANT_B_ACL_BUSY) {
                 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_ACL_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], bt_infoNotify(), BT ACL busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], bt_infoNotify(), BT ACL busy!!!\n");
         } else {
                 coex_dm->bt_status = BT_8192E_2ANT_BT_STATUS_MAX;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex]bt_infoNotify(), BT Non-Defined state!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex]bt_infoNotify(), BT Non-Defined state!!!\n");
         }
 
         if ((BT_8192E_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
@@ -3788,7 +3769,7 @@ void ex_halbtc8192e2ant_stack_operation_notify(struct btc_coexist *btcoexist,
 
 void ex_halbtc8192e2ant_halt_notify(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
+        btc_iface_dbg(INTF_NOTIFY, "[BTCoex], Halt notify\n");
 
         halbtc8192e2ant_IgnoreWlanAct(btcoexist, FORCE_EXEC, true);
         ex_halbtc8192e2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
@@ -3801,29 +3782,29 @@ void ex_halbtc8192e2ant_periodical(struct btc_coexist *btcoexist)
         struct btc_board_info *board_info = &btcoexist->board_info;
         struct btc_stack_info *stack_info = &btcoexist->stack_info;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "=======================Periodical=======================\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "=======================Periodical=======================\n");
         if (dis_ver_info_cnt <= 5) {
                 dis_ver_info_cnt += 1;
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "************************************************\n");
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
-                          board_info->pg_ant_num, board_info->btdm_ant_num,
-                          board_info->btdm_ant_pos);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "BT stack/ hci ext ver = %s / %d\n",
-                          ((stack_info->profile_notified) ? "Yes" : "No"),
-                          stack_info->hci_version);
+                btc_iface_dbg(INTF_INIT,
+                              "************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
+                              board_info->pg_ant_num, board_info->btdm_ant_num,
+                              board_info->btdm_ant_pos);
+                btc_iface_dbg(INTF_INIT,
+                              "BT stack/ hci ext ver = %s / %d\n",
+                              ((stack_info->profile_notified) ? "Yes" : "No"),
+                              stack_info->hci_version);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
                                    &bt_patch_ver);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
-                          glcoex_ver_date_8192e_2ant, glcoex_ver_8192e_2ant,
-                          fw_ver, bt_patch_ver, bt_patch_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
+                              glcoex_ver_date_8192e_2ant, glcoex_ver_8192e_2ant,
+                              fw_ver, bt_patch_ver, bt_patch_ver);
+                btc_iface_dbg(INTF_INIT,
+                              "************************************************\n");
         }
 
 #if (BT_AUTO_REPORT_ONLY_8192E_2ANT == 0)
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b1ant.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b1ant.c
index 7e239d3cea26..16add42a62af 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b1ant.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b1ant.c
@@ -74,28 +74,28 @@ static u8 halbtc8723b1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "[BTCoex], BT Rssi thresh error!!\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "[BTCoex], BT Rssi thresh error!!\n");
                         return coex_sta->pre_bt_rssi_state;
                 }
 
@@ -104,12 +104,12 @@ static u8 halbtc8723b1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_bt_rssi_state ==
                                         BTC_RSSI_STATE_MEDIUM) ||
@@ -118,26 +118,26 @@ static u8 halbtc8723b1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh1 +
                                         BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Medium\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh1) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         }
@@ -165,32 +165,28 @@ static u8 halbtc8723b1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
-                                  "[BTCoex], wifi RSSI thresh error!!\n");
+                        btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                    "[BTCoex], wifi RSSI thresh error!!\n");
                         return coex_sta->pre_wifi_rssi_state[index];
                 }
 
@@ -201,14 +197,12 @@ static u8 halbtc8723b1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh +
                                          BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
                                                 BTC_RSSI_STATE_MEDIUM) ||
@@ -217,31 +211,26 @@ static u8 halbtc8723b1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh1 +
                                          BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Medium\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh1) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         }
@@ -435,9 +424,9 @@ static void halbtc8723b1ant_query_bt_info(struct btc_coexist *btcoexist)
 
         h2c_parameter[0] |= BIT0;       /* trigger*/
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 }
@@ -532,8 +521,8 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 
         if (!bt_link_info->bt_link_exist) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], No BT link exists!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], No BT link exists!!!\n");
                 return algorithm;
         }
 
@@ -548,27 +537,27 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
 
         if (numdiffprofile == 1) {
                 if (bt_link_info->sco_exist) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT Profile = SCO only\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT Profile = SCO only\n");
                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
                 } else {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = HID only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = HID only\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = A2DP only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = A2DP only\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = PAN(HS) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = PAN(HS) only\n");
                                         algorithm =
                                                 BT_8723B_1ANT_COEX_ALGO_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = PAN(EDR) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = PAN(EDR) only\n");
                                         algorithm =
                                                 BT_8723B_1ANT_COEX_ALGO_PANEDR;
                                 }
@@ -577,21 +566,21 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
         } else if (numdiffprofile == 2) {
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + HID\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + PAN(HS)\n");
                                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -599,32 +588,32 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
                 } else {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = HID + A2DP\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = HID + A2DP\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP;
                                 }
@@ -634,31 +623,31 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
                                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -668,13 +657,13 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 }
@@ -686,11 +675,11 @@ static u8 halbtc8723b1ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
                                         algorithm =
                                             BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -717,9 +706,9 @@ static void btc8723b1ant_set_sw_pen_tx_rate_adapt(struct btc_coexist *btcoexist,
                 h2c_parameter[5] = 0xf9;  /*MCS5 or OFDM36 */
         }
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
-                  (low_penalty_ra ? "ON!!" : "OFF!!"));
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set WiFi Low-Penalty Retry: %s",
+                    (low_penalty_ra ? "ON!!" : "OFF!!"));
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 }
@@ -743,20 +732,20 @@ static void halbtc8723b1ant_set_coex_table(struct btc_coexist *btcoexist,
                                            u32 val0x6c0, u32 val0x6c4,
                                            u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 }
 
@@ -765,10 +754,10 @@ static void halbtc8723b1ant_coex_table(struct btc_coexist *btcoexist,
                                        u32 val0x6c4, u32 val0x6c8,
                                        u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n",
-                  (force_exec ? "force to" : ""),
-                  val0x6c0, val0x6c4, val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n",
+                    (force_exec ? "force to" : ""),
+                    val0x6c0, val0x6c4, val0x6cc);
         coex_dm->cur_val0x6c0 = val0x6c0;
         coex_dm->cur_val0x6c4 = val0x6c4;
         coex_dm->cur_val0x6c8 = val0x6c8;
@@ -839,9 +828,9 @@ static void halbtc8723b1ant_SetFwIgnoreWlanAct(struct btc_coexist *btcoexist,
         if (enable)
                 h2c_parameter[0] |= BIT0;       /* function enable */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 }
@@ -849,16 +838,16 @@ static void halbtc8723b1ant_SetFwIgnoreWlanAct(struct btc_coexist *btcoexist,
 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
                                             bool force_exec, bool enable)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn Ignore WlanAct %s\n",
-                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn Ignore WlanAct %s\n",
+                    (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
         coex_dm->cur_ignore_wlan_act = enable;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
-                          coex_dm->pre_ignore_wlan_act,
-                          coex_dm->cur_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
+                            coex_dm->pre_ignore_wlan_act,
+                            coex_dm->cur_ignore_wlan_act);
 
                 if (coex_dm->pre_ignore_wlan_act ==
                     coex_dm->cur_ignore_wlan_act)
@@ -882,8 +871,8 @@ static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
 
         if (ap_enable) {
                 if ((byte1 & BIT4) && !(byte1 & BIT5)) {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "[BTCoex], FW for 1Ant AP mode\n");
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "[BTCoex], FW for 1Ant AP mode\n");
                         real_byte1 &= ~BIT4;
                         real_byte1 |= BIT5;
 
@@ -904,13 +893,13 @@ static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist,
         coex_dm->ps_tdma_para[3] = byte4;
         coex_dm->ps_tdma_para[4] = real_byte5;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
-                  h2c_parameter[0],
-                  h2c_parameter[1] << 24 |
-                  h2c_parameter[2] << 16 |
-                  h2c_parameter[3] << 8 |
-                  h2c_parameter[4]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
+                    h2c_parameter[0],
+                    h2c_parameter[1] << 24 |
+                    h2c_parameter[2] << 16 |
+                    h2c_parameter[3] << 8 |
+                    h2c_parameter[4]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 }
@@ -929,22 +918,22 @@ static void halbtc8723b1ant_LpsRpwm(struct btc_coexist *btcoexist,
                                     bool force_exec,
                                     u8 lps_val, u8 rpwm_val)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
-                  (force_exec ? "force to" : ""), lps_val, rpwm_val);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
+                    (force_exec ? "force to" : ""), lps_val, rpwm_val);
         coex_dm->cur_lps = lps_val;
         coex_dm->cur_rpwm = rpwm_val;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
-                          coex_dm->cur_lps, coex_dm->cur_rpwm);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n",
+                            coex_dm->cur_lps, coex_dm->cur_rpwm);
 
                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
-                                  coex_dm->pre_rpwm, coex_dm->cur_rpwm);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n",
+                                    coex_dm->pre_rpwm, coex_dm->cur_rpwm);
 
                         return;
                 }
@@ -958,8 +947,8 @@ static void halbtc8723b1ant_LpsRpwm(struct btc_coexist *btcoexist,
 static void halbtc8723b1ant_sw_mechanism(struct btc_coexist *btcoexist,
                                          bool low_penalty_ra)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
 
         halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
 }
@@ -1174,13 +1163,13 @@ static void halbtc8723b1ant_ps_tdma(struct btc_coexist *btcoexist,
 
         if (!force_exec) {
                 if (coex_dm->cur_ps_tdma_on)
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], ******** TDMA(on, %d) *********\n",
-                                  coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], ******** TDMA(on, %d) *********\n",
+                                    coex_dm->cur_ps_tdma);
                 else
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], ******** TDMA(off, %d) ********\n",
-                                  coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], ******** TDMA(off, %d) ********\n",
+                                    coex_dm->cur_ps_tdma);
 
                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
@@ -1394,45 +1383,45 @@ static bool halbtc8723b1ant_is_common_action(struct btc_coexist *btcoexist)
 
         if (!wifi_connected &&
             BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
                 commom = true;
         } else if (wifi_connected &&
                    (BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi connected + BT non connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi connected + BT non connected-idle!!\n");
                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
                 commom = true;
         } else if (!wifi_connected &&
                    (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE ==
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
                 commom = true;
         } else if (wifi_connected &&
                    (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE ==
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi connected + BT connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi connected + BT connected-idle!!\n");
                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
                 commom = true;
         } else if (!wifi_connected &&
                    (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE !=
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          ("[BTCoex], Wifi non connected-idle + BT Busy!!\n"));
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
                 halbtc8723b1ant_sw_mechanism(btcoexist, false);
                 commom = true;
         } else {
                 if (wifi_busy)
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
                 else
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
 
                 commom = false;
         }
@@ -1451,8 +1440,8 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
         u8 retry_count = 0, bt_info_ext;
         bool wifi_busy = false;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], TdmaDurationAdjustForAcl()\n");
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], TdmaDurationAdjustForAcl()\n");
 
         if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY == wifi_status)
                 wifi_busy = true;
@@ -1481,8 +1470,8 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
 
         if (!coex_dm->auto_tdma_adjust) {
                 coex_dm->auto_tdma_adjust = true;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], first run TdmaDurationAdjust()!!\n");
 
                 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
                 coex_dm->tdma_adj_type = 2;
@@ -1513,9 +1502,8 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
                                 up = 0;
                                 dn = 0;
                                 result = 1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Increase wifi duration!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Increase wifi duration!!\n");
                         }
                 } else if (retry_count <= 3) {
                         up--;
@@ -1538,9 +1526,8 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
                                 dn = 0;
                                 wait_count = 0;
                                 result = -1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
                         }
                 } else {
                         if (wait_count == 1)
@@ -1556,8 +1543,8 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
                         dn = 0;
                         wait_count = 0;
                         result = -1;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
                 }
 
                 if (result == -1) {
@@ -1602,9 +1589,9 @@ static void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist,
                         }
                 } else {          /*no change */
                         /*if busy / idle change */
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex],********* TDMA(on, %d) ********\n",
-                                  coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex],********* TDMA(on, %d) ********\n",
+                                    coex_dm->cur_ps_tdma);
                 }
 
                 if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 &&
@@ -2010,15 +1997,15 @@ static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist *btcoexist)
         bool scan = false, link = false, roam = false;
         bool under_4way = false, ap_enable = false;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], CoexForWifiConnect()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], CoexForWifiConnect()===>\n");
 
         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
                            &under_4way);
         if (under_4way) {
                 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
                 return;
         }
 
@@ -2032,8 +2019,8 @@ static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist *btcoexist)
                 else
                         halbtc8723b1ant_action_wifi_connected_special_packet(
                                                                      btcoexist);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
                 return;
         }
 
@@ -2102,58 +2089,58 @@ static void btc8723b1ant_run_sw_coex_mech(struct btc_coexist *btcoexist)
         if (!halbtc8723b1ant_is_common_action(btcoexist)) {
                 switch (coex_dm->cur_algorithm) {
                 case BT_8723B_1ANT_COEX_ALGO_SCO:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = SCO.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = SCO\n");
                         halbtc8723b1ant_action_sco(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID\n");
                         halbtc8723b1ant_action_hid(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = A2DP\n");
                         halbtc8723b1ant_action_a2dp(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = A2DP+PAN(HS).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
                         halbtc8723b1ant_action_a2dp_pan_hs(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN(EDR)\n");
                         halbtc8723b1ant_action_pan_edr(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HS mode.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HS mode\n");
                         halbtc8723b1ant_action_pan_hs(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN+A2DP\n");
                         halbtc8723b1ant_action_pan_edr_a2dp(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN(EDR)+HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN(EDR)+HID\n");
                         halbtc8723b1ant_action_pan_edr_hid(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID+A2DP+PAN.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID+A2DP+PAN\n");
                         btc8723b1ant_action_hid_a2dp_pan_edr(btcoexist);
                         break;
                 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID+A2DP\n");
                         halbtc8723b1ant_action_hid_a2dp(btcoexist);
                         break;
                 default:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = coexist All Off!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = coexist All Off!!\n");
                         break;
                 }
                 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
@@ -2171,24 +2158,24 @@ static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         u32 wifi_link_status = 0;
         u32 num_of_wifi_link = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], RunCoexistMechanism()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], RunCoexistMechanism()===>\n");
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
                 return;
         }
 
         if (btcoexist->stop_coex_dm) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
                 return;
         }
 
         if (coex_sta->under_ips) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is under IPS !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is under IPS !!!\n");
                 return;
         }
 
@@ -2267,8 +2254,8 @@ static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         if (!wifi_connected) {
                 bool scan = false, link = false, roam = false;
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is non connected-idle !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is non connected-idle !!!\n");
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
@@ -2305,8 +2292,8 @@ static void halbtc8723b1ant_init_hw_config(struct btc_coexist *btcoexist,
         u8 u8tmp = 0;
         u32 cnt_bt_cal_chk = 0;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], 1Ant Init HW Config!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], 1Ant Init HW Config!!\n");
 
         if (backup) {/* backup rf 0x1e value */
                 coex_dm->backup_arfr_cnt1 =
@@ -2333,14 +2320,14 @@ static void halbtc8723b1ant_init_hw_config(struct btc_coexist *btcoexist,
                 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x49d);
                 cnt_bt_cal_chk++;
                 if (u32tmp & BIT0) {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                                  "[BTCoex], ########### BT calibration(cnt=%d) ###########\n",
-                                  cnt_bt_cal_chk);
+                        btc_iface_dbg(INTF_INIT,
+                                      "[BTCoex], ########### BT calibration(cnt=%d) ###########\n",
+                                      cnt_bt_cal_chk);
                         mdelay(50);
                 } else {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                                  "[BTCoex], ********** BT NOT calibration (cnt=%d)**********\n",
-                                  cnt_bt_cal_chk);
+                        btc_iface_dbg(INTF_INIT,
+                                      "[BTCoex], ********** BT NOT calibration (cnt=%d)**********\n",
+                                      cnt_bt_cal_chk);
                         break;
                 }
         }
@@ -2383,8 +2370,8 @@ void ex_halbtc8723b1ant_init_hwconfig(struct btc_coexist *btcoexist)
 
 void ex_halbtc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], Coex Mechanism Init!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], Coex Mechanism Init!!\n");
 
         btcoexist->stop_coex_dm = false;
 
@@ -2677,8 +2664,8 @@ void ex_halbtc8723b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
                 return;
 
         if (BTC_IPS_ENTER == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS ENTER notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS ENTER notify\n");
                 coex_sta->under_ips = true;
 
                 halbtc8723b1ant_SetAntPath(btcoexist, BTC_ANT_PATH_BT,
@@ -2689,8 +2676,8 @@ void ex_halbtc8723b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
                                                      NORMAL_EXEC, 0);
                 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist);
         } else if (BTC_IPS_LEAVE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS LEAVE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS LEAVE notify\n");
                 coex_sta->under_ips = false;
 
                 halbtc8723b1ant_init_hw_config(btcoexist, false);
@@ -2705,12 +2692,12 @@ void ex_halbtc8723b1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
                 return;
 
         if (BTC_LPS_ENABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS ENABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS ENABLE notify\n");
                 coex_sta->under_lps = true;
         } else if (BTC_LPS_DISABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS DISABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS DISABLE notify\n");
                 coex_sta->under_lps = false;
         }
 }
@@ -2753,15 +2740,15 @@ void ex_halbtc8723b1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
         }
 
         if (BTC_SCAN_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN START notify\n");
                 if (!wifi_connected)    /* non-connected scan */
                         btc8723b1ant_action_wifi_not_conn_scan(btcoexist);
                 else    /* wifi is connected */
                         btc8723b1ant_action_wifi_conn_scan(btcoexist);
         } else if (BTC_SCAN_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN FINISH notify\n");
                 if (!wifi_connected)    /* non-connected scan */
                         btc8723b1ant_action_wifi_not_conn(btcoexist);
                 else
@@ -2802,12 +2789,12 @@ void ex_halbtc8723b1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
         }
 
         if (BTC_ASSOCIATE_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT START notify\n");
                 btc8723b1ant_act_wifi_not_conn_asso_auth(btcoexist);
         } else if (BTC_ASSOCIATE_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT FINISH notify\n");
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
                                    &wifi_connected);
@@ -2830,11 +2817,11 @@ void ex_halbtc8723b1ant_media_status_notify(struct btc_coexist *btcoexist,
                 return;
 
         if (BTC_MEDIA_CONNECT == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA connect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA connect notify\n");
         else
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA disconnect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA disconnect notify\n");
 
         /* only 2.4G we need to inform bt the chnl mask */
         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
@@ -2855,10 +2842,10 @@ void ex_halbtc8723b1ant_media_status_notify(struct btc_coexist *btcoexist,
         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x66 = 0x%x\n",
-                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
-                  h2c_parameter[2]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x66 = 0x%x\n",
+                    h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
+                    h2c_parameter[2]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 }
@@ -2900,8 +2887,8 @@ void ex_halbtc8723b1ant_special_packet_notify(struct btc_coexist *btcoexist,
 
         if (BTC_PACKET_DHCP == type ||
             BTC_PACKET_EAPOL == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], special Packet(%d) notify\n", type);
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], special Packet(%d) notify\n", type);
                 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist);
         }
 }
@@ -2921,19 +2908,19 @@ void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
         coex_sta->bt_info_c2h_cnt[rsp_source]++;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Bt info[%d], length=%d, hex data = [",
-                  rsp_source, length);
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Bt info[%d], length=%d, hex data = [",
+                      rsp_source, length);
         for (i = 0; i < length; i++) {
                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
                 if (i == 1)
                         bt_info = tmp_buf[i];
                 if (i == length - 1)
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x]\n", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x]\n", tmp_buf[i]);
                 else
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x, ", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x, ", tmp_buf[i]);
         }
 
         if (BT_INFO_SRC_8723B_1ANT_WIFI_FW != rsp_source) {
@@ -2950,8 +2937,8 @@ void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
                  * because bt is reset and loss of the info.
                  */
                 if (coex_sta->bt_info_ext & BIT1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
                                            &wifi_connected);
                         if (wifi_connected)
@@ -2965,8 +2952,8 @@ void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 if (coex_sta->bt_info_ext & BIT3) {
                         if (!btcoexist->manual_control &&
                             !btcoexist->stop_coex_dm) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n");
                                 halbtc8723b1ant_ignore_wlan_act(btcoexist,
                                                                 FORCE_EXEC,
                                                                 false);
@@ -3021,30 +3008,30 @@ void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
 
         if (!(bt_info&BT_INFO_8723B_1ANT_B_CONNECTION)) {
                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n");
         /* connection exists but no busy */
         } else if (bt_info == BT_INFO_8723B_1ANT_B_CONNECTION) {
                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
         } else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
                 (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY)) {
                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
         } else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
                 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
                         coex_dm->auto_tdma_adjust = false;
 
                 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
         } else {
                 coex_dm->bt_status =
                         BT_8723B_1ANT_BT_STATUS_MAX;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n");
         }
 
         if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
@@ -3060,7 +3047,7 @@ void ex_halbtc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist,
 
 void ex_halbtc8723b1ant_halt_notify(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
+        btc_iface_dbg(INTF_NOTIFY, "[BTCoex], Halt notify\n");
 
         btcoexist->stop_coex_dm = true;
 
@@ -3078,11 +3065,11 @@ void ex_halbtc8723b1ant_halt_notify(struct btc_coexist *btcoexist)
 
 void ex_halbtc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Pnp notify\n");
+        btc_iface_dbg(INTF_NOTIFY, "[BTCoex], Pnp notify\n");
 
         if (BTC_WIFI_PNP_SLEEP == pnp_state) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], Pnp notify to SLEEP\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], Pnp notify to SLEEP\n");
                 btcoexist->stop_coex_dm = true;
                 halbtc8723b1ant_SetAntPath(btcoexist, BTC_ANT_PATH_BT, false,
                                            true);
@@ -3092,8 +3079,8 @@ void ex_halbtc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
                 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
                 halbtc8723b1ant_wifi_off_hw_cfg(btcoexist);
         } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], Pnp notify to WAKE UP\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], Pnp notify to WAKE UP\n");
                 btcoexist->stop_coex_dm = false;
                 halbtc8723b1ant_init_hw_config(btcoexist, false);
                 halbtc8723b1ant_init_coex_dm(btcoexist);
@@ -3103,8 +3090,8 @@ void ex_halbtc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
 
 void ex_halbtc8723b1ant_coex_dm_reset(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], *****************Coex DM Reset****************\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], *****************Coex DM Reset****************\n");
 
         halbtc8723b1ant_init_hw_config(btcoexist, false);
         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
@@ -3119,31 +3106,31 @@ void ex_halbtc8723b1ant_periodical(struct btc_coexist *btcoexist)
         static u8 dis_ver_info_cnt;
         u32 fw_ver = 0, bt_patch_ver = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], ==========================Periodical===========================\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], ==========================Periodical===========================\n");
 
         if (dis_ver_info_cnt <= 5) {
                 dis_ver_info_cnt += 1;
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
-                          board_info->pg_ant_num, board_info->btdm_ant_num,
-                          board_info->btdm_ant_pos);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
-                          ((stack_info->profile_notified) ? "Yes" : "No"),
-                          stack_info->hci_version);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
+                              board_info->pg_ant_num, board_info->btdm_ant_num,
+                              board_info->btdm_ant_pos);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
+                              stack_info->profile_notified ? "Yes" : "No",
+                              stack_info->hci_version);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
                                    &bt_patch_ver);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
-                          glcoex_ver_date_8723b_1ant,
-                          glcoex_ver_8723b_1ant, fw_ver,
-                          bt_patch_ver, bt_patch_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
+                              glcoex_ver_date_8723b_1ant,
+                              glcoex_ver_8723b_1ant, fw_ver,
+                              bt_patch_ver, bt_patch_ver);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
         }
 
 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b2ant.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b2ant.c
index c43ab59a690a..5f488ecaef70 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b2ant.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8723b2ant.c
@@ -72,32 +72,28 @@ static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh +
                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "[BTCoex], BT Rssi thresh error!!\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "[BTCoex], BT Rssi thresh error!!\n");
                         return coex_sta->pre_bt_rssi_state;
                 }
 
@@ -106,14 +102,12 @@ static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh +
                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_bt_rssi_state ==
                                                 BTC_RSSI_STATE_MEDIUM) ||
@@ -122,31 +116,26 @@ static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= rssi_thresh1 +
                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "stay at Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Medium\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh1) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state "
-                                          "stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         }
@@ -173,36 +162,28 @@ static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh +
                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
-                                  "[BTCoex], wifi RSSI thresh error!!\n");
+                        btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                    "[BTCoex], wifi RSSI thresh error!!\n");
                         return coex_sta->pre_wifi_rssi_state[index];
                 }
 
@@ -213,16 +194,12 @@ static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
                                                 BTC_RSSI_STATE_MEDIUM) ||
@@ -231,36 +208,26 @@ static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= rssi_thresh1 +
                                          BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "stay at Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Medium\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh1) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state "
-                                          "stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         }
@@ -292,12 +259,12 @@ static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
         coex_sta->low_priority_tx = reg_lp_tx;
         coex_sta->low_priority_rx = reg_lp_rx;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
-                  reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
-                  reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
+                    reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
+                    reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 
         /* reset counter */
         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
@@ -311,9 +278,9 @@ static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
 
         h2c_parameter[0] |= BIT0;       /* trigger */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 }
@@ -427,8 +394,8 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 
         if (!bt_link_info->bt_link_exist) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], No BT link exists!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], No BT link exists!!!\n");
                 return algorithm;
         }
 
@@ -443,27 +410,27 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
 
         if (num_of_diff_profile == 1) {
                 if (bt_link_info->sco_exist) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], SCO only\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], SCO only\n");
                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
                 } else {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], HID only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], HID only\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], A2DP only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], A2DP only\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], PAN(HS) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], PAN(HS) only\n");
                                         algorithm =
                                                 BT_8723B_2ANT_COEX_ALGO_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], PAN(EDR) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], PAN(EDR) only\n");
                                         algorithm =
                                                 BT_8723B_2ANT_COEX_ALGO_PANEDR;
                                 }
@@ -472,21 +439,21 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
         } else if (num_of_diff_profile == 2) {
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + HID\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + A2DP ==> SCO\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + A2DP ==> SCO\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + PAN(HS)\n");
                                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -494,31 +461,31 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
                 } else {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], HID + A2DP\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], HID + A2DP\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + PAN(HS)\n");
                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex],A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex],A2DP + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
                                 }
@@ -528,37 +495,32 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + HID + A2DP"
-                                          " ==> HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + HID + A2DP ==> HID\n");
                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + "
-                                                  "PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + "
-                                                  "PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + PAN(EDR)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + A2DP + "
-                                                  "PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + A2DP + "
-                                                  "PAN(EDR) ==> HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -568,15 +530,13 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + A2DP + "
-                                                  "PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + A2DP + PAN(HS)\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + A2DP + "
-                                                  "PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + A2DP + PAN(EDR)\n");
                                         algorithm =
                                         BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 }
@@ -588,13 +548,11 @@ static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], Error!!! SCO + HID"
-                                                  " + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + A2DP +"
-                                                  " PAN(EDR)==>PAN(EDR)+HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
                                         algorithm =
                                             BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
@@ -624,17 +582,15 @@ static bool btc8723b_need_dec_pwr(struct btc_coexist *btcoexist)
         if (wifi_connected) {
                 if (bt_hs_on) {
                         if (bt_hs_rssi > 37) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                                          "[BTCoex], Need to decrease bt "
-                                          "power for HS mode!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW,
+                                            "[BTCoex], Need to decrease bt power for HS mode!!\n");
                                 ret = true;
                         }
                 } else {
                         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
                             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                                          "[BTCoex], Need to decrease bt "
-                                          "power for Wifi is connected!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW,
+                                            "[BTCoex], Need to decrease bt power for Wifi is connected!!\n");
                                 ret = true;
                         }
                 }
@@ -653,10 +609,10 @@ static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
          */
         h2c_parameter[0] = dac_swing_lvl;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 }
@@ -671,9 +627,9 @@ static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
         if (dec_bt_pwr)
                 h2c_parameter[0] |= BIT1;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n",
-                  (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n",
+                    (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 }
@@ -681,15 +637,15 @@ static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
                                     bool force_exec, bool dec_bt_pwr)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s Dec BT power = %s\n",
-                  (force_exec ? "force to" : ""), (dec_bt_pwr ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s Dec BT power = %s\n",
+                    force_exec ? "force to" : "", dec_bt_pwr ? "ON" : "OFF");
         coex_dm->cur_dec_bt_pwr = dec_bt_pwr;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
-                          coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
+                            coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
 
                 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
                         return;
@@ -702,17 +658,16 @@ static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
                                           bool force_exec, u8 fw_dac_swing_lvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s set FW Dac Swing level = %d\n",
-                  (force_exec ? "force to" : ""), fw_dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s set FW Dac Swing level = %d\n",
+                    (force_exec ? "force to" : ""), fw_dac_swing_lvl);
         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], preFwDacSwingLvl=%d, "
-                          "curFwDacSwingLvl=%d\n",
-                          coex_dm->pre_fw_dac_swing_lvl,
-                          coex_dm->cur_fw_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
+                            coex_dm->pre_fw_dac_swing_lvl,
+                            coex_dm->cur_fw_dac_swing_lvl);
 
                 if (coex_dm->pre_fw_dac_swing_lvl ==
                    coex_dm->cur_fw_dac_swing_lvl)
@@ -729,16 +684,16 @@ static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 {
         if (rx_rf_shrink_on) {
                 /* Shrink RF Rx LPF corner */
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Shrink RF Rx LPF corner!!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Shrink RF Rx LPF corner!!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
                                           0xfffff, 0xffffc);
         } else {
                 /* Resume RF Rx LPF corner */
                 /* After initialized, we can use coex_dm->btRf0x1eBackup */
                 if (btcoexist->initilized) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                                  "[BTCoex], Resume RF Rx LPF corner!!\n");
+                        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                                    "[BTCoex], Resume RF Rx LPF corner!!\n");
                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
                                                   0xfffff,
                                                   coex_dm->bt_rf0x1e_backup);
@@ -749,18 +704,17 @@ static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 static void btc8723b2ant_rf_shrink(struct btc_coexist *btcoexist,
                                    bool force_exec, bool rx_rf_shrink_on)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn Rx RF Shrink = %s\n",
-                  (force_exec ? "force to" : ""), (rx_rf_shrink_on ?
-                  "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn Rx RF Shrink = %s\n",
+                    (force_exec ? "force to" : ""), (rx_rf_shrink_on ?
+                                                     "ON" : "OFF"));
         coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreRfRxLpfShrink=%d, "
-                          "bCurRfRxLpfShrink=%d\n",
-                          coex_dm->pre_rf_rx_lpf_shrink,
-                          coex_dm->cur_rf_rx_lpf_shrink);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreRfRxLpfShrink=%d, bCurRfRxLpfShrink=%d\n",
+                            coex_dm->pre_rf_rx_lpf_shrink,
+                            coex_dm->cur_rf_rx_lpf_shrink);
 
                 if (coex_dm->pre_rf_rx_lpf_shrink ==
                     coex_dm->cur_rf_rx_lpf_shrink)
@@ -788,9 +742,9 @@ static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
                 h2c_parameter[5] = 0xf9;  /*MCS5 or OFDM36*/
         }
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
-                  (low_penalty_ra ? "ON!!" : "OFF!!"));
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set WiFi Low-Penalty Retry: %s",
+                    (low_penalty_ra ? "ON!!" : "OFF!!"));
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 }
@@ -799,18 +753,17 @@ static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
                                         bool force_exec, bool low_penalty_ra)
 {
         /*return; */
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn LowPenaltyRA = %s\n",
-                  (force_exec ? "force to" : ""), (low_penalty_ra ?
-                  "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn LowPenaltyRA = %s\n",
+                    (force_exec ? "force to" : ""), (low_penalty_ra ?
+                                                     "ON" : "OFF"));
         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreLowPenaltyRa=%d, "
-                          "bCurLowPenaltyRa=%d\n",
-                          coex_dm->pre_low_penalty_ra,
-                          coex_dm->cur_low_penalty_ra);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
+                            coex_dm->pre_low_penalty_ra,
+                            coex_dm->cur_low_penalty_ra);
 
                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
                         return;
@@ -824,8 +777,8 @@ static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
                                            u32 level)
 {
         u8 val = (u8) level;
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], Write SwDacSwing = 0x%x\n", level);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], Write SwDacSwing = 0x%x\n", level);
         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
 }
 
@@ -843,20 +796,20 @@ static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
                                    bool force_exec, bool dac_swing_on,
                                    u32 dac_swing_lvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
-                  (force_exec ? "force to" : ""),
-                  (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
+                    (force_exec ? "force to" : ""),
+                    (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
         coex_dm->cur_dac_swing_on = dac_swing_on;
         coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x,"
-                          " bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
-                          coex_dm->pre_dac_swing_on, coex_dm->pre_dac_swing_lvl,
-                          coex_dm->cur_dac_swing_on,
-                          coex_dm->cur_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
+                            coex_dm->pre_dac_swing_on,
+                            coex_dm->pre_dac_swing_lvl,
+                            coex_dm->cur_dac_swing_on,
+                            coex_dm->cur_dac_swing_lvl);
 
                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
                     (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
@@ -877,8 +830,8 @@ static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
 
         /*  BB AGC Gain Table */
         if (agc_table_en) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB Agc Table On!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB Agc Table On!\n");
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6e1A0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6d1B0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6c1C0001);
@@ -887,8 +840,8 @@ static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x691F0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x68200001);
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB Agc Table Off!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB Agc Table Off!\n");
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
                 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
@@ -901,15 +854,15 @@ static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
         /* RF Gain */
         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
         if (agc_table_en) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Agc Table On!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Agc Table On!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
                                           0xfffff, 0x38fff);
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
                                           0xfffff, 0x38ffe);
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Agc Table Off!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Agc Table Off!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
                                           0xfffff, 0x380c3);
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
@@ -920,15 +873,15 @@ static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
 
         if (agc_table_en) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Agc Table On!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Agc Table On!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
                                           0xfffff, 0x38fff);
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
                                           0xfffff, 0x38ffe);
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Agc Table Off!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Agc Table Off!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
                                           0xfffff, 0x380c3);
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
@@ -946,16 +899,17 @@ static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
 static void btc8723b2ant_agc_table(struct btc_coexist *btcoexist,
                                    bool force_exec, bool agc_table_en)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s %s Agc Table\n",
-                  (force_exec ? "force to" : ""),
-                  (agc_table_en ? "Enable" : "Disable"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s %s Agc Table\n",
+                    (force_exec ? "force to" : ""),
+                    (agc_table_en ? "Enable" : "Disable"));
         coex_dm->cur_agc_table_en = agc_table_en;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
-                          coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
+                            coex_dm->pre_agc_table_en,
+                            coex_dm->cur_agc_table_en);
 
                 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
                         return;
@@ -969,20 +923,20 @@ static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
                                         u32 val0x6c0, u32 val0x6c4,
                                         u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 }
 
@@ -991,29 +945,24 @@ static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
                                     u32 val0x6c4, u32 val0x6c8,
                                     u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s write Coex Table 0x6c0=0x%x,"
-                  " 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
-                  (force_exec ? "force to" : ""), val0x6c0,
-                  val0x6c4, val0x6c8, val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
+                    force_exec ? "force to" : "",
+                    val0x6c0, val0x6c4, val0x6c8, val0x6cc);
         coex_dm->cur_val0x6c0 = val0x6c0;
         coex_dm->cur_val0x6c4 = val0x6c4;
         coex_dm->cur_val0x6c8 = val0x6c8;
         coex_dm->cur_val0x6cc = val0x6cc;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], preVal0x6c0=0x%x, "
-                          "preVal0x6c4=0x%x, preVal0x6c8=0x%x, "
-                          "preVal0x6cc=0x%x !!\n",
-                          coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
-                          coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], curVal0x6c0=0x%x, "
-                          "curVal0x6c4=0x%x, curVal0x6c8=0x%x, "
-                          "curVal0x6cc=0x%x !!\n",
-                          coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
-                          coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], preVal0x6c0=0x%x, preVal0x6c4=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
+                            coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
+                            coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], curVal0x6c0=0x%x, curVal0x6c4=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
+                            coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
+                            coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
 
                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
@@ -1099,9 +1048,9 @@ static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
         if (enable)
                 h2c_parameter[0] |= BIT0;/* function enable*/
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set FW for BT Ignore Wlan_Act, "
-                  "FW write 0x63=0x%x\n", h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63=0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 }
@@ -1109,17 +1058,16 @@ static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
                                          bool force_exec, bool enable)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn Ignore WlanAct %s\n",
-                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn Ignore WlanAct %s\n",
+                    (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
         coex_dm->cur_ignore_wlan_act = enable;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPreIgnoreWlanAct = %d, "
-                          "bCurIgnoreWlanAct = %d!!\n",
-                          coex_dm->pre_ignore_wlan_act,
-                          coex_dm->cur_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
+                            coex_dm->pre_ignore_wlan_act,
+                            coex_dm->cur_ignore_wlan_act);
 
                 if (coex_dm->pre_ignore_wlan_act ==
                     coex_dm->cur_ignore_wlan_act)
@@ -1147,11 +1095,11 @@ static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
         coex_dm->ps_tdma_para[3] = byte4;
         coex_dm->ps_tdma_para[4] = byte5;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
-                  h2c_parameter[0],
-                  h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
-                  h2c_parameter[3] << 8 | h2c_parameter[4]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
+                    h2c_parameter[0],
+                    h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
+                    h2c_parameter[3] << 8 | h2c_parameter[4]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 }
@@ -1203,7 +1151,6 @@ static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
 
                 /* Force GNT_BT to low */
                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
-                btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
 
                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
                         /* tell firmware "no antenna inverse" */
@@ -1211,19 +1158,25 @@ static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
                         h2c_parameter[1] = 1;  /* ext switch type */
                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
                                                 h2c_parameter);
+                        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
                 } else {
                         /* tell firmware "antenna inverse" */
                         h2c_parameter[0] = 1;
                         h2c_parameter[1] = 1;  /* ext switch type */
                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
                                                 h2c_parameter);
+                        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
                 }
         }
 
         /* ext switch setting */
         if (use_ext_switch) {
                 /* fixed internal switch S1->WiFi, S0->BT */
-                btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
+                if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
+                        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
+                else
+                        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
+
                 switch (antpos_type) {
                 case BTC_ANT_WIFI_AT_MAIN:
                         /* ext switch main at wifi */
@@ -1255,20 +1208,20 @@ static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
                                  bool turn_on, u8 type)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn %s PS TDMA, type=%d\n",
-                  (force_exec ? "force to" : ""),
-                  (turn_on ? "ON" : "OFF"), type);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn %s PS TDMA, type=%d\n",
+                    (force_exec ? "force to" : ""),
+                    (turn_on ? "ON" : "OFF"), type);
         coex_dm->cur_ps_tdma_on = turn_on;
         coex_dm->cur_ps_tdma = type;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
-                          coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
-                          coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
+                            coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
+                            coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
 
                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
@@ -1466,8 +1419,8 @@ static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
                                    &low_pwr_disable);
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non-connected idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non-connected idle!!\n");
 
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
                                           0x0);
@@ -1490,9 +1443,8 @@ static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
                                            BTC_SET_ACT_DISABLE_LOW_POWER,
                                            &low_pwr_disable);
 
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi connected + "
-                                  "BT non connected-idle!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi connected + BT non connected-idle!!\n");
 
                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
                                                   0xfffff, 0x0);
@@ -1518,9 +1470,8 @@ static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
 
                         if (bt_hs_on)
                                 return false;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi connected + "
-                                  "BT connected-idle!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi connected + BT connected-idle!!\n");
 
                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
                                                   0xfffff, 0x0);
@@ -1544,17 +1495,15 @@ static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
                                            &low_pwr_disable);
 
                         if (wifi_busy) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], Wifi Connected-Busy + "
-                                          "BT Busy!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
                                 common = false;
                         } else {
                                 if (bt_hs_on)
                                         return false;
 
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], Wifi Connected-Idle + "
-                                          "BT Busy!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
 
                                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
                                                           0x1, 0xfffff, 0x0);
@@ -1592,9 +1541,8 @@ static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
 {
         /* Set PS TDMA for max interval == 1 */
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
 
                 if (coex_dm->cur_ps_tdma == 71) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
@@ -1690,9 +1638,8 @@ static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71);
                         coex_dm->tdma_adj_type = 71;
@@ -1790,9 +1737,8 @@ static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
 {
         /* Set PS TDMA for max interval == 2 */
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
                         coex_dm->tdma_adj_type = 6;
@@ -1873,9 +1819,8 @@ static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
                         coex_dm->tdma_adj_type = 2;
@@ -1963,9 +1908,8 @@ static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
 {
         /* Set PS TDMA for max interval == 3 */
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
                         coex_dm->tdma_adj_type = 7;
@@ -2046,9 +1990,8 @@ static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM,
-                          ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
                         coex_dm->tdma_adj_type = 3;
@@ -2140,13 +2083,13 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
         s32 result;
         u8 retry_count = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], TdmaDurationAdjust()\n");
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], TdmaDurationAdjust()\n");
 
         if (!coex_dm->auto_tdma_adjust) {
                 coex_dm->auto_tdma_adjust = true;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], first run TdmaDurationAdjust()!!\n");
                 if (sco_hid) {
                         if (tx_pause) {
                                 if (max_interval == 1) {
@@ -2250,11 +2193,11 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
         } else {
                 /*accquire the BT TRx retry count from BT_Info byte2*/
                 retry_count = coex_sta->bt_retry_cnt;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], retry_count = %d\n", retry_count);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
-                          up, dn, m, n, wait_count);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], retry_count = %d\n", retry_count);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
+                            up, dn, m, n, wait_count);
                 result = 0;
                 wait_count++;
                  /* no retry in the last 2-second duration*/
@@ -2271,10 +2214,8 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                                 up = 0;
                                 dn = 0;
                                 result = 1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Increase wifi "
-                                          "duration!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Increase wifi duration!!\n");
                         } /* <=3 retry in the last 2-second duration*/
                 } else if (retry_count <= 3) {
                         up--;
@@ -2297,10 +2238,8 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                                 dn = 0;
                                 wait_count = 0;
                                 result = -1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Decrease wifi duration "
-                                          "for retry_counter<3!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Decrease wifi duration for retry_counter<3!!\n");
                         }
                 } else {
                         if (wait_count == 1)
@@ -2316,13 +2255,12 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                         dn = 0;
                         wait_count = 0;
                         result = -1;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], Decrease wifi duration "
-                                  "for retry_counter>3!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], Decrease wifi duration for retry_counter>3!!\n");
                 }
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], max Interval = %d\n", max_interval);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], max Interval = %d\n", max_interval);
                 if (max_interval == 1)
                         set_tdma_int1(btcoexist, tx_pause, result);
                 else if (max_interval == 2)
@@ -2336,10 +2274,9 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
          */
         if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
                 bool scan = false, link = false, roam = false;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], PsTdma type dismatch!!!, "
-                          "curPsTdma=%d, recordPsTdma=%d\n",
-                          coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], PsTdma type dismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
+                            coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
@@ -2349,9 +2286,8 @@ static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
                         btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
                                              coex_dm->tdma_adj_type);
                 else
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], roaming/link/scan is under"
-                                  " progress, will adjust next time!!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
         }
 }
 
@@ -2989,27 +2925,26 @@ static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
 {
         u8 algorithm = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], RunCoexistMechanism()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], RunCoexistMechanism()===>\n");
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), "
-                          "return for Manual CTRL <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
                 return;
         }
 
         if (coex_sta->under_ips) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is under IPS !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is under IPS !!!\n");
                 return;
         }
 
         algorithm = btc8723b2ant_action_algorithm(btcoexist);
         if (coex_sta->c2h_bt_inquiry_page &&
             (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BT is under inquiry/page scan !!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BT is under inquiry/page scan !!\n");
                 btc8723b2ant_action_bt_inquiry(btcoexist);
                 return;
         } else {
@@ -3021,84 +2956,75 @@ static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         }
 
         coex_dm->cur_algorithm = algorithm;
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
-                  coex_dm->cur_algorithm);
+        btc_alg_dbg(ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
+                    coex_dm->cur_algorithm);
 
         if (btc8723b2ant_is_common_action(btcoexist)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Action 2-Ant common.\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Action 2-Ant common\n");
                 coex_dm->auto_tdma_adjust = false;
         } else {
                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], preAlgorithm=%d, "
-                                  "curAlgorithm=%d\n", coex_dm->pre_algorithm,
-                                  coex_dm->cur_algorithm);
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
+                                    coex_dm->pre_algorithm,
+                                    coex_dm->cur_algorithm);
                         coex_dm->auto_tdma_adjust = false;
                 }
                 switch (coex_dm->cur_algorithm) {
                 case BT_8723B_2ANT_COEX_ALGO_SCO:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = SCO\n");
                         btc8723b2ant_action_sco(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID\n");
                         btc8723b2ant_action_hid(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
                         btc8723b2ant_action_a2dp(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = A2DP+PAN(HS).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
                         btc8723b2ant_action_a2dp_pan_hs(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
                         btc8723b2ant_action_pan_edr(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = HS mode.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
                         btc8723b2ant_action_pan_hs(btcoexist);
-                                break;
+                        break;
                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = PAN+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
                         btc8723b2ant_action_pan_edr_a2dp(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = PAN(EDR)+HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
                         btc8723b2ant_action_pan_edr_hid(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = HID+A2DP+PAN.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
                         btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
                         break;
                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = HID+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
                         btc8723b2ant_action_hid_a2dp(btcoexist);
                         break;
                 default:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, "
-                                  "algorithm = coexist All Off!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
                         btc8723b2ant_coex_alloff(btcoexist);
                         break;
                 }
@@ -3126,8 +3052,8 @@ void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
 {
         u8 u8tmp = 0;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], 2Ant Init HW Config!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], 2Ant Init HW Config!!\n");
         coex_dm->bt_rf0x1e_backup =
                 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
 
@@ -3152,8 +3078,8 @@ void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
 
 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], Coex Mechanism Init!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], Coex Mechanism Init!!\n");
         btc8723b2ant_init_coex_dm(btcoexist);
 }
 
@@ -3388,15 +3314,15 @@ void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_IPS_ENTER == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS ENTER notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS ENTER notify\n");
                 coex_sta->under_ips = true;
                 btc8723b2ant_wifioff_hwcfg(btcoexist);
                 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
                 btc8723b2ant_coex_alloff(btcoexist);
         } else if (BTC_IPS_LEAVE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS LEAVE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS LEAVE notify\n");
                 coex_sta->under_ips = false;
                 ex_btc8723b2ant_init_hwconfig(btcoexist);
                 btc8723b2ant_init_coex_dm(btcoexist);
@@ -3407,12 +3333,12 @@ void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_LPS_ENABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS ENABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS ENABLE notify\n");
                 coex_sta->under_lps = true;
         } else if (BTC_LPS_DISABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS DISABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS DISABLE notify\n");
                 coex_sta->under_lps = false;
         }
 }
@@ -3420,21 +3346,21 @@ void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_SCAN_START == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN START notify\n");
         else if (BTC_SCAN_FINISH == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN FINISH notify\n");
 }
 
 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_ASSOCIATE_START == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT START notify\n");
         else if (BTC_ASSOCIATE_FINISH == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT FINISH notify\n");
 }
 
 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
@@ -3445,11 +3371,11 @@ void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
         u8 wifi_central_chnl;
 
         if (BTC_MEDIA_CONNECT == type)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA connect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA connect notify\n");
         else
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA disconnect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA disconnect notify\n");
 
         /* only 2.4G we need to inform bt the chnl mask */
         btcoexist->btc_get(btcoexist,
@@ -3470,10 +3396,10 @@ void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x66=0x%x\n",
-                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
-                  h2c_parameter[2]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x66=0x%x\n",
+                    h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
+                    h2c_parameter[2]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 }
@@ -3482,8 +3408,8 @@ void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
                                            u8 type)
 {
         if (type == BTC_PACKET_DHCP)
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], DHCP Packet notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], DHCP Packet notify\n");
 }
 
 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
@@ -3501,25 +3427,24 @@ void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
                 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
         coex_sta->bt_info_c2h_cnt[rsp_source]++;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Bt info[%d], length=%d, hex data=[",
-                  rsp_source, length);
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Bt info[%d], length=%d, hex data=[",
+                      rsp_source, length);
         for (i = 0; i < length; i++) {
                 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
                 if (i == 1)
                         bt_info = tmpbuf[i];
                 if (i == length-1)
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x]\n", tmpbuf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x]\n", tmpbuf[i]);
                 else
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x, ", tmpbuf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x, ", tmpbuf[i]);
         }
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), "
-                          "return for Manual CTRL<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
                 return;
         }
 
@@ -3537,9 +3462,8 @@ void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
                      because bt is reset and loss of the info.
                  */
                 if ((coex_sta->bt_info_ext & BIT1)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT ext info bit1 check,"
-                                  " send wifi BW&Chnl to BT!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
                                            &wifi_connected);
                         if (wifi_connected)
@@ -3553,9 +3477,8 @@ void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
                 }
 
                 if ((coex_sta->bt_info_ext & BIT3)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT ext info bit3 check, "
-                                  "set BT NOT to ignore Wlan active!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
                         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
                                                      false);
                 } else {
@@ -3608,28 +3531,26 @@ void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
 
         if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), "
-                          "BT Non-Connected idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
         /* connection exists but no busy */
         } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
         } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
                    (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
         } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
         } else {
                 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), "
-                          "BT Non-Defined state!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
         }
 
         if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
@@ -3652,7 +3573,7 @@ void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
 
 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
+        btc_iface_dbg(INTF_NOTIFY, "[BTCoex], Halt notify\n");
 
         btc8723b2ant_wifioff_hwcfg(btcoexist);
         btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
@@ -3666,33 +3587,31 @@ void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
         static u8 dis_ver_info_cnt;
         u32 fw_ver = 0, bt_patch_ver = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], =========================="
-                  "Periodical===========================\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], ==========================Periodical===========================\n");
 
         if (dis_ver_info_cnt <= 5) {
                 dis_ver_info_cnt += 1;
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************"
-                          "************************************\n");
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], Ant PG Num/ Ant Mech/ "
-                          "Ant Pos = %d/ %d/ %d\n", board_info->pg_ant_num,
-                          board_info->btdm_ant_num, board_info->btdm_ant_pos);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
-                          ((stack_info->profile_notified) ? "Yes" : "No"),
-                          stack_info->hci_version);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
+                              board_info->pg_ant_num,
+                              board_info->btdm_ant_num,
+                              board_info->btdm_ant_pos);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
+                              stack_info->profile_notified ? "Yes" : "No",
+                              stack_info->hci_version);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
                                    &bt_patch_ver);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
-                          glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
-                          fw_ver, bt_patch_ver, bt_patch_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], *****************************"
-                          "***********************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
+                              glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
+                              fw_ver, bt_patch_ver, bt_patch_ver);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
         }
 
 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a1ant.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a1ant.c
index 9cecf174a37d..3ce47c70bfa4 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a1ant.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a1ant.c
@@ -76,28 +76,28 @@ static u8 halbtc8821a1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= (rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "[BTCoex], BT Rssi thresh error!!\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "[BTCoex], BT Rssi thresh error!!\n");
                         return coex_sta->pre_bt_rssi_state;
                 }
 
@@ -106,12 +106,12 @@ static u8 halbtc8821a1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= (rssi_thresh +
                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_bt_rssi_state ==
                            BTC_RSSI_STATE_MEDIUM) ||
@@ -120,26 +120,26 @@ static u8 halbtc8821a1ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >= (rssi_thresh1 +
                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Medium\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh1) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         }
@@ -165,32 +165,28 @@ static u8 halbtc8821a1ant_WifiRssiState(struct btc_coexist *btcoexist,
                         if (wifi_rssi >=
                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
-                                  "[BTCoex], wifi RSSI thresh error!!\n");
+                        btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                    "[BTCoex], wifi RSSI thresh error!!\n");
                         return coex_sta->pre_wifi_rssi_state[index];
                 }
 
@@ -201,14 +197,12 @@ static u8 halbtc8821a1ant_WifiRssiState(struct btc_coexist *btcoexist,
                         if (wifi_rssi >=
                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
                         BTC_RSSI_STATE_MEDIUM) ||
@@ -218,31 +212,26 @@ static u8 halbtc8821a1ant_WifiRssiState(struct btc_coexist *btcoexist,
                             (rssi_thresh1 +
                              BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Medium\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh1) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         }
@@ -431,9 +420,9 @@ static void halbtc8821a1ant_query_bt_info(struct btc_coexist *btcoexist)
 
         h2c_parameter[0] |= BIT0;       /* trigger*/
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 }
@@ -504,8 +493,8 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 
         if (!bt_link_info->bt_link_exist) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], No BT link exists!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], No BT link exists!!!\n");
                 return algorithm;
         }
 
@@ -520,26 +509,26 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
 
         if (num_of_diff_profile == 1) {
                 if (bt_link_info->sco_exist) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT Profile = SCO only\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT Profile = SCO only\n");
                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
                 } else {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = HID only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = HID only\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = A2DP only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = A2DP only\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = PAN(HS) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = PAN(HS) only\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = PAN(EDR) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = PAN(EDR) only\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR;
                                 }
                         }
@@ -547,50 +536,50 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
         } else if (num_of_diff_profile == 2) {
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + HID\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
                         } else if (bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
                 } else {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = HID + A2DP\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = HID + A2DP\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
                         } else if (bt_link_info->hid_exist &&
                                    bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + PAN(EDR)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                    bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP;
                                 }
                         }
@@ -599,29 +588,29 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
                 if (bt_link_info->sco_exist) {
                         if (bt_link_info->hid_exist &&
                             bt_link_info->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
                         } else if (bt_link_info->hid_exist &&
                                 bt_link_info->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (bt_link_info->pan_exist &&
                                 bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
@@ -630,12 +619,12 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 }
                         }
@@ -646,12 +635,12 @@ static u8 halbtc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
                             bt_link_info->pan_exist &&
                             bt_link_info->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
 
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
@@ -670,10 +659,10 @@ static void halbtc8821a1ant_set_bt_auto_report(struct btc_coexist *btcoexist,
         if (enable_auto_report)
                 h2c_parameter[0] |= BIT0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
-                  (enable_auto_report ? "Enabled!!" : "Disabled!!"),
-                   h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
+                    (enable_auto_report ? "Enabled!!" : "Disabled!!"),
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 }
@@ -682,17 +671,16 @@ static void halbtc8821a1ant_bt_auto_report(struct btc_coexist *btcoexist,
                                            bool force_exec,
                                            bool enable_auto_report)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM,
-                  ALGO_TRACE_FW, "[BTCoex], %s BT Auto report = %s\n",
-                  (force_exec ? "force to" : ""), ((enable_auto_report) ?
-                  "Enabled" : "Disabled"));
+        btc_alg_dbg(ALGO_TRACE_FW, "[BTCoex], %s BT Auto report = %s\n",
+                    (force_exec ? "force to" : ""), ((enable_auto_report) ?
+                                                     "Enabled" : "Disabled"));
         coex_dm->cur_bt_auto_report = enable_auto_report;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_bt_auto_report = %d, cur_bt_auto_report = %d\n",
-                          coex_dm->pre_bt_auto_report,
-                          coex_dm->cur_bt_auto_report);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_bt_auto_report = %d, cur_bt_auto_report = %d\n",
+                            coex_dm->pre_bt_auto_report,
+                            coex_dm->cur_bt_auto_report);
 
                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
                         return;
@@ -718,9 +706,9 @@ static void btc8821a1ant_set_sw_pen_tx_rate(struct btc_coexist *btcoexist,
                 h2c_parameter[5] = 0xf9;        /*MCS5 or OFDM36*/
         }
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
-                  (low_penalty_ra ? "ON!!" : "OFF!!"));
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set WiFi Low-Penalty Retry: %s",
+                    (low_penalty_ra ? "ON!!" : "OFF!!"));
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 }
@@ -743,20 +731,20 @@ static void halbtc8821a1ant_set_coex_table(struct btc_coexist *btcoexist,
                                            u32 val0x6c0, u32 val0x6c4,
                                            u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 }
 
@@ -764,10 +752,10 @@ static void halbtc8821a1ant_coex_table(struct btc_coexist *btcoexist,
                                        bool force_exec, u32 val0x6c0,
                                        u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
-                  (force_exec ? "force to" : ""), val0x6c0, val0x6c4,
-                  val0x6c8, val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
+                    (force_exec ? "force to" : ""), val0x6c0, val0x6c4,
+                    val0x6c8, val0x6cc);
         coex_dm->cur_val_0x6c0 = val0x6c0;
         coex_dm->cur_val_0x6c4 = val0x6c4;
         coex_dm->cur_val_0x6c8 = val0x6c8;
@@ -839,9 +827,9 @@ static void btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
         if (enable)
                 h2c_parameter[0] |= BIT0;       /* function enable*/
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 }
@@ -849,16 +837,16 @@ static void btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
 static void halbtc8821a1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
                                             bool force_exec, bool enable)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn Ignore WlanAct %s\n",
-                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn Ignore WlanAct %s\n",
+                    (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
         coex_dm->cur_ignore_wlan_act = enable;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
-                          coex_dm->pre_ignore_wlan_act,
-                          coex_dm->cur_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
+                            coex_dm->pre_ignore_wlan_act,
+                            coex_dm->cur_ignore_wlan_act);
 
                 if (coex_dm->pre_ignore_wlan_act ==
                     coex_dm->cur_ignore_wlan_act)
@@ -887,13 +875,13 @@ static void halbtc8821a1ant_set_fw_pstdma(struct btc_coexist *btcoexist,
         coex_dm->ps_tdma_para[3] = byte4;
         coex_dm->ps_tdma_para[4] = byte5;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
-                  h2c_parameter[0],
-                  h2c_parameter[1]<<24 |
-                  h2c_parameter[2]<<16 |
-                  h2c_parameter[3]<<8 |
-                  h2c_parameter[4]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
+                    h2c_parameter[0],
+                    h2c_parameter[1] << 24 |
+                    h2c_parameter[2] << 16 |
+                    h2c_parameter[3] << 8 |
+                    h2c_parameter[4]);
         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 }
 
@@ -910,22 +898,22 @@ static void halbtc8821a1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
 static void halbtc8821a1ant_lps_rpwm(struct btc_coexist *btcoexist,
                                      bool force_exec, u8 lps_val, u8 rpwm_val)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
-                  (force_exec ? "force to" : ""), lps_val, rpwm_val);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
+                    (force_exec ? "force to" : ""), lps_val, rpwm_val);
         coex_dm->cur_lps = lps_val;
         coex_dm->cur_rpwm = rpwm_val;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], LPS-RxBeaconMode = 0x%x, LPS-RPWM = 0x%x!!\n",
-                          coex_dm->cur_lps, coex_dm->cur_rpwm);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], LPS-RxBeaconMode = 0x%x, LPS-RPWM = 0x%x!!\n",
+                            coex_dm->cur_lps, coex_dm->cur_rpwm);
 
                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], LPS-RPWM_Last = 0x%x, LPS-RPWM_Now = 0x%x!!\n",
-                                  coex_dm->pre_rpwm, coex_dm->cur_rpwm);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], LPS-RPWM_Last = 0x%x, LPS-RPWM_Now = 0x%x!!\n",
+                                    coex_dm->pre_rpwm, coex_dm->cur_rpwm);
 
                         return;
                 }
@@ -939,8 +927,8 @@ static void halbtc8821a1ant_lps_rpwm(struct btc_coexist *btcoexist,
 static void halbtc8821a1ant_sw_mechanism(struct btc_coexist *btcoexist,
                                          bool low_penalty_ra)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
 
         halbtc8821a1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
 }
@@ -1036,13 +1024,13 @@ static void halbtc8821a1ant_ps_tdma(struct btc_coexist *btcoexist,
 
         if (!force_exec) {
                 if (coex_dm->cur_ps_tdma_on) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], ********** TDMA(on, %d) **********\n",
-                                  coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], ********** TDMA(on, %d) **********\n",
+                                    coex_dm->cur_ps_tdma);
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], ********** TDMA(off, %d) **********\n",
-                                  coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], ********** TDMA(off, %d) **********\n",
+                                    coex_dm->cur_ps_tdma);
                 }
                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
@@ -1253,50 +1241,50 @@ static bool halbtc8821a1ant_is_common_action(struct btc_coexist *btcoexist)
         if (!wifi_connected &&
             BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
             coex_dm->bt_status) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
                 halbtc8821a1ant_sw_mechanism(btcoexist, false);
 
                 common = true;
         } else if (wifi_connected &&
                    (BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi connected + BT non connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi connected + BT non connected-idle!!\n");
                 halbtc8821a1ant_sw_mechanism(btcoexist, false);
 
                 common = true;
         } else if (!wifi_connected &&
                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
                 halbtc8821a1ant_sw_mechanism(btcoexist, false);
 
                 common = true;
         } else if (wifi_connected &&
                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
                    coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi connected + BT connected-idle!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi connected + BT connected-idle!!\n");
                 halbtc8821a1ant_sw_mechanism(btcoexist, false);
 
                 common = true;
         } else if (!wifi_connected &&
                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE !=
                     coex_dm->bt_status)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
                 halbtc8821a1ant_sw_mechanism(btcoexist, false);
 
                 common = true;
         } else {
                 if (wifi_busy) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
                 }
 
                 common = false;
@@ -1313,8 +1301,8 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
         long                    result;
         u8                      retry_count = 0, bt_info_ext;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], TdmaDurationAdjustForAcl()\n");
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], TdmaDurationAdjustForAcl()\n");
 
         if ((BT_8821A_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN ==
              wifi_status) ||
@@ -1342,8 +1330,8 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
 
         if (!coex_dm->auto_tdma_adjust) {
                 coex_dm->auto_tdma_adjust = true;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], first run TdmaDurationAdjust()!!\n");
 
                 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
                 coex_dm->tdma_adj_type = 2;
@@ -1378,9 +1366,8 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                                 up = 0;
                                 dn = 0;
                                 result = 1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Increase wifi duration!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Increase wifi duration!!\n");
                         }
                 } else if (retry_count <= 3) {
                         /* <=3 retry in the last 2-second duration*/
@@ -1410,9 +1397,8 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                                 dn = 0;
                                 wait_count = 0;
                                 result = -1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
                         }
                 } else {
                         /* retry count > 3, if retry count > 3 happens once,
@@ -1433,8 +1419,8 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                         dn = 0;
                         wait_count = 0;
                         result = -1;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
                 }
 
                 if (result == -1) {
@@ -1479,9 +1465,9 @@ static void btc8821a1ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                         }
                 } else {
                         /*no change*/
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], ********** TDMA(on, %d) **********\n",
-                                coex_dm->cur_ps_tdma);
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], ********** TDMA(on, %d) **********\n",
+                                    coex_dm->cur_ps_tdma);
                 }
 
                 if (coex_dm->cur_ps_tdma != 1 &&
@@ -1603,27 +1589,27 @@ static void btc8821a1ant_mon_bt_en_dis(struct btc_coexist *btcoexist)
                 bt_disabled = false;
                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                    &bt_disabled);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is enabled !!\n");
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is enabled !!\n");
         } else {
                 bt_disable_cnt++;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], bt all counters = 0, %d times!!\n",
-                          bt_disable_cnt);
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], bt all counters = 0, %d times!!\n",
+                            bt_disable_cnt);
                 if (bt_disable_cnt >= 2) {
                         bt_disabled = true;
                         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                            &bt_disabled);
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                                  "[BTCoex], BT is disabled !!\n");
+                        btc_alg_dbg(ALGO_BT_MONITOR,
+                                    "[BTCoex], BT is disabled !!\n");
                         halbtc8821a1ant_action_wifi_only(btcoexist);
                 }
         }
         if (pre_bt_disabled != bt_disabled) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is from %s to %s!!\n",
-                        (pre_bt_disabled ? "disabled" : "enabled"),
-                        (bt_disabled ? "disabled" : "enabled"));
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is from %s to %s!!\n",
+                            (pre_bt_disabled ? "disabled" : "enabled"),
+                            (bt_disabled ? "disabled" : "enabled"));
                 pre_bt_disabled = bt_disabled;
                 if (bt_disabled) {
                         btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
@@ -1897,15 +1883,15 @@ static void halbtc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
         bool    scan = false, link = false, roam = false;
         bool    under_4way = false;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], CoexForWifiConnect()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], CoexForWifiConnect()===>\n");
 
         btcoexist->btc_get(btcoexist,
                  BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
         if (under_4way) {
                 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
                 return;
         }
 
@@ -1914,8 +1900,8 @@ static void halbtc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
         if (scan || link || roam) {
                 halbtc8821a1ant_action_wifi_connected_scan(btcoexist);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
                 return;
         }
 
@@ -1976,58 +1962,58 @@ static void btc8821a1ant_run_sw_coex_mech(struct btc_coexist *btcoexist)
         if (!halbtc8821a1ant_is_common_action(btcoexist)) {
                 switch (coex_dm->cur_algorithm) {
                 case BT_8821A_1ANT_COEX_ALGO_SCO:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = SCO.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = SCO\n");
                         halbtc8821a1ant_action_sco(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID\n");
                         halbtc8821a1ant_action_hid(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = A2DP\n");
                         halbtc8821a1ant_action_a2dp(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = A2DP+PAN(HS).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
                         halbtc8821a1ant_action_a2dp_pan_hs(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN(EDR)\n");
                         halbtc8821a1ant_action_pan_edr(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HS mode.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HS mode\n");
                         halbtc8821a1ant_action_pan_hs(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN+A2DP\n");
                         halbtc8821a1ant_action_pan_edr_a2dp(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = PAN(EDR)+HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = PAN(EDR)+HID\n");
                         halbtc8821a1ant_action_pan_edr_hid(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID+A2DP+PAN.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID+A2DP+PAN\n");
                         btc8821a1ant_action_hid_a2dp_pan_edr(btcoexist);
                         break;
                 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = HID+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = HID+A2DP\n");
                         halbtc8821a1ant_action_hid_a2dp(btcoexist);
                         break;
                 default:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action algorithm = coexist All Off!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action algorithm = coexist All Off!!\n");
                         /*halbtc8821a1ant_coex_all_off(btcoexist);*/
                         break;
                 }
@@ -2045,31 +2031,31 @@ static void halbtc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         u8      wifi_rssi_state = BTC_RSSI_STATE_HIGH;
         bool    wifi_under_5g = false;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], RunCoexistMechanism()===>\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], RunCoexistMechanism()===>\n");
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
                 return;
         }
 
         if (btcoexist->stop_coex_dm) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
                 return;
         }
 
         if (coex_sta->under_ips) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is under IPS !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is under IPS !!!\n");
                 return;
         }
 
         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
         if (wifi_under_5g) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
                 halbtc8821a1ant_coex_under_5g(btcoexist);
                 return;
         }
@@ -2135,8 +2121,8 @@ static void halbtc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         if (!wifi_connected) {
                 bool    scan = false, link = false, roam = false;
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], wifi is non connected-idle !!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], wifi is non connected-idle !!!\n");
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
@@ -2168,8 +2154,8 @@ static void halbtc8821a1ant_init_hw_config(struct btc_coexist *btcoexist,
         u8      u1_tmp = 0;
         bool    wifi_under_5g = false;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], 1Ant Init HW Config!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], 1Ant Init HW Config!!\n");
 
         if (back_up) {
                 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
@@ -2220,8 +2206,8 @@ void ex_halbtc8821a1ant_init_hwconfig(struct btc_coexist *btcoexist)
 
 void ex_halbtc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], Coex Mechanism Init!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], Coex Mechanism Init!!\n");
 
         btcoexist->stop_coex_dm = false;
 
@@ -2515,8 +2501,8 @@ void ex_halbtc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
                 return;
 
         if (BTC_IPS_ENTER == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS ENTER notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS ENTER notify\n");
                 coex_sta->under_ips = true;
                 halbtc8821a1ant_set_ant_path(btcoexist,
                                              BTC_ANT_PATH_BT, false, true);
@@ -2525,8 +2511,8 @@ void ex_halbtc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
                 halbtc8821a1ant_coex_table_with_type(btcoexist,
                                                      NORMAL_EXEC, 0);
         } else if (BTC_IPS_LEAVE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS LEAVE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS LEAVE notify\n");
                 coex_sta->under_ips = false;
 
                 halbtc8821a1ant_run_coexist_mechanism(btcoexist);
@@ -2539,12 +2525,12 @@ void ex_halbtc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
                 return;
 
         if (BTC_LPS_ENABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS ENABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS ENABLE notify\n");
                 coex_sta->under_Lps = true;
         } else if (BTC_LPS_DISABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS DISABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS DISABLE notify\n");
                 coex_sta->under_Lps = false;
         }
 }
@@ -2574,8 +2560,8 @@ void ex_halbtc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
         }
 
         if (BTC_SCAN_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN START notify\n");
                 if (!wifi_connected) {
                         /* non-connected scan*/
                         btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
@@ -2584,8 +2570,8 @@ void ex_halbtc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
                         halbtc8821a1ant_action_wifi_connected_scan(btcoexist);
                 }
         } else if (BTC_SCAN_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN FINISH notify\n");
                 if (!wifi_connected) {
                         /* non-connected scan*/
                         halbtc8821a1ant_action_wifi_not_connected(btcoexist);
@@ -2614,12 +2600,12 @@ void ex_halbtc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
         }
 
         if (BTC_ASSOCIATE_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT START notify\n");
                 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
         } else if (BTC_ASSOCIATE_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT FINISH notify\n");
 
                 btcoexist->btc_get(btcoexist,
                          BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
@@ -2645,11 +2631,11 @@ void ex_halbtc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
                 return;
 
         if (BTC_MEDIA_CONNECT == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA connect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA connect notify\n");
         } else {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA disconnect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA disconnect notify\n");
         }
 
         /* only 2.4G we need to inform bt the chnl mask*/
@@ -2672,9 +2658,11 @@ void ex_halbtc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x66 = 0x%x\n",
-                  h2c_parameter[0]<<16|h2c_parameter[1]<<8|h2c_parameter[2]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x66 = 0x%x\n",
+                    h2c_parameter[0] << 16 |
+                    h2c_parameter[1] << 8 |
+                    h2c_parameter[2]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 }
@@ -2702,8 +2690,8 @@ void ex_halbtc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist,
 
         if (BTC_PACKET_DHCP == type ||
             BTC_PACKET_EAPOL == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], special Packet(%d) notify\n", type);
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], special Packet(%d) notify\n", type);
                 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
         }
 }
@@ -2727,19 +2715,19 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 rsp_source = BT_INFO_SRC_8821A_1ANT_WIFI_FW;
         coex_sta->bt_info_c2h_cnt[rsp_source]++;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Bt info[%d], length = %d, hex data = [",
-                  rsp_source, length);
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Bt info[%d], length = %d, hex data = [",
+                      rsp_source, length);
         for (i = 0; i < length; i++) {
                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
                 if (i == 1)
                         bt_info = tmp_buf[i];
                 if (i == length-1) {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x]\n", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x]\n", tmp_buf[i]);
                 } else {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x, ", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x, ", tmp_buf[i]);
                 }
         }
 
@@ -2756,8 +2744,8 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 /* Here we need to resend some wifi info to BT*/
                 /* because bt is reset and loss of the info.*/
                 if (coex_sta->bt_info_ext & BIT1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
                         btcoexist->btc_get(btcoexist,
                                            BTC_GET_BL_WIFI_CONNECTED,
                                            &wifi_connected);
@@ -2773,8 +2761,8 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 if ((coex_sta->bt_info_ext & BIT3) && !wifi_under_5g) {
                         if (!btcoexist->manual_control &&
                             !btcoexist->stop_coex_dm) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
                                 halbtc8821a1ant_ignore_wlan_act(btcoexist,
                                                                 FORCE_EXEC,
                                                                 false);
@@ -2782,8 +2770,8 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
                 }
 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 0)
                 if (!(coex_sta->bt_info_ext & BIT4)) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], BT ext info bit4 check, set BT to enable Auto Report!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], BT ext info bit4 check, set BT to enable Auto Report!!\n");
                         halbtc8821a1ant_bt_auto_report(btcoexist,
                                                        FORCE_EXEC, true);
                 }
@@ -2828,28 +2816,28 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
 
         if (!(bt_info&BT_INFO_8821A_1ANT_B_CONNECTION)) {
                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
         } else if (bt_info == BT_INFO_8821A_1ANT_B_CONNECTION) {
                 /* connection exists but no busy*/
                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
         } else if ((bt_info&BT_INFO_8821A_1ANT_B_SCO_ESCO) ||
                 (bt_info&BT_INFO_8821A_1ANT_B_SCO_BUSY)) {
                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_SCO_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
         } else if (bt_info&BT_INFO_8821A_1ANT_B_ACL_BUSY) {
                 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
                         coex_dm->auto_tdma_adjust = false;
                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_ACL_BUSY;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
         } else {
                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_MAX;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
         }
 
         if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
@@ -2866,8 +2854,8 @@ void ex_halbtc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
 
 void ex_halbtc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Halt notify\n");
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Halt notify\n");
 
         btcoexist->stop_coex_dm = true;
 
@@ -2885,20 +2873,20 @@ void ex_halbtc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
 
 void ex_halbtc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Pnp notify\n");
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Pnp notify\n");
 
         if (BTC_WIFI_PNP_SLEEP == pnp_state) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], Pnp notify to SLEEP\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], Pnp notify to SLEEP\n");
                 btcoexist->stop_coex_dm = true;
                 halbtc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
                 halbtc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
                                                  0x0, 0x0);
                 halbtc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 9);
         } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], Pnp notify to WAKE UP\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], Pnp notify to WAKE UP\n");
                 btcoexist->stop_coex_dm = false;
                 halbtc8821a1ant_init_hw_config(btcoexist, false);
                 halbtc8821a1ant_init_coex_dm(btcoexist);
@@ -2914,33 +2902,33 @@ ex_halbtc8821a1ant_periodical(
         struct btc_board_info *board_info = &btcoexist->board_info;
         struct btc_stack_info *stack_info = &btcoexist->stack_info;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], ==========================Periodical===========================\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], ==========================Periodical===========================\n");
 
         if (dis_ver_info_cnt <= 5) {
                 dis_ver_info_cnt += 1;
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
-                          board_info->pg_ant_num,
-                          board_info->btdm_ant_num,
-                          board_info->btdm_ant_pos);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
-                          ((stack_info->profile_notified) ? "Yes" : "No"),
-                          stack_info->hci_version);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
+                              board_info->pg_ant_num,
+                              board_info->btdm_ant_num,
+                              board_info->btdm_ant_pos);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
+                              stack_info->profile_notified ? "Yes" : "No",
+                              stack_info->hci_version);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
                                    &bt_patch_ver);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
-                        glcoex_ver_date_8821a_1ant,
-                        glcoex_ver_8821a_1ant,
-                        fw_ver, bt_patch_ver,
-                        bt_patch_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
+                              glcoex_ver_date_8821a_1ant,
+                              glcoex_ver_8821a_1ant,
+                              fw_ver, bt_patch_ver,
+                              bt_patch_ver);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
         }
 
 #if (BT_AUTO_REPORT_ONLY_8821A_1ANT == 0)
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a2ant.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a2ant.c
index 044d914291c0..81f843bba771 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a2ant.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a2ant.c
@@ -80,28 +80,28 @@ static u8 halbtc8821a2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                                    BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT;
                         if (bt_rssi >= tmp) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                  "[BTCoex], BT Rssi thresh error!!\n");
+                        btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                    "[BTCoex], BT Rssi thresh error!!\n");
                         return coex_sta->pre_bt_rssi_state;
                 }
 
@@ -110,12 +110,12 @@ static u8 halbtc8821a2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                         if (bt_rssi >=
                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_bt_rssi_state ==
                            BTC_RSSI_STATE_MEDIUM) ||
@@ -125,26 +125,26 @@ static u8 halbtc8821a2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
                             (rssi_thresh1 +
                              BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to High\n");
                         } else if (bt_rssi < rssi_thresh) {
                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Low\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Low\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at Medium\n");
                         }
                 } else {
                         if (bt_rssi < rssi_thresh1) {
                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state switch to Medium\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state switch to Medium\n");
                         } else {
                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
-                                          "[BTCoex], BT Rssi state stay at High\n");
+                                btc_alg_dbg(ALGO_BT_RSSI_STATE,
+                                            "[BTCoex], BT Rssi state stay at High\n");
                         }
                 }
         }
@@ -171,32 +171,28 @@ static u8 halbtc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >=
                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         } else if (level_num == 3) {
                 if (rssi_thresh > rssi_thresh1) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
-                                  "[BTCoex], wifi RSSI thresh error!!\n");
+                        btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                    "[BTCoex], wifi RSSI thresh error!!\n");
                         return coex_sta->pre_wifi_rssi_state[index];
                 }
 
@@ -207,14 +203,12 @@ static u8 halbtc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >=
                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Low\n");
                         }
                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
                            BTC_RSSI_STATE_MEDIUM) ||
@@ -223,31 +217,26 @@ static u8 halbtc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
                         if (wifi_rssi >= (rssi_thresh1 +
                             BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to High\n");
                         } else if (wifi_rssi < rssi_thresh) {
                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Low\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Low\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at Medium\n");
                         }
                 } else {
                         if (wifi_rssi < rssi_thresh1) {
                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state switch to Medium\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state switch to Medium\n");
                         } else {
                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_WIFI_RSSI_STATE,
-                                          "[BTCoex], wifi RSSI state stay at High\n");
+                                btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
+                                            "[BTCoex], wifi RSSI state stay at High\n");
                         }
                 }
         }
@@ -279,26 +268,26 @@ static void btc8821a2ant_mon_bt_en_dis(struct btc_coexist *btcoexist)
                 bt_disabled = false;
                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                    &bt_disabled);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is enabled !!\n");
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is enabled !!\n");
         } else {
                 bt_disable_cnt++;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], bt all counters = 0, %d times!!\n",
-                          bt_disable_cnt);
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], bt all counters = 0, %d times!!\n",
+                            bt_disable_cnt);
                 if (bt_disable_cnt >= 2) {
                         bt_disabled = true;
                         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
                                            &bt_disabled);
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                                  "[BTCoex], BT is disabled !!\n");
+                        btc_alg_dbg(ALGO_BT_MONITOR,
+                                    "[BTCoex], BT is disabled !!\n");
                 }
         }
         if (pre_bt_disabled != bt_disabled) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                          "[BTCoex], BT is from %s to %s!!\n",
-                          (pre_bt_disabled ? "disabled" : "enabled"),
-                          (bt_disabled ? "disabled" : "enabled"));
+                btc_alg_dbg(ALGO_BT_MONITOR,
+                            "[BTCoex], BT is from %s to %s!!\n",
+                            (pre_bt_disabled ? "disabled" : "enabled"),
+                            (bt_disabled ? "disabled" : "enabled"));
                 pre_bt_disabled = bt_disabled;
         }
 }
@@ -324,12 +313,12 @@ static void halbtc8821a2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
         coex_sta->low_priority_tx = reg_lp_tx;
         coex_sta->low_priority_rx = reg_lp_rx;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
-                  reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
-                  "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
-                  reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
+                    reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
+        btc_alg_dbg(ALGO_BT_MONITOR,
+                    "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
+                    reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 
         /* reset counter */
         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
@@ -343,9 +332,9 @@ static void halbtc8821a2ant_query_bt_info(struct btc_coexist *btcoexist)
 
         h2c_parameter[0] |= BIT0;       /* trigger */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 }
@@ -368,8 +357,8 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
                 stack_info->bt_link_exist = coex_sta->bt_link_exist;
 
         if (!coex_sta->bt_link_exist) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], No profile exists!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], No profile exists!!!\n");
                 return algorithm;
         }
 
@@ -384,26 +373,26 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
 
         if (num_of_diff_profile == 1) {
                 if (coex_sta->sco_exist) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], SCO only\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], SCO only\n");
                         algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
                 } else {
                         if (coex_sta->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], HID only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], HID only\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
                         } else if (coex_sta->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], A2DP only\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], A2DP only\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP;
                         } else if (coex_sta->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], PAN(HS) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], PAN(HS) only\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], PAN(EDR) only\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], PAN(EDR) only\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR;
                                 }
                         }
@@ -411,50 +400,50 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
         } else if (num_of_diff_profile == 2) {
                 if (coex_sta->sco_exist) {
                         if (coex_sta->hid_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + HID\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (coex_sta->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + A2DP ==> SCO\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + A2DP ==> SCO\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (coex_sta->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + PAN(HS)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + PAN(EDR)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
                 } else {
                         if (coex_sta->hid_exist &&
                             coex_sta->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], HID + A2DP\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], HID + A2DP\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
                         } else if (coex_sta->hid_exist &&
                                 coex_sta->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + PAN(HS)\n");
                                         algorithm =  BT_8821A_2ANT_COEX_ALGO_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + PAN(EDR)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (coex_sta->pan_exist &&
                                 coex_sta->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], A2DP + PAN(EDR)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP;
                                 }
                         }
@@ -463,29 +452,29 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
                 if (coex_sta->sco_exist) {
                         if (coex_sta->hid_exist &&
                             coex_sta->a2dp_exist) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                          "[BTCoex], SCO + HID + A2DP ==> HID\n");
+                                btc_alg_dbg(ALGO_TRACE,
+                                            "[BTCoex], SCO + HID + A2DP ==> HID\n");
                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                         } else if (coex_sta->hid_exist &&
                                 coex_sta->pan_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + PAN(HS)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + PAN(EDR)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         } else if (coex_sta->pan_exist &&
                                    coex_sta->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
@@ -494,12 +483,12 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
                             coex_sta->pan_exist &&
                             coex_sta->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + A2DP + PAN(HS)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], HID + A2DP + PAN(EDR)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], HID + A2DP + PAN(EDR)\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
                                 }
                         }
@@ -510,12 +499,12 @@ static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
                             coex_sta->pan_exist &&
                             coex_sta->a2dp_exist) {
                                 if (bt_hs_on) {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
 
                                 } else {
-                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                                  "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
+                                        btc_alg_dbg(ALGO_TRACE,
+                                                    "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
                                 }
                         }
@@ -544,15 +533,15 @@ static bool halbtc8821a2ant_need_to_dec_bt_pwr(struct btc_coexist *btcoexist)
         if (wifi_connected) {
                 if (bt_hs_on) {
                         if (bt_hs_rssi > 37) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                                          "[BTCoex], Need to decrease bt power for HS mode!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW,
+                                            "[BTCoex], Need to decrease bt power for HS mode!!\n");
                                 ret = true;
                         }
                 } else {
                         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
                             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
-                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                                          "[BTCoex], Need to decrease bt power for Wifi is connected!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW,
+                                            "[BTCoex], Need to decrease bt power for Wifi is connected!!\n");
                                 ret = true;
                         }
                 }
@@ -570,10 +559,10 @@ static void btc8821a2ant_set_fw_dac_swing_lev(struct btc_coexist *btcoexist,
          */
         h2c_parameter[0] = dac_swing_lvl;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 }
@@ -588,9 +577,9 @@ static void halbtc8821a2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
         if (dec_bt_pwr)
                 h2c_parameter[0] |= BIT1;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], decrease Bt Power : %s, FW write 0x62 = 0x%x\n",
-                  (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], decrease Bt Power : %s, FW write 0x62 = 0x%x\n",
+                    (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 }
@@ -598,16 +587,16 @@ static void halbtc8821a2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 static void halbtc8821a2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
                                        bool force_exec, bool dec_bt_pwr)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s Dec BT power = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((dec_bt_pwr) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s Dec BT power = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((dec_bt_pwr) ? "ON" : "OFF"));
         coex_dm->cur_dec_bt_pwr = dec_bt_pwr;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_dec_bt_pwr = %d, cur_dec_bt_pwr = %d\n",
-                          coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_dec_bt_pwr = %d, cur_dec_bt_pwr = %d\n",
+                            coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
 
                 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
                         return;
@@ -627,10 +616,10 @@ static void btc8821a2ant_set_fw_bt_lna_constr(struct btc_coexist *btcoexist,
         if (bt_lna_cons_on)
                 h2c_parameter[1] |= BIT0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set BT LNA Constrain: %s, FW write 0x69 = 0x%x\n",
-                  (bt_lna_cons_on ? "ON!!" : "OFF!!"),
-                  h2c_parameter[0]<<8|h2c_parameter[1]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set BT LNA Constrain: %s, FW write 0x69 = 0x%x\n",
+                    bt_lna_cons_on ? "ON!!" : "OFF!!",
+                    h2c_parameter[0] << 8 | h2c_parameter[1]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 2, h2c_parameter);
 }
@@ -638,17 +627,17 @@ static void btc8821a2ant_set_fw_bt_lna_constr(struct btc_coexist *btcoexist,
 static void btc8821a2_set_bt_lna_const(struct btc_coexist *btcoexist,
                                        bool force_exec, bool bt_lna_cons_on)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s BT Constrain = %s\n",
-                  (force_exec ? "force" : ""),
-                  ((bt_lna_cons_on) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s BT Constrain = %s\n",
+                    (force_exec ? "force" : ""),
+                    ((bt_lna_cons_on) ? "ON" : "OFF"));
         coex_dm->cur_bt_lna_constrain = bt_lna_cons_on;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_bt_lna_constrain = %d,cur_bt_lna_constrain = %d\n",
-                          coex_dm->pre_bt_lna_constrain,
-                          coex_dm->cur_bt_lna_constrain);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_bt_lna_constrain = %d,cur_bt_lna_constrain = %d\n",
+                            coex_dm->pre_bt_lna_constrain,
+                            coex_dm->cur_bt_lna_constrain);
 
                 if (coex_dm->pre_bt_lna_constrain ==
                     coex_dm->cur_bt_lna_constrain)
@@ -669,10 +658,10 @@ static void halbtc8821a2ant_set_fw_bt_psd_mode(struct btc_coexist *btcoexist,
 
         h2c_parameter[1] = bt_psd_mode;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set BT PSD mode = 0x%x, FW write 0x69 = 0x%x\n",
-                  h2c_parameter[1],
-                  h2c_parameter[0]<<8|h2c_parameter[1]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set BT PSD mode = 0x%x, FW write 0x69 = 0x%x\n",
+                    h2c_parameter[1],
+                    h2c_parameter[0] << 8 | h2c_parameter[1]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 2, h2c_parameter);
 }
@@ -680,15 +669,15 @@ static void halbtc8821a2ant_set_fw_bt_psd_mode(struct btc_coexist *btcoexist,
 static void halbtc8821a2ant_set_bt_psd_mode(struct btc_coexist *btcoexist,
                                             bool force_exec, u8 bt_psd_mode)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s BT PSD mode = 0x%x\n",
-                  (force_exec ? "force" : ""), bt_psd_mode);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s BT PSD mode = 0x%x\n",
+                    (force_exec ? "force" : ""), bt_psd_mode);
         coex_dm->cur_bt_psd_mode = bt_psd_mode;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_bt_psd_mode = 0x%x, cur_bt_psd_mode = 0x%x\n",
-                          coex_dm->pre_bt_psd_mode, coex_dm->cur_bt_psd_mode);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_bt_psd_mode = 0x%x, cur_bt_psd_mode = 0x%x\n",
+                            coex_dm->pre_bt_psd_mode, coex_dm->cur_bt_psd_mode);
 
                 if (coex_dm->pre_bt_psd_mode == coex_dm->cur_bt_psd_mode)
                         return;
@@ -709,10 +698,10 @@ static void halbtc8821a2ant_set_bt_auto_report(struct btc_coexist *btcoexist,
         if (enable_auto_report)
                 h2c_parameter[0] |= BIT0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
-                  (enable_auto_report ? "Enabled!!" : "Disabled!!"),
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
+                    (enable_auto_report ? "Enabled!!" : "Disabled!!"),
+                    h2c_parameter[0]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 }
@@ -721,17 +710,17 @@ static void halbtc8821a2ant_bt_auto_report(struct btc_coexist *btcoexist,
                                            bool force_exec,
                                            bool enable_auto_report)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s BT Auto report = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((enable_auto_report) ? "Enabled" : "Disabled"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s BT Auto report = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((enable_auto_report) ? "Enabled" : "Disabled"));
         coex_dm->cur_bt_auto_report = enable_auto_report;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_bt_auto_report = %d, cur_bt_auto_report = %d\n",
-                          coex_dm->pre_bt_auto_report,
-                          coex_dm->cur_bt_auto_report);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_bt_auto_report = %d, cur_bt_auto_report = %d\n",
+                            coex_dm->pre_bt_auto_report,
+                            coex_dm->cur_bt_auto_report);
 
                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
                         return;
@@ -746,16 +735,16 @@ static void halbtc8821a2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
                                              bool force_exec,
                                              u8 fw_dac_swing_lvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s set FW Dac Swing level = %d\n",
-                  (force_exec ? "force to" : ""), fw_dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s set FW Dac Swing level = %d\n",
+                    (force_exec ? "force to" : ""), fw_dac_swing_lvl);
         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_fw_dac_swing_lvl = %d, cur_fw_dac_swing_lvl = %d\n",
-                          coex_dm->pre_fw_dac_swing_lvl,
-                          coex_dm->cur_fw_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_fw_dac_swing_lvl = %d, cur_fw_dac_swing_lvl = %d\n",
+                            coex_dm->pre_fw_dac_swing_lvl,
+                            coex_dm->cur_fw_dac_swing_lvl);
 
                 if (coex_dm->pre_fw_dac_swing_lvl ==
                     coex_dm->cur_fw_dac_swing_lvl)
@@ -773,8 +762,8 @@ static void btc8821a2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 {
         if (rx_rf_shrink_on) {
                 /* Shrink RF Rx LPF corner */
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], Shrink RF Rx LPF corner!!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], Shrink RF Rx LPF corner!!\n");
                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
                                           0xfffff, 0xffffc);
         } else {
@@ -782,8 +771,8 @@ static void btc8821a2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
                  * After initialized, we can use coex_dm->bt_rf0x1e_backup
                  */
                 if (btcoexist->initilized) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                                  "[BTCoex], Resume RF Rx LPF corner!!\n");
+                        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                                    "[BTCoex], Resume RF Rx LPF corner!!\n");
                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
                                                   0x1e, 0xfffff,
                                                    coex_dm->bt_rf0x1e_backup);
@@ -794,17 +783,17 @@ static void btc8821a2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 static void halbtc8821a2ant_RfShrink(struct btc_coexist *btcoexist,
                                      bool force_exec, bool rx_rf_shrink_on)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn Rx RF Shrink = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((rx_rf_shrink_on) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn Rx RF Shrink = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((rx_rf_shrink_on) ? "ON" : "OFF"));
         coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], pre_rf_rx_lpf_shrink = %d, cur_rf_rx_lpf_shrink = %d\n",
-                          coex_dm->pre_rf_rx_lpf_shrink,
-                          coex_dm->cur_rf_rx_lpf_shrink);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], pre_rf_rx_lpf_shrink = %d, cur_rf_rx_lpf_shrink = %d\n",
+                            coex_dm->pre_rf_rx_lpf_shrink,
+                            coex_dm->cur_rf_rx_lpf_shrink);
 
                 if (coex_dm->pre_rf_rx_lpf_shrink ==
                     coex_dm->cur_rf_rx_lpf_shrink)
@@ -835,9 +824,9 @@ static void btc8821a2ant_SetSwPenTxRateAdapt(struct btc_coexist *btcoexist,
                 h2c_parameter[5] = 0xf9;
         }
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
-                  (low_penalty_ra ? "ON!!" : "OFF!!"));
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set WiFi Low-Penalty Retry: %s",
+                    (low_penalty_ra ? "ON!!" : "OFF!!"));
 
         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 }
@@ -846,17 +835,17 @@ static void halbtc8821a2ant_low_penalty_ra(struct btc_coexist *btcoexist,
                                            bool force_exec, bool low_penalty_ra)
 {
         /*return;*/
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn LowPenaltyRA = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((low_penalty_ra) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn LowPenaltyRA = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((low_penalty_ra) ? "ON" : "OFF"));
         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], pre_low_penalty_ra = %d, cur_low_penalty_ra = %d\n",
-                          coex_dm->pre_low_penalty_ra,
-                          coex_dm->cur_low_penalty_ra);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], pre_low_penalty_ra = %d, cur_low_penalty_ra = %d\n",
+                            coex_dm->pre_low_penalty_ra,
+                            coex_dm->cur_low_penalty_ra);
 
                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
                         return;
@@ -872,8 +861,8 @@ static void halbtc8821a2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
 {
         u8 val = (u8)level;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], Write SwDacSwing = 0x%x\n", level);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], Write SwDacSwing = 0x%x\n", level);
         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc5b, 0x3e, val);
 }
 
@@ -891,21 +880,21 @@ static void halbtc8821a2ant_dac_swing(struct btc_coexist *btcoexist,
                                       bool force_exec, bool dac_swing_on,
                                       u32 dac_swing_lvl)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn DacSwing = %s, dac_swing_lvl = 0x%x\n",
-                  (force_exec ? "force to" : ""),
-                  ((dac_swing_on) ? "ON" : "OFF"),
-                  dac_swing_lvl);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn DacSwing = %s, dac_swing_lvl = 0x%x\n",
+                    (force_exec ? "force to" : ""),
+                    ((dac_swing_on) ? "ON" : "OFF"),
+                    dac_swing_lvl);
         coex_dm->cur_dac_swing_on = dac_swing_on;
         coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], pre_dac_swing_on = %d, pre_dac_swing_lvl = 0x%x, cur_dac_swing_on = %d, cur_dac_swing_lvl = 0x%x\n",
-                          coex_dm->pre_dac_swing_on,
-                          coex_dm->pre_dac_swing_lvl,
-                          coex_dm->cur_dac_swing_on,
-                          coex_dm->cur_dac_swing_lvl);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], pre_dac_swing_on = %d, pre_dac_swing_lvl = 0x%x, cur_dac_swing_on = %d, cur_dac_swing_lvl = 0x%x\n",
+                            coex_dm->pre_dac_swing_on,
+                            coex_dm->pre_dac_swing_lvl,
+                            coex_dm->cur_dac_swing_on,
+                            coex_dm->cur_dac_swing_lvl);
 
                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
                     (coex_dm->pre_dac_swing_lvl ==
@@ -924,12 +913,12 @@ static void halbtc8821a2ant_set_adc_back_off(struct btc_coexist *btcoexist,
                                              bool adc_back_off)
 {
         if (adc_back_off) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB BackOff Level On!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB BackOff Level On!\n");
                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x3);
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                          "[BTCoex], BB BackOff Level Off!\n");
+                btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                            "[BTCoex], BB BackOff Level Off!\n");
                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x1);
         }
 }
@@ -937,16 +926,17 @@ static void halbtc8821a2ant_set_adc_back_off(struct btc_coexist *btcoexist,
 static void halbtc8821a2ant_adc_back_off(struct btc_coexist *btcoexist,
                                          bool force_exec, bool adc_back_off)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s turn AdcBackOff = %s\n",
-                  (force_exec ? "force to" : ""),
-                  ((adc_back_off) ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s turn AdcBackOff = %s\n",
+                    (force_exec ? "force to" : ""),
+                    ((adc_back_off) ? "ON" : "OFF"));
         coex_dm->cur_adc_back_off = adc_back_off;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], pre_adc_back_off = %d, cur_adc_back_off = %d\n",
-                          coex_dm->pre_adc_back_off, coex_dm->cur_adc_back_off);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], pre_adc_back_off = %d, cur_adc_back_off = %d\n",
+                            coex_dm->pre_adc_back_off,
+                            coex_dm->cur_adc_back_off);
 
                 if (coex_dm->pre_adc_back_off == coex_dm->cur_adc_back_off)
                         return;
@@ -960,20 +950,20 @@ static void halbtc8821a2ant_set_coex_table(struct btc_coexist *btcoexist,
                                            u32 val0x6c0, u32 val0x6c4,
                                            u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
-                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW_EXEC,
+                    "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 }
 
@@ -981,28 +971,28 @@ static void halbtc8821a2ant_coex_table(struct btc_coexist *btcoexist,
                                        bool force_exec, u32 val0x6c0,
                                        u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
-                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
-                  (force_exec ? "force to" : ""),
-                  val0x6c0, val0x6c4, val0x6c8, val0x6cc);
+        btc_alg_dbg(ALGO_TRACE_SW,
+                    "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
+                    (force_exec ? "force to" : ""),
+                    val0x6c0, val0x6c4, val0x6c8, val0x6cc);
         coex_dm->cur_val0x6c0 = val0x6c0;
         coex_dm->cur_val0x6c4 = val0x6c4;
         coex_dm->cur_val0x6c8 = val0x6c8;
         coex_dm->cur_val0x6cc = val0x6cc;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], pre_val0x6c0 = 0x%x, pre_val0x6c4 = 0x%x, pre_val0x6c8 = 0x%x, pre_val0x6cc = 0x%x !!\n",
-                          coex_dm->pre_val0x6c0,
-                          coex_dm->pre_val0x6c4,
-                          coex_dm->pre_val0x6c8,
-                          coex_dm->pre_val0x6cc);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
-                          "[BTCoex], cur_val0x6c0 = 0x%x, cur_val0x6c4 = 0x%x, cur_val0x6c8 = 0x%x, cur_val0x6cc = 0x%x !!\n",
-                          coex_dm->cur_val0x6c0,
-                          coex_dm->cur_val0x6c4,
-                          coex_dm->cur_val0x6c8,
-                          coex_dm->cur_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], pre_val0x6c0 = 0x%x, pre_val0x6c4 = 0x%x, pre_val0x6c8 = 0x%x, pre_val0x6cc = 0x%x !!\n",
+                            coex_dm->pre_val0x6c0,
+                            coex_dm->pre_val0x6c4,
+                            coex_dm->pre_val0x6c8,
+                            coex_dm->pre_val0x6cc);
+                btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
+                            "[BTCoex], cur_val0x6c0 = 0x%x, cur_val0x6c4 = 0x%x, cur_val0x6c8 = 0x%x, cur_val0x6cc = 0x%x !!\n",
+                            coex_dm->cur_val0x6c0,
+                            coex_dm->cur_val0x6c4,
+                            coex_dm->cur_val0x6c8,
+                            coex_dm->cur_val0x6cc);
 
                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
@@ -1027,9 +1017,9 @@ static void halbtc8821a2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoex,
         if (enable)
                 h2c_parameter[0] |= BIT0;/* function enable */
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
-                  h2c_parameter[0]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
+                    h2c_parameter[0]);
 
         btcoex->btc_fill_h2c(btcoex, 0x63, 1, h2c_parameter);
 }
@@ -1037,16 +1027,16 @@ static void halbtc8821a2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoex,
 static void halbtc8821a2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
                                             bool force_exec, bool enable)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn Ignore WlanAct %s\n",
-                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn Ignore WlanAct %s\n",
+                    (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
         coex_dm->cur_ignore_wlan_act = enable;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
-                          coex_dm->pre_ignore_wlan_act,
-                          coex_dm->cur_ignore_wlan_act);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
+                            coex_dm->pre_ignore_wlan_act,
+                            coex_dm->cur_ignore_wlan_act);
 
                 if (coex_dm->pre_ignore_wlan_act ==
                     coex_dm->cur_ignore_wlan_act)
@@ -1075,13 +1065,13 @@ static void halbtc8821a2ant_set_fw_pstdma(struct btc_coexist *btcoexist,
         coex_dm->ps_tdma_para[3] = byte4;
         coex_dm->ps_tdma_para[4] = byte5;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
-                  h2c_parameter[0],
-                  h2c_parameter[1]<<24|
-                  h2c_parameter[2]<<16|
-                  h2c_parameter[3]<<8|
-                  h2c_parameter[4]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
+                    h2c_parameter[0],
+                    h2c_parameter[1] << 24 |
+                    h2c_parameter[2] << 16 |
+                    h2c_parameter[3] << 8 |
+                    h2c_parameter[4]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 }
@@ -1175,20 +1165,20 @@ static void halbtc8821a2ant_set_ant_path(struct btc_coexist *btcoexist,
 static void halbtc8821a2ant_ps_tdma(struct btc_coexist *btcoexist,
                                     bool force_exec, bool turn_on, u8 type)
 {
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], %s turn %s PS TDMA, type = %d\n",
-                  (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"),
-                  type);
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], %s turn %s PS TDMA, type = %d\n",
+                    (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"),
+                    type);
         coex_dm->cur_ps_tdma_on = turn_on;
         coex_dm->cur_ps_tdma = type;
 
         if (!force_exec) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n",
-                          coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n",
-                          coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n",
+                            coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n",
+                            coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
 
                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
@@ -1374,8 +1364,8 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
                                    &low_pwr_disable);
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi IPS + BT IPS!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi IPS + BT IPS!!\n");
 
                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
@@ -1392,13 +1382,13 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                                    &low_pwr_disable);
 
                 if (wifi_busy) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Busy + BT IPS!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Busy + BT IPS!!\n");
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 false, 1);
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi LPS + BT IPS!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi LPS + BT IPS!!\n");
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 false, 1);
                 }
@@ -1416,8 +1406,8 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
                                    &low_pwr_disable);
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi IPS + BT LPS!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi IPS + BT LPS!!\n");
 
                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
@@ -1433,13 +1423,13 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                         BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_disable);
 
                 if (wifi_busy) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Busy + BT LPS!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Busy + BT LPS!!\n");
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 false, 1);
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi LPS + BT LPS!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi LPS + BT LPS!!\n");
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 false, 1);
                 }
@@ -1458,8 +1448,8 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                 btcoexist->btc_set(btcoexist,
                         BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_disable);
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Wifi IPS + BT Busy!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Wifi IPS + BT Busy!!\n");
 
                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
@@ -1478,12 +1468,12 @@ static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
                                    &low_pwr_disable);
 
                 if (wifi_busy) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi Busy + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi Busy + BT Busy!!\n");
                         common = false;
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Wifi LPS + BT Busy!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Wifi LPS + BT Busy!!\n");
                         halbtc8821a2ant_ps_tdma(btcoexist,
                                                 NORMAL_EXEC, true, 21);
 
@@ -1505,8 +1495,8 @@ static void btc8821a2_int1(struct btc_coexist *btcoexist, bool tx_pause,
                            int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
 
                 if (coex_dm->cur_ps_tdma == 71) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
@@ -1601,8 +1591,8 @@ static void btc8821a2_int1(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 71);
@@ -1706,8 +1696,8 @@ static void btc8821a2_int2(struct btc_coexist *btcoexist, bool tx_pause,
                            int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 6);
@@ -1796,8 +1786,8 @@ static void btc8821a2_int2(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 2);
@@ -1892,8 +1882,8 @@ static void btc8821a2_int3(struct btc_coexist *btcoexist, bool tx_pause,
                            int result)
 {
         if (tx_pause) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 1\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 1\n");
                 if (coex_dm->cur_ps_tdma == 1) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 7);
@@ -1982,8 +1972,8 @@ static void btc8821a2_int3(struct btc_coexist *btcoexist, bool tx_pause,
                         }
                 }
         } else {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], TxPause = 0\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], TxPause = 0\n");
                 if (coex_dm->cur_ps_tdma == 5) {
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
                                                 true, 3);
@@ -2085,13 +2075,13 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
         int             result;
         u8              retry_count = 0;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
-                  "[BTCoex], TdmaDurationAdjust()\n");
+        btc_alg_dbg(ALGO_TRACE_FW,
+                    "[BTCoex], TdmaDurationAdjust()\n");
 
         if (coex_dm->reset_tdma_adjust) {
                 coex_dm->reset_tdma_adjust = false;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], first run TdmaDurationAdjust()!!\n");
                 if (sco_hid) {
                         if (tx_pause) {
                                 if (max_interval == 1) {
@@ -2195,11 +2185,11 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
         } else {
                 /* accquire the BT TRx retry count from BT_Info byte2 */
                 retry_count = coex_sta->bt_retry_cnt;
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], retry_count = %d\n", retry_count);
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
-                          (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], retry_count = %d\n", retry_count);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
+                            (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
                 result = 0;
                 wait_count++;
 
@@ -2220,9 +2210,8 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                                 up = 0;
                                 dn = 0;
                                 result = 1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Increase wifi duration!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Increase wifi duration!!\n");
                         }
                 } else if (retry_count <= 3) {
                         /* <=3 retry in the last 2-second duration */
@@ -2251,9 +2240,8 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                                 dn = 0;
                                 wait_count = 0;
                                 result = -1;
-                                BTC_PRINT(BTC_MSG_ALGORITHM,
-                                          ALGO_TRACE_FW_DETAIL,
-                                          "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
+                                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                            "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
                         }
                 } else {
                         /* retry count > 3, if retry count > 3 happens once,
@@ -2274,12 +2262,12 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                         dn = 0;
                         wait_count = 0;
                         result = -1;
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
                 }
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], max Interval = %d\n", max_interval);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], max Interval = %d\n", max_interval);
                 if (max_interval == 1)
                         btc8821a2_int1(btcoexist, tx_pause, result);
                 else if (max_interval == 2)
@@ -2295,9 +2283,9 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
         if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
                 bool    scan = false, link = false, roam = false;
 
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                          "[BTCoex], PsTdma type dismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
-                          coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
+                btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                            "[BTCoex], PsTdma type dismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
+                            coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
 
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
@@ -2307,8 +2295,8 @@ static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
                                                 coex_dm->tdma_adj_type);
                 } else {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
-                                  "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
+                        btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
+                                    "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
                 }
         }
 
@@ -3183,8 +3171,8 @@ static void halbtc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         u8      algorithm = 0;
 
         if (btcoexist->manual_control) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Manual control!!!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Manual control!!!\n");
                 return;
         }
 
@@ -3192,8 +3180,8 @@ static void halbtc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
                 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
 
         if (wifi_under_5g) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
                 halbtc8821a2ant_coex_under_5g(btcoexist);
                 return;
         }
@@ -3201,81 +3189,82 @@ static void halbtc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
         algorithm = halbtc8821a2ant_action_algorithm(btcoexist);
         if (coex_sta->c2h_bt_inquiry_page &&
             (BT_8821A_2ANT_COEX_ALGO_PANHS != algorithm)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], BT is under inquiry/page scan !!\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], BT is under inquiry/page scan !!\n");
                 halbtc8821a2ant_bt_inquiry_page(btcoexist);
                 return;
         }
 
         coex_dm->cur_algorithm = algorithm;
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
 
         if (halbtc8821a2ant_is_common_action(btcoexist)) {
-                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                          "[BTCoex], Action 2-Ant common.\n");
+                btc_alg_dbg(ALGO_TRACE,
+                            "[BTCoex], Action 2-Ant common\n");
                 coex_dm->reset_tdma_adjust = true;
         } else {
                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
-                        coex_dm->pre_algorithm, coex_dm->cur_algorithm);
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
+                                    coex_dm->pre_algorithm,
+                                    coex_dm->cur_algorithm);
                         coex_dm->reset_tdma_adjust = true;
                 }
                 switch (coex_dm->cur_algorithm) {
                 case BT_8821A_2ANT_COEX_ALGO_SCO:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = SCO\n");
                         halbtc8821a2ant_action_sco(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID\n");
                         halbtc8821a2ant_action_hid(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
                         halbtc8821a2ant_action_a2dp(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
                         halbtc8821a2ant_action_a2dp_pan_hs(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
                         halbtc8821a2ant_action_pan_edr(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_PANHS:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = HS mode.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
                         halbtc8821a2ant_action_pan_hs(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
                         halbtc8821a2ant_action_pan_edr_a2dp(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_PANEDR_HID:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
                         halbtc8821a2ant_action_pan_edr_hid(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
                         btc8821a2ant_act_hid_a2dp_pan_edr(btcoexist);
                         break;
                 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
                         halbtc8821a2ant_action_hid_a2dp(btcoexist);
                         break;
                 default:
-                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                                  "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
+                        btc_alg_dbg(ALGO_TRACE,
+                                    "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
                         halbtc8821a2ant_coex_all_off(btcoexist);
                         break;
                 }
@@ -3294,8 +3283,8 @@ void ex_halbtc8821a2ant_init_hwconfig(struct btc_coexist *btcoexist)
 {
         u8 u1tmp = 0;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], 2Ant Init HW Config!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], 2Ant Init HW Config!!\n");
 
         /* backup rf 0x1e value */
         coex_dm->bt_rf0x1e_backup =
@@ -3328,8 +3317,8 @@ ex_halbtc8821a2ant_init_coex_dm(
         struct btc_coexist *btcoexist
         )
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                  "[BTCoex], Coex Mechanism Init!!\n");
+        btc_iface_dbg(INTF_INIT,
+                      "[BTCoex], Coex Mechanism Init!!\n");
 
         halbtc8821a2ant_init_coex_dm(btcoexist);
 }
@@ -3574,13 +3563,13 @@ ex_halbtc8821a2ant_display_coex_info(
 void ex_halbtc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_IPS_ENTER == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS ENTER notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS ENTER notify\n");
                 coex_sta->under_ips = true;
                 halbtc8821a2ant_coex_all_off(btcoexist);
         } else if (BTC_IPS_LEAVE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], IPS LEAVE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], IPS LEAVE notify\n");
                 coex_sta->under_ips = false;
                 /*halbtc8821a2ant_init_coex_dm(btcoexist);*/
         }
@@ -3589,12 +3578,12 @@ void ex_halbtc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_halbtc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_LPS_ENABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS ENABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS ENABLE notify\n");
                 coex_sta->under_lps = true;
         } else if (BTC_LPS_DISABLE == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], LPS DISABLE notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], LPS DISABLE notify\n");
                 coex_sta->under_lps = false;
         }
 }
@@ -3602,22 +3591,22 @@ void ex_halbtc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
 void ex_halbtc8821a2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_SCAN_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN START notify\n");
         } else if (BTC_SCAN_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], SCAN FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], SCAN FINISH notify\n");
         }
 }
 
 void ex_halbtc8821a2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
 {
         if (BTC_ASSOCIATE_START == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT START notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT START notify\n");
         } else if (BTC_ASSOCIATE_FINISH == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], CONNECT FINISH notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], CONNECT FINISH notify\n");
         }
 }
 
@@ -3629,11 +3618,11 @@ void ex_halbtc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
         u8      wifi_central_chnl;
 
         if (BTC_MEDIA_CONNECT == type) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA connect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA connect notify\n");
         } else {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], MEDIA disconnect notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], MEDIA disconnect notify\n");
         }
 
         /* only 2.4G we need to inform bt the chnl mask*/
@@ -3654,9 +3643,11 @@ void ex_halbtc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
-                  "[BTCoex], FW write 0x66 = 0x%x\n",
-                h2c_parameter[0]<<16|h2c_parameter[1]<<8|h2c_parameter[2]);
+        btc_alg_dbg(ALGO_TRACE_FW_EXEC,
+                    "[BTCoex], FW write 0x66 = 0x%x\n",
+                    h2c_parameter[0] << 16 |
+                    h2c_parameter[1] << 8 |
+                    h2c_parameter[2]);
 
         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 }
@@ -3664,8 +3655,8 @@ void ex_halbtc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
 void ex_halbtc8821a2ant_special_packet_notify(struct btc_coexist *btcoexist,
                                               u8 type) {
         if (type == BTC_PACKET_DHCP) {
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                          "[BTCoex], DHCP Packet notify\n");
+                btc_iface_dbg(INTF_NOTIFY,
+                              "[BTCoex], DHCP Packet notify\n");
         }
 }
 
@@ -3685,19 +3676,19 @@ void ex_halbtc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
                 rsp_source = BT_INFO_SRC_8821A_2ANT_WIFI_FW;
         coex_sta->bt_info_c2h_cnt[rsp_source]++;
 
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Bt info[%d], length = %d, hex data = [",
-                  rsp_source, length);
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Bt info[%d], length = %d, hex data = [",
+                      rsp_source, length);
         for (i = 0; i < length; i++) {
                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
                 if (i == 1)
                         bt_info = tmp_buf[i];
                 if (i == length-1) {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x]\n", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x]\n", tmp_buf[i]);
                 } else {
-                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                                  "0x%02x, ", tmp_buf[i]);
+                        btc_iface_dbg(INTF_NOTIFY,
+                                      "0x%02x, ", tmp_buf[i]);
                 }
         }
 
@@ -3823,8 +3814,8 @@ void ex_halbtc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
 
 void ex_halbtc8821a2ant_halt_notify(struct btc_coexist *btcoexist)
 {
-        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
-                  "[BTCoex], Halt notify\n");
+        btc_iface_dbg(INTF_NOTIFY,
+                      "[BTCoex], Halt notify\n");
 
         halbtc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
         ex_halbtc8821a2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
@@ -3837,31 +3828,31 @@ void ex_halbtc8821a2ant_periodical(struct btc_coexist *btcoexist)
         struct btc_board_info *board_info = &btcoexist->board_info;
         struct btc_stack_info *stack_info = &btcoexist->stack_info;
 
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "[BTCoex], ==========================Periodical===========================\n");
+        btc_alg_dbg(ALGO_TRACE,
+                    "[BTCoex], ==========================Periodical===========================\n");
 
         if (dis_ver_info_cnt <= 5) {
                 dis_ver_info_cnt += 1;
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
-                          board_info->pg_ant_num,
-                          board_info->btdm_ant_num,
-                          board_info->btdm_ant_pos);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
-                          ((stack_info->profile_notified) ? "Yes" : "No"),
-                          stack_info->hci_version);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
+                              board_info->pg_ant_num,
+                              board_info->btdm_ant_num,
+                              board_info->btdm_ant_pos);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
+                              stack_info->profile_notified ? "Yes" : "No",
+                              stack_info->hci_version);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
                                    &bt_patch_ver);
                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
-                          glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
-                          fw_ver, bt_patch_ver, bt_patch_ver);
-                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
-                          "[BTCoex], ****************************************************************\n");
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
+                              glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
+                              fw_ver, bt_patch_ver, bt_patch_ver);
+                btc_iface_dbg(INTF_INIT,
+                              "[BTCoex], ****************************************************************\n");
         }
 
         halbtc8821a2ant_query_bt_info(btcoexist);
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.c
index b2791c893417..b660c214dc71 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.c
@@ -141,8 +141,8 @@ static u8 halbtc_get_wifi_central_chnl(struct btc_coexist *btcoexist)
 
         if (rtlphy->current_channel != 0)
                 chnl = rtlphy->current_channel;
-        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
-                  "static halbtc_get_wifi_central_chnl:%d\n", chnl);
+        btc_alg_dbg(ALGO_TRACE,
+                    "static halbtc_get_wifi_central_chnl:%d\n", chnl);
         return chnl;
 }
 
@@ -965,13 +965,38 @@ void exhalbtc_set_chip_type(u8 chip_type)
         }
 }
 
-void exhalbtc_set_ant_num(u8 type, u8 ant_num)
+void exhalbtc_set_ant_num(struct rtl_priv *rtlpriv, u8 type, u8 ant_num)
 {
         if (BT_COEX_ANT_TYPE_PG == type) {
                 gl_bt_coexist.board_info.pg_ant_num = ant_num;
                 gl_bt_coexist.board_info.btdm_ant_num = ant_num;
+                /* The antenna position:
+                 * Main (default) or Aux for pgAntNum=2 && btdmAntNum =1.
+                 * The antenna position should be determined by
+                 * auto-detect mechanism.
+                 * The following is assumed to main,
+                 * and those must be modified
+                 * if y auto-detect mechanism is ready
+                 */
+                if ((gl_bt_coexist.board_info.pg_ant_num == 2) &&
+                    (gl_bt_coexist.board_info.btdm_ant_num == 1))
+                        gl_bt_coexist.board_info.btdm_ant_pos =
+                                                       BTC_ANTENNA_AT_MAIN_PORT;
+                else
+                        gl_bt_coexist.board_info.btdm_ant_pos =
+                                                       BTC_ANTENNA_AT_MAIN_PORT;
         } else if (BT_COEX_ANT_TYPE_ANTDIV == type) {
                 gl_bt_coexist.board_info.btdm_ant_num = ant_num;
+                gl_bt_coexist.board_info.btdm_ant_pos =
+                                                       BTC_ANTENNA_AT_MAIN_PORT;
+        } else if (type == BT_COEX_ANT_TYPE_DETECTED) {
+                gl_bt_coexist.board_info.btdm_ant_num = ant_num;
+                if (rtlpriv->cfg->mod_params->ant_sel == 1)
+                        gl_bt_coexist.board_info.btdm_ant_pos =
+                                BTC_ANTENNA_AT_AUX_PORT;
+                else
+                        gl_bt_coexist.board_info.btdm_ant_pos =
+                                BTC_ANTENNA_AT_MAIN_PORT;
         }
 }
 
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.h b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.h
index 0a903ea179ef..3cbe34c535ec 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.h
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtcoutsrc.h
@@ -116,12 +116,17 @@ extern u32 btc_dbg_type[];
 #define         WIFI_P2P_GO_CONNECTED                   BIT3
 #define         WIFI_P2P_GC_CONNECTED                   BIT4
 
-#define BTC_PRINT(dbgtype, dbgflag, printstr, ...)              \
-        do {                                                    \
-                if (unlikely(btc_dbg_type[dbgtype] & dbgflag)) {\
-                        printk(printstr, ##__VA_ARGS__);        \
-                }                                               \
-        } while (0)
+#define btc_alg_dbg(dbgflag, fmt, ...)                                  \
+do {                                                                    \
+        if (unlikely(btc_dbg_type[BTC_MSG_ALGORITHM] & dbgflag))        \
+                printk(KERN_DEBUG fmt, ##__VA_ARGS__);                  \
+} while (0)
+#define btc_iface_dbg(dbgflag, fmt, ...)                                \
+do {                                                                    \
+        if (unlikely(btc_dbg_type[BTC_MSG_INTERFACE] & dbgflag))        \
+                printk(KERN_DEBUG fmt, ##__VA_ARGS__);                  \
+} while (0)
+
 
 #define BTC_RSSI_HIGH(_rssi_)   \
         ((_rssi_ == BTC_RSSI_STATE_HIGH ||      \
@@ -535,7 +540,7 @@ void exhalbtc_set_bt_patch_version(u16 bt_hci_version, u16 bt_patch_version);
 void exhalbtc_update_min_bt_rssi(char bt_rssi);
 void exhalbtc_set_bt_exist(bool bt_exist);
 void exhalbtc_set_chip_type(u8 chip_type);
-void exhalbtc_set_ant_num(u8 type, u8 ant_num);
+void exhalbtc_set_ant_num(struct rtl_priv *rtlpriv, u8 type, u8 ant_num);
 void exhalbtc_display_bt_coex_info(struct btc_coexist *btcoexist);
 void exhalbtc_signal_compensation(struct btc_coexist *btcoexist,
                                   u8 *rssi_wifi, u8 *rssi_bt);
diff --git a/drivers/net/wireless/realtek/rtlwifi/btcoexist/rtl_btc.c b/drivers/net/wireless/realtek/rtlwifi/btcoexist/rtl_btc.c
index b9b0cb7af8ea..d3fd9211b3a4 100644
--- a/drivers/net/wireless/realtek/rtlwifi/btcoexist/rtl_btc.c
+++ b/drivers/net/wireless/realtek/rtlwifi/btcoexist/rtl_btc.c
@@ -72,7 +72,10 @@ void rtl_btc_init_hal_vars(struct rtl_priv *rtlpriv)
                  __func__, bt_type);
         exhalbtc_set_chip_type(bt_type);
 
-        exhalbtc_set_ant_num(BT_COEX_ANT_TYPE_PG, ant_num);
+        if (rtlpriv->cfg->mod_params->ant_sel == 1)
+                exhalbtc_set_ant_num(rtlpriv, BT_COEX_ANT_TYPE_DETECTED, 1);
+        else
+                exhalbtc_set_ant_num(rtlpriv, BT_COEX_ANT_TYPE_PG, ant_num);
 }
 
 void rtl_btc_init_hw_config(struct rtl_priv *rtlpriv)
diff --git a/drivers/net/wireless/realtek/rtlwifi/pci.c b/drivers/net/wireless/realtek/rtlwifi/pci.c
index 283d608b9973..1ac41b8bd19a 100644
--- a/drivers/net/wireless/realtek/rtlwifi/pci.c
+++ b/drivers/net/wireless/realtek/rtlwifi/pci.c
@@ -359,30 +359,28 @@ static bool rtl_pci_check_buddy_priv(struct ieee80211_hw *hw,
         struct rtl_priv *rtlpriv = rtl_priv(hw);
         struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
         bool find_buddy_priv = false;
-        struct rtl_priv *tpriv = NULL;
+        struct rtl_priv *tpriv;
         struct rtl_pci_priv *tpcipriv = NULL;
 
         if (!list_empty(&rtlpriv->glb_var->glb_priv_list)) {
                 list_for_each_entry(tpriv, &rtlpriv->glb_var->glb_priv_list,
                                     list) {
-                        if (tpriv) {
-                                tpcipriv = (struct rtl_pci_priv *)tpriv->priv;
-                                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                                         "pcipriv->ndis_adapter.funcnumber %x\n",
-                                        pcipriv->ndis_adapter.funcnumber);
-                                RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
-                                         "tpcipriv->ndis_adapter.funcnumber %x\n",
-                                        tpcipriv->ndis_adapter.funcnumber);
-
-                                if ((pcipriv->ndis_adapter.busnumber ==
-                                     tpcipriv->ndis_adapter.busnumber) &&
-                                    (pcipriv->ndis_adapter.devnumber ==
-                                    tpcipriv->ndis_adapter.devnumber) &&
-                                    (pcipriv->ndis_adapter.funcnumber !=
-                                    tpcipriv->ndis_adapter.funcnumber)) {
-                                        find_buddy_priv = true;
-                                        break;
-                                }
+                        tpcipriv = (struct rtl_pci_priv *)tpriv->priv;
+                        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                 "pcipriv->ndis_adapter.funcnumber %x\n",
+                                pcipriv->ndis_adapter.funcnumber);
+                        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
+                                 "tpcipriv->ndis_adapter.funcnumber %x\n",
+                                tpcipriv->ndis_adapter.funcnumber);
+
+                        if ((pcipriv->ndis_adapter.busnumber ==
+                             tpcipriv->ndis_adapter.busnumber) &&
+                            (pcipriv->ndis_adapter.devnumber ==
+                            tpcipriv->ndis_adapter.devnumber) &&
+                            (pcipriv->ndis_adapter.funcnumber !=
+                            tpcipriv->ndis_adapter.funcnumber)) {
+                                find_buddy_priv = true;
+                                break;
                         }
                 }
         }
@@ -1213,7 +1211,8 @@ static void _rtl_pci_init_struct(struct ieee80211_hw *hw,
         /*Tx/Rx related var */
         _rtl_pci_init_trx_var(hw);
 
-        /*IBSS*/ mac->beacon_interval = 100;
+        /*IBSS*/
+        mac->beacon_interval = 100;
 
         /*AMPDU*/
         mac->min_space_cfg = 0;
diff --git a/drivers/net/wireless/realtek/rtlwifi/regd.c b/drivers/net/wireless/realtek/rtlwifi/regd.c
index 5be34118e0af..3524441fd516 100644
--- a/drivers/net/wireless/realtek/rtlwifi/regd.c
+++ b/drivers/net/wireless/realtek/rtlwifi/regd.c
@@ -154,13 +154,13 @@ static bool _rtl_is_radar_freq(u16 center_freq)
 static void _rtl_reg_apply_beaconing_flags(struct wiphy *wiphy,
                                            enum nl80211_reg_initiator initiator)
 {
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         const struct ieee80211_reg_rule *reg_rule;
         struct ieee80211_channel *ch;
         unsigned int i;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
 
                 if (!wiphy->bands[band])
                         continue;
@@ -210,9 +210,9 @@ static void _rtl_reg_apply_active_scan_flags(struct wiphy *wiphy,
         struct ieee80211_channel *ch;
         const struct ieee80211_reg_rule *reg_rule;
 
-        if (!wiphy->bands[IEEE80211_BAND_2GHZ])
+        if (!wiphy->bands[NL80211_BAND_2GHZ])
                 return;
-        sband = wiphy->bands[IEEE80211_BAND_2GHZ];
+        sband = wiphy->bands[NL80211_BAND_2GHZ];
 
         /*
          *If no country IE has been received always enable active scan
@@ -262,10 +262,10 @@ static void _rtl_reg_apply_radar_flags(struct wiphy *wiphy)
         struct ieee80211_channel *ch;
         unsigned int i;
 
-        if (!wiphy->bands[IEEE80211_BAND_5GHZ])
+        if (!wiphy->bands[NL80211_BAND_5GHZ])
                 return;
 
-        sband = wiphy->bands[IEEE80211_BAND_5GHZ];
+        sband = wiphy->bands[NL80211_BAND_5GHZ];
 
         for (i = 0; i < sband->n_channels; i++) {
                 ch = &sband->channels[i];
@@ -301,12 +301,12 @@ static void _rtl_reg_apply_world_flags(struct wiphy *wiphy,
 
 static void _rtl_dump_channel_map(struct wiphy *wiphy)
 {
-        enum ieee80211_band band;
+        enum nl80211_band band;
         struct ieee80211_supported_band *sband;
         struct ieee80211_channel *ch;
         unsigned int i;
 
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 if (!wiphy->bands[band])
                         continue;
                 sband = wiphy->bands[band];
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/dm.c b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/dm.c
index ce4da9d79fbd..db9a7829d568 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/dm.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/dm.c
@@ -1137,7 +1137,7 @@ void rtl88e_dm_check_txpower_tracking(struct ieee80211_hw *hw)
         } else {
                 RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
                          "Schedule TxPowerTracking !!\n");
-                                dm_txpower_track_cb_therm(hw);
+                dm_txpower_track_cb_therm(hw);
                 rtlpriv->dm.tm_trigger = 0;
         }
 }
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c
index a2bb02c7b837..416a9ba6382e 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8188ee/phy.c
@@ -1903,8 +1903,7 @@ static void _rtl88e_phy_lc_calibrate(struct ieee80211_hw *hw, bool is2t)
         } else {
                 rtl_write_byte(rtlpriv, REG_TXPAUSE, 0x00);
         }
-RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "\n");
-
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "\n");
 }
 
 static void _rtl88e_phy_set_rfpath_switch(struct ieee80211_hw *hw,
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192c/dm_common.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192c/dm_common.c
index 03cbe4cf110b..316be5ff69ca 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192c/dm_common.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192c/dm_common.c
@@ -240,7 +240,7 @@ static void rtl92c_dm_false_alarm_counter_statistics(struct ieee80211_hw *hw)
         ret_value = rtl_get_bbreg(hw, ROFDM_PHYCOUNTER3, MASKDWORD);
         falsealm_cnt->cnt_mcs_fail = (ret_value & 0xffff);
 
-         ret_value = rtl_get_bbreg(hw, ROFDM0_FRAMESYNC, MASKDWORD);
+        ret_value = rtl_get_bbreg(hw, ROFDM0_FRAMESYNC, MASKDWORD);
         falsealm_cnt->cnt_fast_fsync_fail = (ret_value & 0xffff);
         falsealm_cnt->cnt_sb_search_fail = ((ret_value & 0xffff0000) >> 16);
 
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/trx.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/trx.c
index 24eff8ea4c2e..35e6bf7e233d 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/trx.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192ee/trx.c
@@ -368,7 +368,7 @@ bool rtl92ee_rx_query_desc(struct ieee80211_hw *hw,
         status->decrypted = !GET_RX_DESC_SWDEC(pdesc);
         status->rate = (u8)GET_RX_DESC_RXMCS(pdesc);
         status->isampdu = (bool)(GET_RX_DESC_PAGGR(pdesc) == 1);
-                status->timestamp_low = GET_RX_DESC_TSFL(pdesc);
+        status->timestamp_low = GET_RX_DESC_TSFL(pdesc);
         status->is_cck = RTL92EE_RX_HAL_IS_CCK_RATE(status->rate);
 
         status->macid = GET_RX_DESC_MACID(pdesc);
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8192se/phy.c b/drivers/net/wireless/realtek/rtlwifi/rtl8192se/phy.c
index 4b4612fe2fdb..881821f4e243 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8192se/phy.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8192se/phy.c
@@ -645,7 +645,7 @@ bool rtl92s_phy_set_rf_power_state(struct ieee80211_hw *hw,
                                  rtlpriv->psc.state_inap);
                         ppsc->last_sleep_jiffies = jiffies;
                         _rtl92se_phy_set_rf_sleep(hw);
-            break;
+                        break;
         default:
                 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
                          "switch case not processed\n");
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/hal_btc.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/hal_btc.c
index 00a0531cc5f4..44de695dc999 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/hal_btc.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723ae/hal_btc.c
@@ -134,9 +134,9 @@ static bool rtl8723e_dm_bt_need_to_dec_bt_pwr(struct ieee80211_hw *hw)
         if (mgnt_link_status_query(hw) == RT_MEDIA_CONNECT) {
                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_DMESG,
                         "Need to decrease bt power\n");
-                        rtlpriv->btcoexist.cstate |=
-                        BT_COEX_STATE_DEC_BT_POWER;
-                        return true;
+                rtlpriv->btcoexist.cstate |=
+                BT_COEX_STATE_DEC_BT_POWER;
+                return true;
         }
 
         rtlpriv->btcoexist.cstate &= ~BT_COEX_STATE_DEC_BT_POWER;
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
index c983d2fe147f..5a3df9198ddf 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/hw.c
@@ -2684,6 +2684,7 @@ void rtl8723be_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw,
                                               bool auto_load_fail, u8 *hwinfo)
 {
         struct rtl_priv *rtlpriv = rtl_priv(hw);
+        struct rtl_mod_params *mod_params = rtlpriv->cfg->mod_params;
         u8 value;
         u32 tmpu_32;
 
@@ -2702,6 +2703,10 @@ void rtl8723be_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw,
                 rtlpriv->btcoexist.btc_info.ant_num = ANT_X2;
         }
 
+        /* override ant_num / ant_path */
+        if (mod_params->ant_sel)
+                rtlpriv->btcoexist.btc_info.ant_num =
+                        (mod_params->ant_sel == 1 ? ANT_X2 : ANT_X1);
 }
 
 void rtl8723be_bt_reg_init(struct ieee80211_hw *hw)
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c
index b7b73cbe346d..445f681d08c0 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/phy.c
@@ -1723,8 +1723,8 @@ static u8 _rtl8723be_phy_path_a_rx_iqk(struct ieee80211_hw *hw)
 
         /* Allen 20131125 */
         tmp = (reg_eac & 0x03FF0000) >> 16;
-                if ((tmp & 0x200) > 0)
-                        tmp = 0x400 - tmp;
+        if ((tmp & 0x200) > 0)
+                tmp = 0x400 - tmp;
         /* if Tx is OK, check whether Rx is OK */
         if (!(reg_eac & BIT(27)) &&
             (((reg_ea4 & 0x03FF0000) >> 16) != 0x132) &&
@@ -2301,8 +2301,7 @@ static void _rtl8723be_phy_lc_calibrate(struct ieee80211_hw *hw, bool is2t)
         } else {
                 rtl_write_byte(rtlpriv, REG_TXPAUSE, 0x00);
         }
-RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "\n");
-
+        RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "\n");
 }
 
 static void _rtl8723be_phy_set_rfpath_switch(struct ieee80211_hw *hw,
@@ -2606,8 +2605,7 @@ static bool _rtl8723be_phy_set_rf_power_state(struct ieee80211_hw *hw,
                                          "IPS Set eRf nic enable\n");
                                 rtstatus = rtl_ps_enable_nic(hw);
                         } while (!rtstatus && (initializecount < 10));
-                                RT_CLEAR_PS_LEVEL(ppsc,
-                                                  RT_RF_OFF_LEVL_HALT_NIC);
+                        RT_CLEAR_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC);
                 } else {
                         RT_TRACE(rtlpriv, COMP_RF, DBG_DMESG,
                                  "Set ERFON sleeped:%d ms\n",
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/rf.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/rf.c
index 5ed4492d3c80..97f5a0377e7a 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/rf.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/rf.c
@@ -303,8 +303,8 @@ static void _rtl8723be_get_txpower_writeval_by_regulatory(
                                            [chnlgroup][index + (rf ? 8 : 0)] &
                                               (0x7f << (i * 8))) >> (i * 8));
 
-                                        if (pwr_diff_limit[i] > pwr_diff)
-                                                pwr_diff_limit[i] = pwr_diff;
+                                if (pwr_diff_limit[i] > pwr_diff)
+                                        pwr_diff_limit[i] = pwr_diff;
                         }
 
                         customer_limit = (pwr_diff_limit[3] << 24) |
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/sw.c b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/sw.c
index a78eaeda0008..2101793438ed 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8723be/sw.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8723be/sw.c
@@ -273,6 +273,7 @@ static struct rtl_mod_params rtl8723be_mod_params = {
         .msi_support = false,
         .disable_watchdog = false,
         .debug = DBG_EMERG,
+        .ant_sel = 0,
 };
 
 static struct rtl_hal_cfg rtl8723be_hal_cfg = {
@@ -394,6 +395,7 @@ module_param_named(fwlps, rtl8723be_mod_params.fwctrl_lps, bool, 0444);
 module_param_named(msi, rtl8723be_mod_params.msi_support, bool, 0444);
 module_param_named(disable_watchdog, rtl8723be_mod_params.disable_watchdog,
                    bool, 0444);
+module_param_named(ant_sel, rtl8723be_mod_params.ant_sel, int, 0444);
 MODULE_PARM_DESC(swenc, "Set to 1 for software crypto (default 0)\n");
 MODULE_PARM_DESC(ips, "Set to 0 to not use link power save (default 1)\n");
 MODULE_PARM_DESC(swlps, "Set to 1 to use SW control power save (default 0)\n");
@@ -402,6 +404,7 @@ MODULE_PARM_DESC(msi, "Set to 1 to use MSI interrupts mode (default 0)\n");
 MODULE_PARM_DESC(debug, "Set debug level (0-5) (default 0)");
 MODULE_PARM_DESC(disable_watchdog,
                  "Set to 1 to disable the watchdog (default 0)\n");
+MODULE_PARM_DESC(ant_sel, "Set to 1 or 2 to force antenna number (default 0)\n");
 
 static SIMPLE_DEV_PM_OPS(rtlwifi_pm_ops, rtl_pci_suspend, rtl_pci_resume);
 
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
index 95dcbff4673b..e346cb86cb08 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
@@ -1957,9 +1957,9 @@ void rtl8812ae_dm_txpower_tracking_callback_thermalmeter(
                                 rtldm->swing_idx_ofdm_base[p] =
                                         rtldm->swing_idx_ofdm[p];
 
-                        RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
-                                 "pDM_Odm->RFCalibrateInfo.ThermalValue =%d ThermalValue= %d\n",
-                                 rtldm->thermalvalue, thermal_value);
+                RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
+                         "pDM_Odm->RFCalibrateInfo.ThermalValue =%d ThermalValue= %d\n",
+                         rtldm->thermalvalue, thermal_value);
                 /*Record last Power Tracking Thermal Value*/
                 rtldm->thermalvalue = thermal_value;
         }
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c
index 74165b3eb362..ddf74d527017 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/phy.c
@@ -418,9 +418,9 @@ u32 phy_get_tx_swing_8812A(struct ieee80211_hw *hw, u8	band,
                         out = 0x16A; /* -3 dB */
                 }
         } else {
-            u32 swing = 0, swing_a = 0, swing_b = 0;
+                u32 swing = 0, swing_a = 0, swing_b = 0;
 
-            if (band == BAND_ON_2_4G) {
+                if (band == BAND_ON_2_4G) {
                         if (reg_swing_2g == auto_temp) {
                                 efuse_shadow_read(hw, 1, 0xC6, (u32 *)&swing);
                                 swing = (swing == 0xFF) ? 0x00 : swing;
@@ -514,7 +514,7 @@ u32 phy_get_tx_swing_8812A(struct ieee80211_hw *hw, u8	band,
 
         RT_TRACE(rtlpriv, COMP_SCAN, DBG_LOUD,
                  "<=== PHY_GetTxBBSwing_8812A, out = 0x%X\n", out);
-         return out;
+        return out;
 }
 
 void rtl8821ae_phy_switch_wirelessband(struct ieee80211_hw *hw, u8 band)
diff --git a/drivers/net/wireless/realtek/rtlwifi/wifi.h b/drivers/net/wireless/realtek/rtlwifi/wifi.h
index 554d81420f19..11d9c2307e2f 100644
--- a/drivers/net/wireless/realtek/rtlwifi/wifi.h
+++ b/drivers/net/wireless/realtek/rtlwifi/wifi.h
@@ -1359,7 +1359,7 @@ struct rtl_mac {
         u32 tx_ss_num;
         u32 rx_ss_num;
 
-        struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
         struct ieee80211_hw *hw;
         struct ieee80211_vif *vif;
         enum nl80211_iftype opmode;
@@ -2246,6 +2246,9 @@ struct rtl_mod_params {
 
         /* default 0: 1 means do not disable interrupts */
         bool int_clear;
+
+        /* select antenna */
+        int ant_sel;
 };
 
 struct rtl_hal_usbint_cfg {
@@ -2867,7 +2870,7 @@ value to host byte ordering.*/
         (ppsc->cur_ps_level |= _ps_flg)
 
 #define container_of_dwork_rtl(x, y, z) \
-        container_of(container_of(x, struct delayed_work, work), y, z)
+        container_of(to_delayed_work(x), y, z)
 
 #define FILL_OCTET_STRING(_os, _octet, _len)    \
                 (_os).octet = (u8 *)(_octet);           \
diff --git a/drivers/net/wireless/rndis_wlan.c b/drivers/net/wireless/rndis_wlan.c
index a13d1f2b5912..569918c485b4 100644
--- a/drivers/net/wireless/rndis_wlan.c
+++ b/drivers/net/wireless/rndis_wlan.c
@@ -1291,7 +1291,7 @@ static int set_channel(struct usbnet *usbdev, int channel)
                 return 0;
 
         dsconfig = 1000 *
-                ieee80211_channel_to_frequency(channel, IEEE80211_BAND_2GHZ);
+                ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
 
         len = sizeof(config);
         ret = rndis_query_oid(usbdev,
@@ -3476,7 +3476,7 @@ static int rndis_wlan_bind(struct usbnet *usbdev, struct usb_interface *intf)
         priv->band.n_channels = ARRAY_SIZE(rndis_channels);
         priv->band.bitrates = priv->rates;
         priv->band.n_bitrates = ARRAY_SIZE(rndis_rates);
-        wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
+        wiphy->bands[NL80211_BAND_2GHZ] = &priv->band;
         wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
 
         memcpy(priv->cipher_suites, rndis_cipher_suites,
diff --git a/drivers/net/wireless/rsi/rsi_91x_mac80211.c b/drivers/net/wireless/rsi/rsi_91x_mac80211.c
index 4df992de7d07..dbb23899ddcb 100644
--- a/drivers/net/wireless/rsi/rsi_91x_mac80211.c
+++ b/drivers/net/wireless/rsi/rsi_91x_mac80211.c
@@ -20,84 +20,84 @@
 #include "rsi_common.h"
 
 static const struct ieee80211_channel rsi_2ghz_channels[] = {
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2412,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2412,
           .hw_value = 1 }, /* Channel 1 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2417,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2417,
           .hw_value = 2 }, /* Channel 2 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2422,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2422,
           .hw_value = 3 }, /* Channel 3 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2427,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2427,
           .hw_value = 4 }, /* Channel 4 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2432,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2432,
           .hw_value = 5 }, /* Channel 5 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2437,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2437,
           .hw_value = 6 }, /* Channel 6 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2442,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2442,
           .hw_value = 7 }, /* Channel 7 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2447,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2447,
           .hw_value = 8 }, /* Channel 8 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2452,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2452,
           .hw_value = 9 }, /* Channel 9 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2457,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2457,
           .hw_value = 10 }, /* Channel 10 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2462,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2462,
           .hw_value = 11 }, /* Channel 11 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2467,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2467,
           .hw_value = 12 }, /* Channel 12 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2472,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2472,
           .hw_value = 13 }, /* Channel 13 */
-        { .band = IEEE80211_BAND_2GHZ, .center_freq = 2484,
+        { .band = NL80211_BAND_2GHZ, .center_freq = 2484,
           .hw_value = 14 }, /* Channel 14 */
 };
 
 static const struct ieee80211_channel rsi_5ghz_channels[] = {
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5180,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5180,
           .hw_value = 36,  }, /* Channel 36 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5200,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5200,
           .hw_value = 40, }, /* Channel 40 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5220,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5220,
           .hw_value = 44, }, /* Channel 44 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5240,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5240,
           .hw_value = 48, }, /* Channel 48 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5260,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5260,
           .hw_value = 52, }, /* Channel 52 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5280,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5280,
           .hw_value = 56, }, /* Channel 56 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5300,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5300,
           .hw_value = 60, }, /* Channel 60 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5320,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5320,
           .hw_value = 64, }, /* Channel 64 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5500,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5500,
           .hw_value = 100, }, /* Channel 100 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5520,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5520,
           .hw_value = 104, }, /* Channel 104 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5540,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5540,
           .hw_value = 108, }, /* Channel 108 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5560,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5560,
           .hw_value = 112, }, /* Channel 112 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5580,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5580,
           .hw_value = 116, }, /* Channel 116 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5600,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5600,
           .hw_value = 120, }, /* Channel 120 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5620,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5620,
           .hw_value = 124, }, /* Channel 124 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5640,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5640,
           .hw_value = 128, }, /* Channel 128 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5660,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5660,
           .hw_value = 132, }, /* Channel 132 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5680,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5680,
           .hw_value = 136, }, /* Channel 136 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5700,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5700,
           .hw_value = 140, }, /* Channel 140 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5745,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5745,
           .hw_value = 149, }, /* Channel 149 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5765,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5765,
           .hw_value = 153, }, /* Channel 153 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5785,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5785,
           .hw_value = 157, }, /* Channel 157 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5805,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5805,
           .hw_value = 161, }, /* Channel 161 */
-        { .band = IEEE80211_BAND_5GHZ, .center_freq = 5825,
+        { .band = NL80211_BAND_5GHZ, .center_freq = 5825,
           .hw_value = 165, }, /* Channel 165 */
 };
 
@@ -150,12 +150,12 @@ static void rsi_register_rates_channels(struct rsi_hw *adapter, int band)
         struct ieee80211_supported_band *sbands = &adapter->sbands[band];
         void *channels = NULL;
 
-        if (band == IEEE80211_BAND_2GHZ) {
+        if (band == NL80211_BAND_2GHZ) {
                 channels = kmalloc(sizeof(rsi_2ghz_channels), GFP_KERNEL);
                 memcpy(channels,
                        rsi_2ghz_channels,
                        sizeof(rsi_2ghz_channels));
-                sbands->band = IEEE80211_BAND_2GHZ;
+                sbands->band = NL80211_BAND_2GHZ;
                 sbands->n_channels = ARRAY_SIZE(rsi_2ghz_channels);
                 sbands->bitrates = rsi_rates;
                 sbands->n_bitrates = ARRAY_SIZE(rsi_rates);
@@ -164,7 +164,7 @@ static void rsi_register_rates_channels(struct rsi_hw *adapter, int band)
                 memcpy(channels,
                        rsi_5ghz_channels,
                        sizeof(rsi_5ghz_channels));
-                sbands->band = IEEE80211_BAND_5GHZ;
+                sbands->band = NL80211_BAND_5GHZ;
                 sbands->n_channels = ARRAY_SIZE(rsi_5ghz_channels);
                 sbands->bitrates = &rsi_rates[4];
                 sbands->n_bitrates = ARRAY_SIZE(rsi_rates) - 4;
@@ -775,7 +775,7 @@ static int rsi_mac80211_set_rate_mask(struct ieee80211_hw *hw,
 {
         struct rsi_hw *adapter = hw->priv;
         struct rsi_common *common = adapter->priv;
-        enum ieee80211_band band = hw->conf.chandef.chan->band;
+        enum nl80211_band band = hw->conf.chandef.chan->band;
 
         mutex_lock(&common->mutex);
         common->fixedrate_mask[band] = 0;
@@ -999,8 +999,8 @@ static int rsi_mac80211_sta_remove(struct ieee80211_hw *hw,
 
         mutex_lock(&common->mutex);
         /* Resetting all the fields to default values */
-        common->bitrate_mask[IEEE80211_BAND_2GHZ] = 0;
-        common->bitrate_mask[IEEE80211_BAND_5GHZ] = 0;
+        common->bitrate_mask[NL80211_BAND_2GHZ] = 0;
+        common->bitrate_mask[NL80211_BAND_5GHZ] = 0;
         common->min_rate = 0xffff;
         common->vif_info[0].is_ht = false;
         common->vif_info[0].sgi = false;
@@ -1070,8 +1070,8 @@ int rsi_mac80211_attach(struct rsi_common *common)
         hw->max_rate_tries = MAX_RETRIES;
 
         hw->max_tx_aggregation_subframes = 6;
-        rsi_register_rates_channels(adapter, IEEE80211_BAND_2GHZ);
-        rsi_register_rates_channels(adapter, IEEE80211_BAND_5GHZ);
+        rsi_register_rates_channels(adapter, NL80211_BAND_2GHZ);
+        rsi_register_rates_channels(adapter, NL80211_BAND_5GHZ);
         hw->rate_control_algorithm = "AARF";
 
         SET_IEEE80211_PERM_ADDR(hw, common->mac_addr);
@@ -1087,10 +1087,10 @@ int rsi_mac80211_attach(struct rsi_common *common)
 
         wiphy->available_antennas_rx = 1;
         wiphy->available_antennas_tx = 1;
-        wiphy->bands[IEEE80211_BAND_2GHZ] =
-                &adapter->sbands[IEEE80211_BAND_2GHZ];
-        wiphy->bands[IEEE80211_BAND_5GHZ] =
-                &adapter->sbands[IEEE80211_BAND_5GHZ];
+        wiphy->bands[NL80211_BAND_2GHZ] =
+                &adapter->sbands[NL80211_BAND_2GHZ];
+        wiphy->bands[NL80211_BAND_5GHZ] =
+                &adapter->sbands[NL80211_BAND_5GHZ];
 
         status = ieee80211_register_hw(hw);
         if (status)
diff --git a/drivers/net/wireless/rsi/rsi_91x_mgmt.c b/drivers/net/wireless/rsi/rsi_91x_mgmt.c
index e43b59d5b53b..40658b62d077 100644
--- a/drivers/net/wireless/rsi/rsi_91x_mgmt.c
+++ b/drivers/net/wireless/rsi/rsi_91x_mgmt.c
@@ -210,7 +210,7 @@ static u16 mcs[] = {13, 26, 39, 52, 78, 104, 117, 130};
  */
 static void rsi_set_default_parameters(struct rsi_common *common)
 {
-        common->band = IEEE80211_BAND_2GHZ;
+        common->band = NL80211_BAND_2GHZ;
         common->channel_width = BW_20MHZ;
         common->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
         common->channel = 1;
@@ -655,7 +655,7 @@ int rsi_set_vap_capabilities(struct rsi_common *common, enum opmode mode)
         vap_caps->rts_threshold = cpu_to_le16(common->rts_threshold);
         vap_caps->default_mgmt_rate = cpu_to_le32(RSI_RATE_6);
 
-        if (common->band == IEEE80211_BAND_5GHZ) {
+        if (common->band == NL80211_BAND_5GHZ) {
                 vap_caps->default_ctrl_rate = cpu_to_le32(RSI_RATE_6);
                 if (conf_is_ht40(&common->priv->hw->conf)) {
                         vap_caps->default_ctrl_rate |=
@@ -872,7 +872,7 @@ int rsi_band_check(struct rsi_common *common)
         else
                 common->channel_width = BW_40MHZ;
 
-        if (common->band == IEEE80211_BAND_2GHZ) {
+        if (common->band == NL80211_BAND_2GHZ) {
                 if (common->channel_width)
                         common->endpoint = EP_2GHZ_40MHZ;
                 else
@@ -1046,7 +1046,7 @@ static int rsi_send_auto_rate_request(struct rsi_common *common)
         if (common->channel_width == BW_40MHZ)
                 auto_rate->desc_word[7] |= cpu_to_le16(1);
 
-        if (band == IEEE80211_BAND_2GHZ) {
+        if (band == NL80211_BAND_2GHZ) {
                 min_rate = RSI_RATE_1;
                 rate_table_offset = 0;
         } else {
diff --git a/drivers/net/wireless/rsi/rsi_91x_pkt.c b/drivers/net/wireless/rsi/rsi_91x_pkt.c
index 702593f19997..02920c93e82d 100644
--- a/drivers/net/wireless/rsi/rsi_91x_pkt.c
+++ b/drivers/net/wireless/rsi/rsi_91x_pkt.c
@@ -27,22 +27,24 @@
 int rsi_send_data_pkt(struct rsi_common *common, struct sk_buff *skb)
 {
         struct rsi_hw *adapter = common->priv;
-        struct ieee80211_hdr *tmp_hdr = NULL;
+        struct ieee80211_hdr *tmp_hdr;
         struct ieee80211_tx_info *info;
         struct skb_info *tx_params;
-        struct ieee80211_bss_conf *bss = NULL;
-        int status = -EINVAL;
+        struct ieee80211_bss_conf *bss;
+        int status;
         u8 ieee80211_size = MIN_802_11_HDR_LEN;
-        u8 extnd_size = 0;
+        u8 extnd_size;
         __le16 *frame_desc;
-        u16 seq_num = 0;
+        u16 seq_num;
 
         info = IEEE80211_SKB_CB(skb);
         bss = &info->control.vif->bss_conf;
         tx_params = (struct skb_info *)info->driver_data;
 
-        if (!bss->assoc)
+        if (!bss->assoc) {
+                status = -EINVAL;
                 goto err;
+        }
 
         tmp_hdr = (struct ieee80211_hdr *)&skb->data[0];
         seq_num = (le16_to_cpu(tmp_hdr->seq_ctrl) >> 4);
@@ -123,15 +125,15 @@ int rsi_send_mgmt_pkt(struct rsi_common *common,
                       struct sk_buff *skb)
 {
         struct rsi_hw *adapter = common->priv;
-        struct ieee80211_hdr *wh = NULL;
+        struct ieee80211_hdr *wh;
         struct ieee80211_tx_info *info;
-        struct ieee80211_bss_conf *bss = NULL;
+        struct ieee80211_bss_conf *bss;
         struct ieee80211_hw *hw = adapter->hw;
         struct ieee80211_conf *conf = &hw->conf;
         struct skb_info *tx_params;
         int status = -E2BIG;
-        __le16 *msg = NULL;
-        u8 extnd_size = 0;
+        __le16 *msg;
+        u8 extnd_size;
         u8 vap_id = 0;
 
         info = IEEE80211_SKB_CB(skb);
@@ -182,7 +184,7 @@ int rsi_send_mgmt_pkt(struct rsi_common *common,
         if (wh->addr1[0] & BIT(0))
                 msg[3] |= cpu_to_le16(RSI_BROADCAST_PKT);
 
-        if (common->band == IEEE80211_BAND_2GHZ)
+        if (common->band == NL80211_BAND_2GHZ)
                 msg[4] = cpu_to_le16(RSI_11B_MODE);
         else
                 msg[4] = cpu_to_le16((RSI_RATE_6 & 0x0f) | RSI_11G_MODE);
diff --git a/drivers/net/wireless/rsi/rsi_main.h b/drivers/net/wireless/rsi/rsi_main.h
index 5baed945f60e..dcd095787166 100644
--- a/drivers/net/wireless/rsi/rsi_main.h
+++ b/drivers/net/wireless/rsi/rsi_main.h
@@ -211,7 +211,7 @@ struct rsi_hw {
         struct ieee80211_hw *hw;
         struct ieee80211_vif *vifs[RSI_MAX_VIFS];
         struct ieee80211_tx_queue_params edca_params[NUM_EDCA_QUEUES];
-        struct ieee80211_supported_band sbands[IEEE80211_NUM_BANDS];
+        struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
 
         struct device *device;
         u8 sc_nvifs;
diff --git a/drivers/net/wireless/st/cw1200/main.c b/drivers/net/wireless/st/cw1200/main.c
index 0e51e27d2e3f..dc478cedbde0 100644
--- a/drivers/net/wireless/st/cw1200/main.c
+++ b/drivers/net/wireless/st/cw1200/main.c
@@ -102,7 +102,7 @@ static struct ieee80211_rate cw1200_mcs_rates[] = {
 
 
 #define CHAN2G(_channel, _freq, _flags) {                       \
-        .band                   = IEEE80211_BAND_2GHZ,          \
+        .band                   = NL80211_BAND_2GHZ,            \
         .center_freq            = (_freq),                      \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -111,7 +111,7 @@ static struct ieee80211_rate cw1200_mcs_rates[] = {
 }
 
 #define CHAN5G(_channel, _flags) {                              \
-        .band                   = IEEE80211_BAND_5GHZ,          \
+        .band                   = NL80211_BAND_5GHZ,            \
         .center_freq    = 5000 + (5 * (_channel)),              \
         .hw_value               = (_channel),                   \
         .flags                  = (_flags),                     \
@@ -311,12 +311,12 @@ static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr,
 
         hw->sta_data_size = sizeof(struct cw1200_sta_priv);
 
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &cw1200_band_2ghz;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz;
         if (have_5ghz)
-                hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &cw1200_band_5ghz;
+                hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz;
 
         /* Channel params have to be cleared before registering wiphy again */
-        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
+        for (band = 0; band < NUM_NL80211_BANDS; band++) {
                 struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
                 if (!sband)
                         continue;
diff --git a/drivers/net/wireless/st/cw1200/scan.c b/drivers/net/wireless/st/cw1200/scan.c
index bff81b8d4164..983788156bb0 100644
--- a/drivers/net/wireless/st/cw1200/scan.c
+++ b/drivers/net/wireless/st/cw1200/scan.c
@@ -402,7 +402,7 @@ void cw1200_probe_work(struct work_struct *work)
         }
         wsm = (struct wsm_tx *)frame.skb->data;
         scan.max_tx_rate = wsm->max_tx_rate;
-        scan.band = (priv->channel->band == IEEE80211_BAND_5GHZ) ?
+        scan.band = (priv->channel->band == NL80211_BAND_5GHZ) ?
                 WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G;
         if (priv->join_status == CW1200_JOIN_STATUS_STA ||
             priv->join_status == CW1200_JOIN_STATUS_IBSS) {
diff --git a/drivers/net/wireless/st/cw1200/sta.c b/drivers/net/wireless/st/cw1200/sta.c
index d0ddcde6c695..daf06a4f842e 100644
--- a/drivers/net/wireless/st/cw1200/sta.c
+++ b/drivers/net/wireless/st/cw1200/sta.c
@@ -1278,7 +1278,7 @@ static void cw1200_do_join(struct cw1200_common *priv)
         join.dtim_period = priv->join_dtim_period;
 
         join.channel_number = priv->channel->hw_value;
-        join.band = (priv->channel->band == IEEE80211_BAND_5GHZ) ?
+        join.band = (priv->channel->band == NL80211_BAND_5GHZ) ?
                 WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G;
 
         memcpy(join.bssid, bssid, sizeof(join.bssid));
@@ -1462,7 +1462,7 @@ int cw1200_enable_listening(struct cw1200_common *priv)
         };
 
         if (priv->channel) {
-                start.band = priv->channel->band == IEEE80211_BAND_5GHZ ?
+                start.band = priv->channel->band == NL80211_BAND_5GHZ ?
                              WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G;
                 start.channel_number = priv->channel->hw_value;
         } else {
@@ -2315,7 +2315,7 @@ static int cw1200_start_ap(struct cw1200_common *priv)
         struct wsm_start start = {
                 .mode = priv->vif->p2p ?
                                 WSM_START_MODE_P2P_GO : WSM_START_MODE_AP,
-                .band = (priv->channel->band == IEEE80211_BAND_5GHZ) ?
+                .band = (priv->channel->band == NL80211_BAND_5GHZ) ?
                                 WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G,
                 .channel_number = priv->channel->hw_value,
                 .beacon_interval = conf->beacon_int,
diff --git a/drivers/net/wireless/st/cw1200/txrx.c b/drivers/net/wireless/st/cw1200/txrx.c
index d28bd49cb5fd..3d170287cd0b 100644
--- a/drivers/net/wireless/st/cw1200/txrx.c
+++ b/drivers/net/wireless/st/cw1200/txrx.c
@@ -1079,7 +1079,7 @@ void cw1200_rx_cb(struct cw1200_common *priv,
 
         hdr->band = ((arg->channel_number & 0xff00) ||
                      (arg->channel_number > 14)) ?
-                        IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
+                        NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
         hdr->freq = ieee80211_channel_to_frequency(
                         arg->channel_number,
                         hdr->band);
diff --git a/drivers/net/wireless/st/cw1200/wsm.c b/drivers/net/wireless/st/cw1200/wsm.c
index 9e0ca3048657..680d60eabc75 100644
--- a/drivers/net/wireless/st/cw1200/wsm.c
+++ b/drivers/net/wireless/st/cw1200/wsm.c
@@ -849,9 +849,9 @@ static int wsm_startup_indication(struct cw1200_common *priv,
 
         /* Disable unsupported frequency bands */
         if (!(priv->wsm_caps.fw_cap & 0x1))
-                priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
+                priv->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
         if (!(priv->wsm_caps.fw_cap & 0x2))
-                priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
+                priv->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
 
         priv->firmware_ready = 1;
         wake_up(&priv->wsm_startup_done);
diff --git a/drivers/net/wireless/ti/wl1251/main.c b/drivers/net/wireless/ti/wl1251/main.c
index cd4777954f87..56384a4e2a35 100644
--- a/drivers/net/wireless/ti/wl1251/main.c
+++ b/drivers/net/wireless/ti/wl1251/main.c
@@ -1482,7 +1482,7 @@ int wl1251_init_ieee80211(struct wl1251 *wl)
         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
                                          BIT(NL80211_IFTYPE_ADHOC);
         wl->hw->wiphy->max_scan_ssids = 1;
-        wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1251_band_2ghz;
+        wl->hw->wiphy->bands[NL80211_BAND_2GHZ] = &wl1251_band_2ghz;
 
         wl->hw->queues = 4;
 
diff --git a/drivers/net/wireless/ti/wl1251/ps.c b/drivers/net/wireless/ti/wl1251/ps.c
index b9e27b98bbc9..fa01b0a0f312 100644
--- a/drivers/net/wireless/ti/wl1251/ps.c
+++ b/drivers/net/wireless/ti/wl1251/ps.c
@@ -32,7 +32,7 @@ void wl1251_elp_work(struct work_struct *work)
         struct delayed_work *dwork;
         struct wl1251 *wl;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wl = container_of(dwork, struct wl1251, elp_work);
 
         wl1251_debug(DEBUG_PSM, "elp work");
diff --git a/drivers/net/wireless/ti/wl1251/rx.c b/drivers/net/wireless/ti/wl1251/rx.c
index cde0eaf99714..a27d4c22b6e8 100644
--- a/drivers/net/wireless/ti/wl1251/rx.c
+++ b/drivers/net/wireless/ti/wl1251/rx.c
@@ -53,7 +53,7 @@ static void wl1251_rx_status(struct wl1251 *wl,
 
         memset(status, 0, sizeof(struct ieee80211_rx_status));
 
-        status->band = IEEE80211_BAND_2GHZ;
+        status->band = NL80211_BAND_2GHZ;
         status->mactime = desc->timestamp;
 
         /*
diff --git a/drivers/net/wireless/ti/wl12xx/main.c b/drivers/net/wireless/ti/wl12xx/main.c
index a0d6cccc56f3..58b9d3c3a833 100644
--- a/drivers/net/wireless/ti/wl12xx/main.c
+++ b/drivers/net/wireless/ti/wl12xx/main.c
@@ -469,8 +469,8 @@ static const u8 wl12xx_rate_to_idx_5ghz[] = {
 };
 
 static const u8 *wl12xx_band_rate_to_idx[] = {
-        [IEEE80211_BAND_2GHZ] = wl12xx_rate_to_idx_2ghz,
-        [IEEE80211_BAND_5GHZ] = wl12xx_rate_to_idx_5ghz
+        [NL80211_BAND_2GHZ] = wl12xx_rate_to_idx_2ghz,
+        [NL80211_BAND_5GHZ] = wl12xx_rate_to_idx_5ghz
 };
 
 enum wl12xx_hw_rates {
@@ -1827,8 +1827,8 @@ static int wl12xx_setup(struct wl1271 *wl)
         wl->fw_status_priv_len = 0;
         wl->stats.fw_stats_len = sizeof(struct wl12xx_acx_statistics);
         wl->ofdm_only_ap = true;
-        wlcore_set_ht_cap(wl, IEEE80211_BAND_2GHZ, &wl12xx_ht_cap);
-        wlcore_set_ht_cap(wl, IEEE80211_BAND_5GHZ, &wl12xx_ht_cap);
+        wlcore_set_ht_cap(wl, NL80211_BAND_2GHZ, &wl12xx_ht_cap);
+        wlcore_set_ht_cap(wl, NL80211_BAND_5GHZ, &wl12xx_ht_cap);
         wl12xx_conf_init(wl);
 
         if (!fref_param) {
diff --git a/drivers/net/wireless/ti/wl12xx/scan.c b/drivers/net/wireless/ti/wl12xx/scan.c
index ebed13af9852..8d475393f9e3 100644
--- a/drivers/net/wireless/ti/wl12xx/scan.c
+++ b/drivers/net/wireless/ti/wl12xx/scan.c
@@ -27,7 +27,7 @@
 static int wl1271_get_scan_channels(struct wl1271 *wl,
                                     struct cfg80211_scan_request *req,
                                     struct basic_scan_channel_params *channels,
-                                    enum ieee80211_band band, bool passive)
+                                    enum nl80211_band band, bool passive)
 {
         struct conf_scan_settings *c = &wl->conf.scan;
         int i, j;
@@ -92,7 +92,7 @@ static int wl1271_get_scan_channels(struct wl1271 *wl,
 #define WL1271_NOTHING_TO_SCAN 1
 
 static int wl1271_scan_send(struct wl1271 *wl, struct wl12xx_vif *wlvif,
-                            enum ieee80211_band band,
+                            enum nl80211_band band,
                             bool passive, u32 basic_rate)
 {
         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
@@ -144,12 +144,12 @@ static int wl1271_scan_send(struct wl1271 *wl, struct wl12xx_vif *wlvif,
         cmd->params.tid_trigger = CONF_TX_AC_ANY_TID;
         cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;
 
-        if (band == IEEE80211_BAND_2GHZ)
+        if (band == NL80211_BAND_2GHZ)
                 cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
         else
                 cmd->params.band = WL1271_SCAN_BAND_5_GHZ;
 
-        if (wl->scan.ssid_len && wl->scan.ssid) {
+        if (wl->scan.ssid_len) {
                 cmd->params.ssid_len = wl->scan.ssid_len;
                 memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
         }
@@ -218,7 +218,7 @@ out:
 void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 {
         int ret = 0;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         u32 rate, mask;
 
         switch (wl->scan.state) {
@@ -226,7 +226,7 @@ void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif)
                 break;
 
         case WL1271_SCAN_STATE_2GHZ_ACTIVE:
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
                 mask = wlvif->bitrate_masks[band];
                 if (wl->scan.req->no_cck) {
                         mask &= ~CONF_TX_CCK_RATES;
@@ -243,7 +243,7 @@ void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif)
                 break;
 
         case WL1271_SCAN_STATE_2GHZ_PASSIVE:
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
                 mask = wlvif->bitrate_masks[band];
                 if (wl->scan.req->no_cck) {
                         mask &= ~CONF_TX_CCK_RATES;
@@ -263,7 +263,7 @@ void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif)
                 break;
 
         case WL1271_SCAN_STATE_5GHZ_ACTIVE:
-                band = IEEE80211_BAND_5GHZ;
+                band = NL80211_BAND_5GHZ;
                 rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[band]);
                 ret = wl1271_scan_send(wl, wlvif, band, false, rate);
                 if (ret == WL1271_NOTHING_TO_SCAN) {
@@ -274,7 +274,7 @@ void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif)
                 break;
 
         case WL1271_SCAN_STATE_5GHZ_PASSIVE:
-                band = IEEE80211_BAND_5GHZ;
+                band = NL80211_BAND_5GHZ;
                 rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[band]);
                 ret = wl1271_scan_send(wl, wlvif, band, true, rate);
                 if (ret == WL1271_NOTHING_TO_SCAN) {
@@ -378,7 +378,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
         wl12xx_adjust_channels(cfg, cfg_channels);
 
         if (!force_passive && cfg->active[0]) {
-                u8 band = IEEE80211_BAND_2GHZ;
+                u8 band = NL80211_BAND_2GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                                  wlvif->role_id, band,
                                                  req->ssids[0].ssid,
@@ -395,7 +395,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
         }
 
         if (!force_passive && cfg->active[1]) {
-                u8 band = IEEE80211_BAND_5GHZ;
+                u8 band = NL80211_BAND_5GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                                  wlvif->role_id, band,
                                                  req->ssids[0].ssid,
diff --git a/drivers/net/wireless/ti/wl18xx/cmd.c b/drivers/net/wireless/ti/wl18xx/cmd.c
index a8d176ddc73c..63e95ba744fd 100644
--- a/drivers/net/wireless/ti/wl18xx/cmd.c
+++ b/drivers/net/wireless/ti/wl18xx/cmd.c
@@ -48,10 +48,10 @@ int wl18xx_cmd_channel_switch(struct wl1271 *wl,
         cmd->stop_tx = ch_switch->block_tx;
 
         switch (ch_switch->chandef.chan->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 cmd->band = WLCORE_BAND_2_4GHZ;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 cmd->band = WLCORE_BAND_5GHZ;
                 break;
         default:
@@ -187,7 +187,7 @@ int wl18xx_cmd_set_cac(struct wl1271 *wl, struct wl12xx_vif *wlvif, bool start)
 
         cmd->role_id = wlvif->role_id;
         cmd->channel = wlvif->channel;
-        if (wlvif->band == IEEE80211_BAND_5GHZ)
+        if (wlvif->band == NL80211_BAND_5GHZ)
                 cmd->band = WLCORE_BAND_5GHZ;
         cmd->bandwidth = wlcore_get_native_channel_type(wlvif->channel_type);
 
diff --git a/drivers/net/wireless/ti/wl18xx/event.c b/drivers/net/wireless/ti/wl18xx/event.c
index ff6e46dd61f8..ef811848d141 100644
--- a/drivers/net/wireless/ti/wl18xx/event.c
+++ b/drivers/net/wireless/ti/wl18xx/event.c
@@ -64,13 +64,13 @@ static int wlcore_smart_config_sync_event(struct wl1271 *wl, u8 sync_channel,
                                           u8 sync_band)
 {
         struct sk_buff *skb;
-        enum ieee80211_band band;
+        enum nl80211_band band;
         int freq;
 
         if (sync_band == WLCORE_BAND_5GHZ)
-                band = IEEE80211_BAND_5GHZ;
+                band = NL80211_BAND_5GHZ;
         else
-                band = IEEE80211_BAND_2GHZ;
+                band = NL80211_BAND_2GHZ;
 
         freq = ieee80211_channel_to_frequency(sync_channel, band);
 
diff --git a/drivers/net/wireless/ti/wl18xx/main.c b/drivers/net/wireless/ti/wl18xx/main.c
index 1bf26cc7374e..ae47c79cb9b6 100644
--- a/drivers/net/wireless/ti/wl18xx/main.c
+++ b/drivers/net/wireless/ti/wl18xx/main.c
@@ -137,8 +137,8 @@ static const u8 wl18xx_rate_to_idx_5ghz[] = {
 };
 
 static const u8 *wl18xx_band_rate_to_idx[] = {
-        [IEEE80211_BAND_2GHZ] = wl18xx_rate_to_idx_2ghz,
-        [IEEE80211_BAND_5GHZ] = wl18xx_rate_to_idx_5ghz
+        [NL80211_BAND_2GHZ] = wl18xx_rate_to_idx_2ghz,
+        [NL80211_BAND_5GHZ] = wl18xx_rate_to_idx_5ghz
 };
 
 enum wl18xx_hw_rates {
@@ -1302,12 +1302,12 @@ static u32 wl18xx_ap_get_mimo_wide_rate_mask(struct wl1271 *wl,
                 wl1271_debug(DEBUG_ACX, "using wide channel rate mask");
 
                 /* sanity check - we don't support this */
-                if (WARN_ON(wlvif->band != IEEE80211_BAND_5GHZ))
+                if (WARN_ON(wlvif->band != NL80211_BAND_5GHZ))
                         return 0;
 
                 return CONF_TX_RATE_USE_WIDE_CHAN;
         } else if (wl18xx_is_mimo_supported(wl) &&
-                   wlvif->band == IEEE80211_BAND_2GHZ) {
+                   wlvif->band == NL80211_BAND_2GHZ) {
                 wl1271_debug(DEBUG_ACX, "using MIMO rate mask");
                 /*
                  * we don't care about HT channel here - if a peer doesn't
@@ -1996,24 +1996,24 @@ static int wl18xx_setup(struct wl1271 *wl)
                  * siso40.
                  */
                 if (wl18xx_is_mimo_supported(wl))
-                        wlcore_set_ht_cap(wl, IEEE80211_BAND_2GHZ,
+                        wlcore_set_ht_cap(wl, NL80211_BAND_2GHZ,
                                           &wl18xx_mimo_ht_cap_2ghz);
                 else
-                        wlcore_set_ht_cap(wl, IEEE80211_BAND_2GHZ,
+                        wlcore_set_ht_cap(wl, NL80211_BAND_2GHZ,
                                           &wl18xx_siso40_ht_cap_2ghz);
 
                 /* 5Ghz is always wide */
-                wlcore_set_ht_cap(wl, IEEE80211_BAND_5GHZ,
+                wlcore_set_ht_cap(wl, NL80211_BAND_5GHZ,
                                   &wl18xx_siso40_ht_cap_5ghz);
         } else if (priv->conf.ht.mode == HT_MODE_WIDE) {
-                wlcore_set_ht_cap(wl, IEEE80211_BAND_2GHZ,
+                wlcore_set_ht_cap(wl, NL80211_BAND_2GHZ,
                                   &wl18xx_siso40_ht_cap_2ghz);
-                wlcore_set_ht_cap(wl, IEEE80211_BAND_5GHZ,
+                wlcore_set_ht_cap(wl, NL80211_BAND_5GHZ,
                                   &wl18xx_siso40_ht_cap_5ghz);
         } else if (priv->conf.ht.mode == HT_MODE_SISO20) {
-                wlcore_set_ht_cap(wl, IEEE80211_BAND_2GHZ,
+                wlcore_set_ht_cap(wl, NL80211_BAND_2GHZ,
                                   &wl18xx_siso20_ht_cap);
-                wlcore_set_ht_cap(wl, IEEE80211_BAND_5GHZ,
+                wlcore_set_ht_cap(wl, NL80211_BAND_5GHZ,
                                   &wl18xx_siso20_ht_cap);
         }
 
diff --git a/drivers/net/wireless/ti/wl18xx/scan.c b/drivers/net/wireless/ti/wl18xx/scan.c
index bc15aa2c3efa..4e5221544354 100644
--- a/drivers/net/wireless/ti/wl18xx/scan.c
+++ b/drivers/net/wireless/ti/wl18xx/scan.c
@@ -110,7 +110,7 @@ static int wl18xx_scan_send(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 
         /* TODO: per-band ies? */
         if (cmd->active[0]) {
-                u8 band = IEEE80211_BAND_2GHZ;
+                u8 band = NL80211_BAND_2GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                  cmd->role_id, band,
                                  req->ssids ? req->ssids[0].ssid : NULL,
@@ -127,7 +127,7 @@ static int wl18xx_scan_send(struct wl1271 *wl, struct wl12xx_vif *wlvif,
         }
 
         if (cmd->active[1] || cmd->dfs) {
-                u8 band = IEEE80211_BAND_5GHZ;
+                u8 band = NL80211_BAND_5GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                  cmd->role_id, band,
                                  req->ssids ? req->ssids[0].ssid : NULL,
@@ -253,7 +253,7 @@ int wl18xx_scan_sched_scan_config(struct wl1271 *wl,
         cmd->terminate_on_report = 0;
 
         if (cmd->active[0]) {
-                u8 band = IEEE80211_BAND_2GHZ;
+                u8 band = NL80211_BAND_2GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                  cmd->role_id, band,
                                  req->ssids ? req->ssids[0].ssid : NULL,
@@ -270,7 +270,7 @@ int wl18xx_scan_sched_scan_config(struct wl1271 *wl,
         }
 
         if (cmd->active[1] || cmd->dfs) {
-                u8 band = IEEE80211_BAND_5GHZ;
+                u8 band = NL80211_BAND_5GHZ;
                 ret = wl12xx_cmd_build_probe_req(wl, wlvif,
                                  cmd->role_id, band,
                                  req->ssids ? req->ssids[0].ssid : NULL,
diff --git a/drivers/net/wireless/ti/wl18xx/tx.c b/drivers/net/wireless/ti/wl18xx/tx.c
index 3406ffb53325..ebaf66ef3f84 100644
--- a/drivers/net/wireless/ti/wl18xx/tx.c
+++ b/drivers/net/wireless/ti/wl18xx/tx.c
@@ -43,7 +43,7 @@ void wl18xx_get_last_tx_rate(struct wl1271 *wl, struct ieee80211_vif *vif,
 
         if (fw_rate <= CONF_HW_RATE_INDEX_54MBPS) {
                 rate->idx = fw_rate;
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         rate->idx -= CONF_HW_RATE_INDEX_6MBPS;
                 rate->flags = 0;
         } else {
diff --git a/drivers/net/wireless/ti/wlcore/cmd.c b/drivers/net/wireless/ti/wlcore/cmd.c
index f01d24baff7c..33153565ad62 100644
--- a/drivers/net/wireless/ti/wlcore/cmd.c
+++ b/drivers/net/wireless/ti/wlcore/cmd.c
@@ -423,7 +423,7 @@ EXPORT_SYMBOL_GPL(wlcore_get_native_channel_type);
 
 static int wl12xx_cmd_role_start_dev(struct wl1271 *wl,
                                      struct wl12xx_vif *wlvif,
-                                     enum ieee80211_band band,
+                                     enum nl80211_band band,
                                      int channel)
 {
         struct wl12xx_cmd_role_start *cmd;
@@ -438,7 +438,7 @@ static int wl12xx_cmd_role_start_dev(struct wl1271 *wl,
         wl1271_debug(DEBUG_CMD, "cmd role start dev %d", wlvif->dev_role_id);
 
         cmd->role_id = wlvif->dev_role_id;
-        if (band == IEEE80211_BAND_5GHZ)
+        if (band == NL80211_BAND_5GHZ)
                 cmd->band = WLCORE_BAND_5GHZ;
         cmd->channel = channel;
 
@@ -524,7 +524,7 @@ int wl12xx_cmd_role_start_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
         wl1271_debug(DEBUG_CMD, "cmd role start sta %d", wlvif->role_id);
 
         cmd->role_id = wlvif->role_id;
-        if (wlvif->band == IEEE80211_BAND_5GHZ)
+        if (wlvif->band == NL80211_BAND_5GHZ)
                 cmd->band = WLCORE_BAND_5GHZ;
         cmd->channel = wlvif->channel;
         cmd->sta.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set);
@@ -693,10 +693,10 @@ int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
         cmd->ap.local_rates = cpu_to_le32(supported_rates);
 
         switch (wlvif->band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 cmd->band = WLCORE_BAND_2_4GHZ;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 cmd->band = WLCORE_BAND_5GHZ;
                 break;
         default:
@@ -773,7 +773,7 @@ int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif)
         wl1271_debug(DEBUG_CMD, "cmd role start ibss %d", wlvif->role_id);
 
         cmd->role_id = wlvif->role_id;
-        if (wlvif->band == IEEE80211_BAND_5GHZ)
+        if (wlvif->band == NL80211_BAND_5GHZ)
                 cmd->band = WLCORE_BAND_5GHZ;
         cmd->channel = wlvif->channel;
         cmd->ibss.basic_rate_set = cpu_to_le32(wlvif->basic_rate_set);
@@ -1164,7 +1164,7 @@ int wl12xx_cmd_build_probe_req(struct wl1271 *wl, struct wl12xx_vif *wlvif,
         }
 
         rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[band]);
-        if (band == IEEE80211_BAND_2GHZ)
+        if (band == NL80211_BAND_2GHZ)
                 ret = wl1271_cmd_template_set(wl, role_id,
                                               template_id_2_4,
                                               skb->data, skb->len, 0, rate);
@@ -1195,7 +1195,7 @@ struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
         wl1271_debug(DEBUG_SCAN, "set ap probe request template");
 
         rate = wl1271_tx_min_rate_get(wl, wlvif->bitrate_masks[wlvif->band]);
-        if (wlvif->band == IEEE80211_BAND_2GHZ)
+        if (wlvif->band == NL80211_BAND_2GHZ)
                 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
                                               CMD_TEMPL_CFG_PROBE_REQ_2_4,
                                               skb->data, skb->len, 0, rate);
@@ -1628,19 +1628,19 @@ out:
         return ret;
 }
 
-static int wlcore_get_reg_conf_ch_idx(enum ieee80211_band band, u16 ch)
+static int wlcore_get_reg_conf_ch_idx(enum nl80211_band band, u16 ch)
 {
         /*
          * map the given band/channel to the respective predefined
          * bit expected by the fw
          */
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 /* channels 1..14 are mapped to 0..13 */
                 if (ch >= 1 && ch <= 14)
                         return ch - 1;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 switch (ch) {
                 case 8 ... 16:
                         /* channels 8,12,16 are mapped to 18,19,20 */
@@ -1670,7 +1670,7 @@ static int wlcore_get_reg_conf_ch_idx(enum ieee80211_band band, u16 ch)
 }
 
 void wlcore_set_pending_regdomain_ch(struct wl1271 *wl, u16 channel,
-                                     enum ieee80211_band band)
+                                     enum nl80211_band band)
 {
         int ch_bit_idx = 0;
 
@@ -1699,7 +1699,7 @@ int wlcore_cmd_regdomain_config_locked(struct wl1271 *wl)
 
         memset(tmp_ch_bitmap, 0, sizeof(tmp_ch_bitmap));
 
-        for (b = IEEE80211_BAND_2GHZ; b <= IEEE80211_BAND_5GHZ; b++) {
+        for (b = NL80211_BAND_2GHZ; b <= NL80211_BAND_5GHZ; b++) {
                 band = wiphy->bands[b];
                 for (i = 0; i < band->n_channels; i++) {
                         struct ieee80211_channel *channel = &band->channels[i];
@@ -1851,7 +1851,7 @@ out:
 }
 
 static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
-                          u8 role_id, enum ieee80211_band band, u8 channel)
+                          u8 role_id, enum nl80211_band band, u8 channel)
 {
         struct wl12xx_cmd_roc *cmd;
         int ret = 0;
@@ -1870,10 +1870,10 @@ static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
         cmd->role_id = role_id;
         cmd->channel = channel;
         switch (band) {
-        case IEEE80211_BAND_2GHZ:
+        case NL80211_BAND_2GHZ:
                 cmd->band = WLCORE_BAND_2_4GHZ;
                 break;
-        case IEEE80211_BAND_5GHZ:
+        case NL80211_BAND_5GHZ:
                 cmd->band = WLCORE_BAND_5GHZ;
                 break;
         default:
@@ -1925,7 +1925,7 @@ out:
 }
 
 int wl12xx_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 role_id,
-               enum ieee80211_band band, u8 channel)
+               enum nl80211_band band, u8 channel)
 {
         int ret = 0;
 
@@ -1995,7 +1995,7 @@ out:
 
 /* start dev role and roc on its channel */
 int wl12xx_start_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif,
-                     enum ieee80211_band band, int channel)
+                     enum nl80211_band band, int channel)
 {
         int ret;
 
diff --git a/drivers/net/wireless/ti/wlcore/cmd.h b/drivers/net/wireless/ti/wlcore/cmd.h
index e28e2f2303ce..52c3b4860461 100644
--- a/drivers/net/wireless/ti/wlcore/cmd.h
+++ b/drivers/net/wireless/ti/wlcore/cmd.h
@@ -40,7 +40,7 @@ int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif);
 int wl12xx_cmd_role_stop_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif);
 int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif);
 int wl12xx_start_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif,
-                     enum ieee80211_band band, int channel);
+                     enum nl80211_band band, int channel);
 int wl12xx_stop_dev(struct wl1271 *wl, struct wl12xx_vif *wlvif);
 int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer);
 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf,
@@ -83,14 +83,14 @@ int wl1271_cmd_set_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 int wl12xx_cmd_set_peer_state(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                               u8 hlid);
 int wl12xx_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 role_id,
-               enum ieee80211_band band, u8 channel);
+               enum nl80211_band band, u8 channel);
 int wl12xx_croc(struct wl1271 *wl, u8 role_id);
 int wl12xx_cmd_add_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                         struct ieee80211_sta *sta, u8 hlid);
 int wl12xx_cmd_remove_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                            u8 hlid);
 void wlcore_set_pending_regdomain_ch(struct wl1271 *wl, u16 channel,
-                                     enum ieee80211_band band);
+                                     enum nl80211_band band);
 int wlcore_cmd_regdomain_config_locked(struct wl1271 *wl);
 int wlcore_cmd_generic_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                            u8 feature, u8 enable, u8 value);
diff --git a/drivers/net/wireless/ti/wlcore/main.c b/drivers/net/wireless/ti/wlcore/main.c
index dde36203ca42..10fd24c28ece 100644
--- a/drivers/net/wireless/ti/wlcore/main.c
+++ b/drivers/net/wireless/ti/wlcore/main.c
@@ -243,7 +243,7 @@ static void wl12xx_tx_watchdog_work(struct work_struct *work)
         struct delayed_work *dwork;
         struct wl1271 *wl;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wl = container_of(dwork, struct wl1271, tx_watchdog_work);
 
         mutex_lock(&wl->mutex);
@@ -1930,7 +1930,7 @@ static void wlcore_op_stop_locked(struct wl1271 *wl)
         if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
                 wlcore_enable_interrupts(wl);
 
-        wl->band = IEEE80211_BAND_2GHZ;
+        wl->band = NL80211_BAND_2GHZ;
 
         wl->rx_counter = 0;
         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
@@ -2011,7 +2011,7 @@ static void wlcore_channel_switch_work(struct work_struct *work)
         struct wl12xx_vif *wlvif;
         int ret;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wlvif = container_of(dwork, struct wl12xx_vif, channel_switch_work);
         wl = wlvif->wl;
 
@@ -2047,7 +2047,7 @@ static void wlcore_connection_loss_work(struct work_struct *work)
         struct ieee80211_vif *vif;
         struct wl12xx_vif *wlvif;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wlvif = container_of(dwork, struct wl12xx_vif, connection_loss_work);
         wl = wlvif->wl;
 
@@ -2076,7 +2076,7 @@ static void wlcore_pending_auth_complete_work(struct work_struct *work)
         unsigned long time_spare;
         int ret;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wlvif = container_of(dwork, struct wl12xx_vif,
                              pending_auth_complete_work);
         wl = wlvif->wl;
@@ -2240,8 +2240,8 @@ static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
                 wlvif->rate_set = CONF_TX_ENABLED_RATES;
         }
 
-        wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
-        wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
+        wlvif->bitrate_masks[NL80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
+        wlvif->bitrate_masks[NL80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
         wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
 
         /*
@@ -2330,7 +2330,7 @@ power_off:
          * 11a channels if not supported
          */
         if (!wl->enable_11a)
-                wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
+                wiphy->bands[NL80211_BAND_5GHZ]->n_channels = 0;
 
         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
                      wl->enable_11a ? "" : "not ");
@@ -5588,7 +5588,7 @@ static void wlcore_roc_complete_work(struct work_struct *work)
         struct wl1271 *wl;
         int ret;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wl = container_of(dwork, struct wl1271, roc_complete_work);
 
         ret = wlcore_roc_completed(wl);
@@ -5871,7 +5871,7 @@ static const struct ieee80211_ops wl1271_ops = {
 };
 
 
-u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
+u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum nl80211_band band)
 {
         u8 idx;
 
@@ -6096,21 +6096,21 @@ static int wl1271_init_ieee80211(struct wl1271 *wl)
          * We keep local copies of the band structs because we need to
          * modify them on a per-device basis.
          */
-        memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
+        memcpy(&wl->bands[NL80211_BAND_2GHZ], &wl1271_band_2ghz,
                sizeof(wl1271_band_2ghz));
-        memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap,
-               &wl->ht_cap[IEEE80211_BAND_2GHZ],
+        memcpy(&wl->bands[NL80211_BAND_2GHZ].ht_cap,
+               &wl->ht_cap[NL80211_BAND_2GHZ],
                sizeof(*wl->ht_cap));
-        memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
+        memcpy(&wl->bands[NL80211_BAND_5GHZ], &wl1271_band_5ghz,
                sizeof(wl1271_band_5ghz));
-        memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap,
-               &wl->ht_cap[IEEE80211_BAND_5GHZ],
+        memcpy(&wl->bands[NL80211_BAND_5GHZ].ht_cap,
+               &wl->ht_cap[NL80211_BAND_5GHZ],
                sizeof(*wl->ht_cap));
 
-        wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
-                &wl->bands[IEEE80211_BAND_2GHZ];
-        wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
-                &wl->bands[IEEE80211_BAND_5GHZ];
+        wl->hw->wiphy->bands[NL80211_BAND_2GHZ] =
+                &wl->bands[NL80211_BAND_2GHZ];
+        wl->hw->wiphy->bands[NL80211_BAND_5GHZ] =
+                &wl->bands[NL80211_BAND_5GHZ];
 
         /*
          * allow 4 queues per mac address we support +
@@ -6205,7 +6205,7 @@ struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size,
         wl->channel = 0;
         wl->rx_counter = 0;
         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
-        wl->band = IEEE80211_BAND_2GHZ;
+        wl->band = NL80211_BAND_2GHZ;
         wl->channel_type = NL80211_CHAN_NO_HT;
         wl->flags = 0;
         wl->sg_enabled = true;
diff --git a/drivers/net/wireless/ti/wlcore/ps.c b/drivers/net/wireless/ti/wlcore/ps.c
index 4cd316e61466..b36133b739cb 100644
--- a/drivers/net/wireless/ti/wlcore/ps.c
+++ b/drivers/net/wireless/ti/wlcore/ps.c
@@ -38,7 +38,7 @@ void wl1271_elp_work(struct work_struct *work)
         struct wl12xx_vif *wlvif;
         int ret;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wl = container_of(dwork, struct wl1271, elp_work);
 
         wl1271_debug(DEBUG_PSM, "elp work");
@@ -202,7 +202,7 @@ int wl1271_ps_set_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                  * enable beacon early termination.
                  * Not relevant for 5GHz and for high rates.
                  */
-                if ((wlvif->band == IEEE80211_BAND_2GHZ) &&
+                if ((wlvif->band == NL80211_BAND_2GHZ) &&
                     (wlvif->basic_rate < CONF_HW_BIT_RATE_9MBPS)) {
                         ret = wl1271_acx_bet_enable(wl, wlvif, true);
                         if (ret < 0)
@@ -213,7 +213,7 @@ int wl1271_ps_set_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                 wl1271_debug(DEBUG_PSM, "leaving psm");
 
                 /* disable beacon early termination */
-                if ((wlvif->band == IEEE80211_BAND_2GHZ) &&
+                if ((wlvif->band == NL80211_BAND_2GHZ) &&
                     (wlvif->basic_rate < CONF_HW_BIT_RATE_9MBPS)) {
                         ret = wl1271_acx_bet_enable(wl, wlvif, false);
                         if (ret < 0)
diff --git a/drivers/net/wireless/ti/wlcore/rx.c b/drivers/net/wireless/ti/wlcore/rx.c
index 34e7e938ede4..c9bd294a0aa6 100644
--- a/drivers/net/wireless/ti/wlcore/rx.c
+++ b/drivers/net/wireless/ti/wlcore/rx.c
@@ -64,9 +64,9 @@ static void wl1271_rx_status(struct wl1271 *wl,
         memset(status, 0, sizeof(struct ieee80211_rx_status));
 
         if ((desc->flags & WL1271_RX_DESC_BAND_MASK) == WL1271_RX_DESC_BAND_BG)
-                status->band = IEEE80211_BAND_2GHZ;
+                status->band = NL80211_BAND_2GHZ;
         else
-                status->band = IEEE80211_BAND_5GHZ;
+                status->band = NL80211_BAND_5GHZ;
 
         status->rate_idx = wlcore_rate_to_idx(wl, desc->rate, status->band);
 
diff --git a/drivers/net/wireless/ti/wlcore/rx.h b/drivers/net/wireless/ti/wlcore/rx.h
index f5a7087cfb97..57c0565637d6 100644
--- a/drivers/net/wireless/ti/wlcore/rx.h
+++ b/drivers/net/wireless/ti/wlcore/rx.h
@@ -146,7 +146,7 @@ struct wl1271_rx_descriptor {
 } __packed;
 
 int wlcore_rx(struct wl1271 *wl, struct wl_fw_status *status);
-u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band);
+u8 wl1271_rate_to_idx(int rate, enum nl80211_band band);
 int wl1271_rx_filter_enable(struct wl1271 *wl,
                             int index, bool enable,
                             struct wl12xx_rx_filter *filter);
diff --git a/drivers/net/wireless/ti/wlcore/scan.c b/drivers/net/wireless/ti/wlcore/scan.c
index 1e3d51cd673a..23343643207a 100644
--- a/drivers/net/wireless/ti/wlcore/scan.c
+++ b/drivers/net/wireless/ti/wlcore/scan.c
@@ -38,7 +38,7 @@ void wl1271_scan_complete_work(struct work_struct *work)
         struct wl12xx_vif *wlvif;
         int ret;
 
-        dwork = container_of(work, struct delayed_work, work);
+        dwork = to_delayed_work(work);
         wl = container_of(dwork, struct wl1271, scan_complete_work);
 
         wl1271_debug(DEBUG_SCAN, "Scanning complete");
@@ -164,7 +164,7 @@ wlcore_scan_get_channels(struct wl1271 *wl,
                 struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
                 u32 delta_per_probe;
 
-                if (band == IEEE80211_BAND_5GHZ)
+                if (band == NL80211_BAND_5GHZ)
                         delta_per_probe = c->dwell_time_delta_per_probe_5;
                 else
                         delta_per_probe = c->dwell_time_delta_per_probe;
@@ -215,7 +215,7 @@ wlcore_scan_get_channels(struct wl1271 *wl,
                         channels[j].channel = req_channels[i]->hw_value;
 
                         if (n_pactive_ch &&
-                            (band == IEEE80211_BAND_2GHZ) &&
+                            (band == NL80211_BAND_2GHZ) &&
                             (channels[j].channel >= 12) &&
                             (channels[j].channel <= 14) &&
                             (flags & IEEE80211_CHAN_NO_IR) &&
@@ -266,7 +266,7 @@ wlcore_set_scan_chan_params(struct wl1271 *wl,
                                          n_channels,
                                          n_ssids,
                                          cfg->channels_2,
-                                         IEEE80211_BAND_2GHZ,
+                                         NL80211_BAND_2GHZ,
                                          false, true, 0,
                                          MAX_CHANNELS_2GHZ,
                                          &n_pactive_ch,
@@ -277,7 +277,7 @@ wlcore_set_scan_chan_params(struct wl1271 *wl,
                                          n_channels,
                                          n_ssids,
                                          cfg->channels_2,
-                                         IEEE80211_BAND_2GHZ,
+                                         NL80211_BAND_2GHZ,
                                          false, false,
                                          cfg->passive[0],
                                          MAX_CHANNELS_2GHZ,
@@ -289,7 +289,7 @@ wlcore_set_scan_chan_params(struct wl1271 *wl,
                                          n_channels,
                                          n_ssids,
                                          cfg->channels_5,
-                                         IEEE80211_BAND_5GHZ,
+                                         NL80211_BAND_5GHZ,
                                          false, true, 0,
                                          wl->max_channels_5,
                                          &n_pactive_ch,
@@ -300,7 +300,7 @@ wlcore_set_scan_chan_params(struct wl1271 *wl,
                                          n_channels,
                                          n_ssids,
                                          cfg->channels_5,
-                                         IEEE80211_BAND_5GHZ,
+                                         NL80211_BAND_5GHZ,
                                          true, true,
                                          cfg->passive[1],
                                          wl->max_channels_5,
@@ -312,7 +312,7 @@ wlcore_set_scan_chan_params(struct wl1271 *wl,
                                          n_channels,
                                          n_ssids,
                                          cfg->channels_5,
-                                         IEEE80211_BAND_5GHZ,
+                                         NL80211_BAND_5GHZ,
                                          false, false,
                                          cfg->passive[1] + cfg->dfs,
                                          wl->max_channels_5,
diff --git a/drivers/net/wireless/ti/wlcore/tx.c b/drivers/net/wireless/ti/wlcore/tx.c
index f0ac36139bcc..c1b8e4e9d70b 100644
--- a/drivers/net/wireless/ti/wlcore/tx.c
+++ b/drivers/net/wireless/ti/wlcore/tx.c
@@ -453,7 +453,7 @@ static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 }
 
 u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set,
-                                enum ieee80211_band rate_band)
+                                enum nl80211_band rate_band)
 {
         struct ieee80211_supported_band *band;
         u32 enabled_rates = 0;
diff --git a/drivers/net/wireless/ti/wlcore/tx.h b/drivers/net/wireless/ti/wlcore/tx.h
index 79cb3ff8b71f..e2ba62d92d7a 100644
--- a/drivers/net/wireless/ti/wlcore/tx.h
+++ b/drivers/net/wireless/ti/wlcore/tx.h
@@ -246,9 +246,9 @@ int wlcore_tx_complete(struct wl1271 *wl);
 void wl12xx_tx_reset_wlvif(struct wl1271 *wl, struct wl12xx_vif *wlvif);
 void wl12xx_tx_reset(struct wl1271 *wl);
 void wl1271_tx_flush(struct wl1271 *wl);
-u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band);
+u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum nl80211_band band);
 u32 wl1271_tx_enabled_rates_get(struct wl1271 *wl, u32 rate_set,
-                                enum ieee80211_band rate_band);
+                                enum nl80211_band rate_band);
 u32 wl1271_tx_min_rate_get(struct wl1271 *wl, u32 rate_set);
 u8 wl12xx_tx_get_hlid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                       struct sk_buff *skb, struct ieee80211_sta *sta);
diff --git a/drivers/net/wireless/ti/wlcore/wlcore.h b/drivers/net/wireless/ti/wlcore/wlcore.h
index 72c31a8edcfb..8f28aa02230c 100644
--- a/drivers/net/wireless/ti/wlcore/wlcore.h
+++ b/drivers/net/wireless/ti/wlcore/wlcore.h
@@ -342,7 +342,7 @@ struct wl1271 {
         struct wl12xx_vif *sched_vif;
 
         /* The current band */
-        enum ieee80211_band band;
+        enum nl80211_band band;
 
         struct completion *elp_compl;
         struct delayed_work elp_work;
@@ -517,7 +517,7 @@ void wlcore_update_inconn_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif,
                               struct wl1271_station *wl_sta, bool in_conn);
 
 static inline void
-wlcore_set_ht_cap(struct wl1271 *wl, enum ieee80211_band band,
+wlcore_set_ht_cap(struct wl1271 *wl, enum nl80211_band band,
                   struct ieee80211_sta_ht_cap *ht_cap)
 {
         memcpy(&wl->ht_cap[band], ht_cap, sizeof(*ht_cap));
diff --git a/drivers/net/wireless/ti/wlcore/wlcore_i.h b/drivers/net/wireless/ti/wlcore/wlcore_i.h
index 27c56876b2c1..5c4199f3a19a 100644
--- a/drivers/net/wireless/ti/wlcore/wlcore_i.h
+++ b/drivers/net/wireless/ti/wlcore/wlcore_i.h
@@ -392,7 +392,7 @@ struct wl12xx_vif {
         u8 ssid_len;
 
         /* The current band */
-        enum ieee80211_band band;
+        enum nl80211_band band;
         int channel;
         enum nl80211_channel_type channel_type;
 
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index d5c371d77ddf..99de07d14939 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -1454,7 +1454,7 @@ static int wl3501_get_freq(struct net_device *dev, struct iw_request_info *info,
         struct wl3501_card *this = netdev_priv(dev);
 
         wrqu->freq.m = 100000 *
-                ieee80211_channel_to_frequency(this->chan, IEEE80211_BAND_2GHZ);
+                ieee80211_channel_to_frequency(this->chan, NL80211_BAND_2GHZ);
         wrqu->freq.e = 1;
         return 0;
 }
diff --git a/drivers/net/wireless/zydas/zd1211rw/zd_mac.c b/drivers/net/wireless/zydas/zd1211rw/zd_mac.c
index e539d9b1b562..3e37a045f702 100644
--- a/drivers/net/wireless/zydas/zd1211rw/zd_mac.c
+++ b/drivers/net/wireless/zydas/zd1211rw/zd_mac.c
@@ -1068,7 +1068,7 @@ int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length)
         }
 
         stats.freq = zd_channels[_zd_chip_get_channel(&mac->chip) - 1].center_freq;
-        stats.band = IEEE80211_BAND_2GHZ;
+        stats.band = NL80211_BAND_2GHZ;
         stats.signal = zd_check_signal(hw, status->signal_strength);
 
         rate = zd_rx_rate(buffer, status);
@@ -1395,7 +1395,7 @@ struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
         mac->band.n_channels = ARRAY_SIZE(zd_channels);
         mac->band.channels = mac->channels;
 
-        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band;
+        hw->wiphy->bands[NL80211_BAND_2GHZ] = &mac->band;
 
         ieee80211_hw_set(hw, MFP_CAPABLE);
         ieee80211_hw_set(hw, HOST_BROADCAST_PS_BUFFERING);