1 files changed, 609 insertions, 207 deletions

diff --git a/drivers/net/wireless/mwifiex/cfg80211.c b/drivers/net/wireless/mwifiex/cfg80211.c
index 7be1e9b83fd0..41c8e25df954 100644
--- a/drivers/net/wireless/mwifiex/cfg80211.c
+++ b/drivers/net/wireless/mwifiex/cfg80211.c
@@ -590,77 +590,62 @@ mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
         struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
         struct mwifiex_private *priv;
         struct mwifiex_uap_bss_param *bss_cfg;
-        int ret, bss_started, i;
-
-        for (i = 0; i < adapter->priv_num; i++) {
-                priv = adapter->priv[i];
-
-                switch (priv->bss_role) {
-                case MWIFIEX_BSS_ROLE_UAP:
-                        bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param),
-                                          GFP_KERNEL);
-                        if (!bss_cfg)
-                                return -ENOMEM;
-
-                        mwifiex_set_sys_config_invalid_data(bss_cfg);
-
-                        if (changed & WIPHY_PARAM_RTS_THRESHOLD)
-                                bss_cfg->rts_threshold = wiphy->rts_threshold;
-                        if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
-                                bss_cfg->frag_threshold = wiphy->frag_threshold;
-                        if (changed & WIPHY_PARAM_RETRY_LONG)
-                                bss_cfg->retry_limit = wiphy->retry_long;
-
-                        bss_started = priv->bss_started;
-
-                        ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_STOP,
-                                               HostCmd_ACT_GEN_SET, 0,
-                                               NULL, true);
-                        if (ret) {
-                                wiphy_err(wiphy, "Failed to stop the BSS\n");
-                                kfree(bss_cfg);
-                                return ret;
-                        }
+        int ret;
 
-                        ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_SYS_CONFIG,
-                                               HostCmd_ACT_GEN_SET,
-                                               UAP_BSS_PARAMS_I, bss_cfg,
-                                               false);
+        priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
 
-                        kfree(bss_cfg);
+        switch (priv->bss_role) {
+        case MWIFIEX_BSS_ROLE_UAP:
+                if (priv->bss_started) {
+                        dev_err(adapter->dev,
+                                "cannot change wiphy params when bss started");
+                        return -EINVAL;
+                }
 
-                        if (ret) {
-                                wiphy_err(wiphy, "Failed to set bss config\n");
-                                return ret;
-                        }
+                bss_cfg = kzalloc(sizeof(*bss_cfg), GFP_KERNEL);
+                if (!bss_cfg)
+                        return -ENOMEM;
 
-                        if (!bss_started)
-                                break;
+                mwifiex_set_sys_config_invalid_data(bss_cfg);
 
-                        ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_START,
-                                               HostCmd_ACT_GEN_SET, 0,
-                                               NULL, false);
-                        if (ret) {
-                                wiphy_err(wiphy, "Failed to start BSS\n");
-                                return ret;
-                        }
+                if (changed & WIPHY_PARAM_RTS_THRESHOLD)
+                        bss_cfg->rts_threshold = wiphy->rts_threshold;
+                if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
+                        bss_cfg->frag_threshold = wiphy->frag_threshold;
+                if (changed & WIPHY_PARAM_RETRY_LONG)
+                        bss_cfg->retry_limit = wiphy->retry_long;
+
+                ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_SYS_CONFIG,
+                                       HostCmd_ACT_GEN_SET,
+                                       UAP_BSS_PARAMS_I, bss_cfg,
+                                       false);
+
+                kfree(bss_cfg);
+                if (ret) {
+                        wiphy_err(wiphy, "Failed to set wiphy phy params\n");
+                        return ret;
+                }
+                break;
 
-                        break;
                 case MWIFIEX_BSS_ROLE_STA:
-                        if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
-                                ret = mwifiex_set_rts(priv,
-                                                      wiphy->rts_threshold);
-                                if (ret)
-                                        return ret;
-                        }
-                        if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
-                                ret = mwifiex_set_frag(priv,
-                                                       wiphy->frag_threshold);
-                                if (ret)
-                                        return ret;
-                        }
-                        break;
+                if (priv->media_connected) {
+                        dev_err(adapter->dev,
+                                "cannot change wiphy params when connected");
+                        return -EINVAL;
+                }
+                if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
+                        ret = mwifiex_set_rts(priv,
+                                              wiphy->rts_threshold);
+                        if (ret)
+                                return ret;
+                }
+                if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
+                        ret = mwifiex_set_frag(priv,
+                                               wiphy->frag_threshold);
+                        if (ret)
+                                return ret;
                 }
+                break;
         }
 
         return 0;
@@ -671,9 +656,6 @@ mwifiex_cfg80211_deinit_p2p(struct mwifiex_private *priv)
 {
         u16 mode = P2P_MODE_DISABLE;
 
-        if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA)
-                mwifiex_set_bss_role(priv, MWIFIEX_BSS_ROLE_STA);
-
         if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
                              HostCmd_ACT_GEN_SET, 0, &mode, true))
                 return -1;
@@ -730,12 +712,249 @@ mwifiex_cfg80211_init_p2p_go(struct mwifiex_private *priv)
                              HostCmd_ACT_GEN_SET, 0, &mode, true))
                 return -1;
 
-        if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
-                mwifiex_set_bss_role(priv, MWIFIEX_BSS_ROLE_UAP);
+        return 0;
+}
+
+static int mwifiex_deinit_priv_params(struct mwifiex_private *priv)
+{
+        priv->mgmt_frame_mask = 0;
+        if (mwifiex_send_cmd(priv, HostCmd_CMD_MGMT_FRAME_REG,
+                             HostCmd_ACT_GEN_SET, 0,
+                             &priv->mgmt_frame_mask, false)) {
+                dev_warn(priv->adapter->dev,
+                         "could not unregister mgmt frame rx\n");
+                return -1;
+        }
+
+        mwifiex_deauthenticate(priv, NULL);
+        mwifiex_free_priv(priv);
+        priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
+        priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
+        priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
 
         return 0;
 }
 
+static int
+mwifiex_init_new_priv_params(struct mwifiex_private *priv,
+                             struct net_device *dev,
+                             enum nl80211_iftype type)
+{
+        mwifiex_init_priv(priv);
+
+        priv->bss_mode = type;
+        priv->wdev.iftype = type;
+
+        mwifiex_init_priv_params(priv, priv->netdev);
+        priv->bss_started = 0;
+
+        switch (type) {
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_ADHOC:
+                priv->bss_role =  MWIFIEX_BSS_ROLE_STA;
+                priv->bss_type = MWIFIEX_BSS_TYPE_STA;
+                break;
+        case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_P2P_GO:
+                priv->bss_role =  MWIFIEX_BSS_ROLE_STA;
+                priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
+                break;
+        case NL80211_IFTYPE_AP:
+                priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
+                priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
+                break;
+        default:
+                dev_err(priv->adapter->dev,
+                        "%s: changing to %d not supported\n",
+                        dev->name, type);
+                return -EOPNOTSUPP;
+        }
+
+        return 0;
+}
+
+static int
+mwifiex_change_vif_to_p2p(struct net_device *dev,
+                          enum nl80211_iftype curr_iftype,
+                          enum nl80211_iftype type, u32 *flags,
+                          struct vif_params *params)
+{
+        struct mwifiex_private *priv;
+        struct mwifiex_adapter *adapter;
+
+        priv = mwifiex_netdev_get_priv(dev);
+
+        if (!priv)
+                return -1;
+
+        adapter = priv->adapter;
+
+        if (adapter->curr_iface_comb.p2p_intf ==
+            adapter->iface_limit.p2p_intf) {
+                dev_err(adapter->dev,
+                        "cannot create multiple P2P ifaces\n");
+                return -1;
+        }
+
+        dev_dbg(priv->adapter->dev, "%s: changing role to p2p\n", dev->name);
+
+        if (mwifiex_deinit_priv_params(priv))
+                return -1;
+        if (mwifiex_init_new_priv_params(priv, dev, type))
+                return -1;
+
+        switch (type) {
+        case NL80211_IFTYPE_P2P_CLIENT:
+                if (mwifiex_cfg80211_init_p2p_client(priv))
+                        return -EFAULT;
+                break;
+        case NL80211_IFTYPE_P2P_GO:
+                if (mwifiex_cfg80211_init_p2p_go(priv))
+                        return -EFAULT;
+                break;
+        default:
+                dev_err(priv->adapter->dev,
+                        "%s: changing to %d not supported\n",
+                        dev->name, type);
+                return -EOPNOTSUPP;
+        }
+
+        if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
+                             HostCmd_ACT_GEN_SET, 0, NULL, true))
+                return -1;
+
+        if (mwifiex_sta_init_cmd(priv, false, false))
+                return -1;
+
+        switch (curr_iftype) {
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_ADHOC:
+                adapter->curr_iface_comb.sta_intf--;
+                break;
+        case NL80211_IFTYPE_AP:
+                adapter->curr_iface_comb.uap_intf--;
+                break;
+        default:
+                break;
+        }
+
+        adapter->curr_iface_comb.p2p_intf++;
+        dev->ieee80211_ptr->iftype = type;
+
+        return 0;
+}
+
+static int
+mwifiex_change_vif_to_sta_adhoc(struct net_device *dev,
+                                enum nl80211_iftype curr_iftype,
+                                enum nl80211_iftype type, u32 *flags,
+                                struct vif_params *params)
+{
+        struct mwifiex_private *priv;
+        struct mwifiex_adapter *adapter;
+
+        priv = mwifiex_netdev_get_priv(dev);
+
+        if (!priv)
+                return -1;
+
+        adapter = priv->adapter;
+
+        if ((curr_iftype != NL80211_IFTYPE_P2P_CLIENT &&
+             curr_iftype != NL80211_IFTYPE_P2P_GO) &&
+            (adapter->curr_iface_comb.sta_intf ==
+             adapter->iface_limit.sta_intf)) {
+                dev_err(adapter->dev,
+                        "cannot create multiple station/adhoc ifaces\n");
+                return -1;
+        }
+
+        if (type == NL80211_IFTYPE_STATION)
+                dev_notice(adapter->dev,
+                           "%s: changing role to station\n", dev->name);
+        else
+                dev_notice(adapter->dev,
+                           "%s: changing role to adhoc\n", dev->name);
+
+        if (mwifiex_deinit_priv_params(priv))
+                return -1;
+        if (mwifiex_init_new_priv_params(priv, dev, type))
+                return -1;
+        if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
+                             HostCmd_ACT_GEN_SET, 0, NULL, true))
+                return -1;
+        if (mwifiex_sta_init_cmd(priv, false, false))
+                return -1;
+
+        switch (curr_iftype) {
+        case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_P2P_GO:
+                adapter->curr_iface_comb.p2p_intf--;
+                break;
+        case NL80211_IFTYPE_AP:
+                adapter->curr_iface_comb.uap_intf--;
+                break;
+        default:
+                break;
+        }
+
+        adapter->curr_iface_comb.sta_intf++;
+        dev->ieee80211_ptr->iftype = type;
+        return 0;
+}
+
+static int
+mwifiex_change_vif_to_ap(struct net_device *dev,
+                         enum nl80211_iftype curr_iftype,
+                         enum nl80211_iftype type, u32 *flags,
+                         struct vif_params *params)
+{
+        struct mwifiex_private *priv;
+        struct mwifiex_adapter *adapter;
+
+        priv = mwifiex_netdev_get_priv(dev);
+
+        if (!priv)
+                return -1;
+
+        adapter = priv->adapter;
+
+        if (adapter->curr_iface_comb.uap_intf ==
+            adapter->iface_limit.uap_intf) {
+                dev_err(adapter->dev,
+                        "cannot create multiple AP ifaces\n");
+                return -1;
+        }
+
+        dev_notice(adapter->dev, "%s: changing role to AP\n", dev->name);
+
+        if (mwifiex_deinit_priv_params(priv))
+                return -1;
+        if (mwifiex_init_new_priv_params(priv, dev, type))
+                return -1;
+        if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
+                             HostCmd_ACT_GEN_SET, 0, NULL, true))
+                return -1;
+        if (mwifiex_sta_init_cmd(priv, false, false))
+                return -1;
+
+        switch (curr_iftype) {
+        case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_P2P_GO:
+                adapter->curr_iface_comb.p2p_intf--;
+                break;
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_ADHOC:
+                adapter->curr_iface_comb.sta_intf--;
+                break;
+        default:
+                break;
+        }
+
+        adapter->curr_iface_comb.uap_intf++;
+        dev->ieee80211_ptr->iftype = type;
+        return 0;
+}
 /*
  * CFG802.11 operation handler to change interface type.
  */
@@ -745,19 +964,32 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
                                      enum nl80211_iftype type, u32 *flags,
                                      struct vif_params *params)
 {
-        int ret;
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
+        enum nl80211_iftype curr_iftype = dev->ieee80211_ptr->iftype;
 
-        switch (dev->ieee80211_ptr->iftype) {
+        switch (curr_iftype) {
         case NL80211_IFTYPE_ADHOC:
                 switch (type) {
                 case NL80211_IFTYPE_STATION:
-                        break;
+                        priv->bss_mode = type;
+                        priv->sec_info.authentication_mode =
+                                                   NL80211_AUTHTYPE_OPEN_SYSTEM;
+                        dev->ieee80211_ptr->iftype = type;
+                        mwifiex_deauthenticate(priv, NULL);
+                        return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
+                                                HostCmd_ACT_GEN_SET, 0, NULL,
+                                                true);
+                case NL80211_IFTYPE_P2P_CLIENT:
+                case NL80211_IFTYPE_P2P_GO:
+                        return mwifiex_change_vif_to_p2p(dev, curr_iftype,
+                                                         type, flags, params);
+                case NL80211_IFTYPE_AP:
+                        return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
+                                                        flags, params);
                 case NL80211_IFTYPE_UNSPECIFIED:
                         wiphy_warn(wiphy, "%s: kept type as IBSS\n", dev->name);
                 case NL80211_IFTYPE_ADHOC:      /* This shouldn't happen */
                         return 0;
-                case NL80211_IFTYPE_AP:
                 default:
                         wiphy_err(wiphy, "%s: changing to %d not supported\n",
                                   dev->name, type);
@@ -767,22 +999,25 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
         case NL80211_IFTYPE_STATION:
                 switch (type) {
                 case NL80211_IFTYPE_ADHOC:
-                        break;
-                case NL80211_IFTYPE_P2P_CLIENT:
-                        if (mwifiex_cfg80211_init_p2p_client(priv))
-                                return -EFAULT;
+                        priv->bss_mode = type;
+                        priv->sec_info.authentication_mode =
+                                                   NL80211_AUTHTYPE_OPEN_SYSTEM;
                         dev->ieee80211_ptr->iftype = type;
-                        return 0;
+                        mwifiex_deauthenticate(priv, NULL);
+                        return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
+                                                HostCmd_ACT_GEN_SET, 0, NULL,
+                                                true);
+                case NL80211_IFTYPE_P2P_CLIENT:
                 case NL80211_IFTYPE_P2P_GO:
-                        if (mwifiex_cfg80211_init_p2p_go(priv))
-                                return -EFAULT;
-                        dev->ieee80211_ptr->iftype = type;
-                        return 0;
+                        return mwifiex_change_vif_to_p2p(dev, curr_iftype,
+                                                         type, flags, params);
+                case NL80211_IFTYPE_AP:
+                        return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
+                                                        flags, params);
                 case NL80211_IFTYPE_UNSPECIFIED:
                         wiphy_warn(wiphy, "%s: kept type as STA\n", dev->name);
                 case NL80211_IFTYPE_STATION:    /* This shouldn't happen */
                         return 0;
-                case NL80211_IFTYPE_AP:
                 default:
                         wiphy_err(wiphy, "%s: changing to %d not supported\n",
                                   dev->name, type);
@@ -791,12 +1026,20 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
                 break;
         case NL80211_IFTYPE_AP:
                 switch (type) {
+                case NL80211_IFTYPE_ADHOC:
+                case NL80211_IFTYPE_STATION:
+                        return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
+                                                               type, flags,
+                                                               params);
+                        break;
+                case NL80211_IFTYPE_P2P_CLIENT:
+                case NL80211_IFTYPE_P2P_GO:
+                        return mwifiex_change_vif_to_p2p(dev, curr_iftype,
+                                                         type, flags, params);
                 case NL80211_IFTYPE_UNSPECIFIED:
                         wiphy_warn(wiphy, "%s: kept type as AP\n", dev->name);
                 case NL80211_IFTYPE_AP:         /* This shouldn't happen */
                         return 0;
-                case NL80211_IFTYPE_ADHOC:
-                case NL80211_IFTYPE_STATION:
                 default:
                         wiphy_err(wiphy, "%s: changing to %d not supported\n",
                                   dev->name, type);
@@ -807,11 +1050,30 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
         case NL80211_IFTYPE_P2P_GO:
                 switch (type) {
                 case NL80211_IFTYPE_STATION:
-                        if (mwifiex_cfg80211_deinit_p2p(priv))
+                        if (mwifiex_cfg80211_init_p2p_client(priv))
                                 return -EFAULT;
                         dev->ieee80211_ptr->iftype = type;
+                        break;
+                case NL80211_IFTYPE_ADHOC:
+                        if (mwifiex_cfg80211_deinit_p2p(priv))
+                                return -EFAULT;
+                        return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
+                                                               type, flags,
+                                                               params);
+                        break;
+                case NL80211_IFTYPE_AP:
+                        if (mwifiex_cfg80211_deinit_p2p(priv))
+                                return -EFAULT;
+                        return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
+                                                        flags, params);
+                case NL80211_IFTYPE_UNSPECIFIED:
+                        wiphy_warn(wiphy, "%s: kept type as P2P\n", dev->name);
+                case NL80211_IFTYPE_P2P_CLIENT:
+                case NL80211_IFTYPE_P2P_GO:
                         return 0;
                 default:
+                        wiphy_err(wiphy, "%s: changing to %d not supported\n",
+                                  dev->name, type);
                         return -EOPNOTSUPP;
                 }
                 break;
@@ -821,16 +1083,8 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
                 return -EOPNOTSUPP;
         }
 
-        dev->ieee80211_ptr->iftype = type;
-        priv->bss_mode = type;
-        mwifiex_deauthenticate(priv, NULL);
-
-        priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
 
-        ret = mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
-                               HostCmd_ACT_GEN_SET, 0, NULL, true);
-
-        return ret;
+        return 0;
 }
 
 static void
@@ -1397,10 +1651,13 @@ static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
 {
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 
+        mwifiex_abort_cac(priv);
+
         if (mwifiex_del_mgmt_ies(priv))
                 wiphy_err(wiphy, "Failed to delete mgmt IEs!\n");
 
         priv->ap_11n_enabled = 0;
+        memset(&priv->bss_cfg, 0, sizeof(priv->bss_cfg));
 
         if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_STOP,
                              HostCmd_ACT_GEN_SET, 0, NULL, true)) {
@@ -1422,12 +1679,9 @@ static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
 {
         struct mwifiex_uap_bss_param *bss_cfg;
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
-        u8 config_bands = 0;
 
         if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
                 return -1;
-        if (mwifiex_set_mgmt_ies(priv, &params->beacon))
-                return -1;
 
         bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
         if (!bss_cfg)
@@ -1444,6 +1698,11 @@ static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
                 memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
                 bss_cfg->ssid.ssid_len = params->ssid_len;
         }
+        if (params->inactivity_timeout > 0) {
+                /* sta_ao_timer/ps_sta_ao_timer is in unit of 100ms */
+                bss_cfg->sta_ao_timer = 10 * params->inactivity_timeout;
+                bss_cfg->ps_sta_ao_timer = 10 * params->inactivity_timeout;
+        }
 
         switch (params->hidden_ssid) {
         case NL80211_HIDDEN_SSID_NOT_IN_USE:
@@ -1459,33 +1718,8 @@ static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
                 return -EINVAL;
         }
 
-        bss_cfg->channel = ieee80211_frequency_to_channel(
-                                params->chandef.chan->center_freq);
-
-        /* Set appropriate bands */
-        if (params->chandef.chan->band == IEEE80211_BAND_2GHZ) {
-                bss_cfg->band_cfg = BAND_CONFIG_BG;
-                config_bands = BAND_B | BAND_G;
-
-                if (params->chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
-                        config_bands |= BAND_GN;
-        } else {
-                bss_cfg->band_cfg = BAND_CONFIG_A;
-                config_bands = BAND_A;
-
-                if (params->chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
-                        config_bands |= BAND_AN;
-
-                if (params->chandef.width > NL80211_CHAN_WIDTH_40)
-                        config_bands |= BAND_AAC;
-        }
-
-        if (!((config_bands | priv->adapter->fw_bands) &
-              ~priv->adapter->fw_bands))
-                priv->adapter->config_bands = config_bands;
-
+        mwifiex_uap_set_channel(bss_cfg, params->chandef);
         mwifiex_set_uap_rates(bss_cfg, params);
-        mwifiex_send_domain_info_cmd_fw(wiphy);
 
         if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
                 kfree(bss_cfg);
@@ -1508,45 +1742,29 @@ static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
 
         mwifiex_set_wmm_params(priv, bss_cfg, params);
 
-        if (params->inactivity_timeout > 0) {
-                /* sta_ao_timer/ps_sta_ao_timer is in unit of 100ms */
-                bss_cfg->sta_ao_timer = 10 * params->inactivity_timeout;
-                bss_cfg->ps_sta_ao_timer = 10 * params->inactivity_timeout;
+        if (mwifiex_is_11h_active(priv) &&
+            !cfg80211_chandef_dfs_required(wiphy, &params->chandef,
+                                           priv->bss_mode)) {
+                dev_dbg(priv->adapter->dev, "Disable 11h extensions in FW\n");
+                if (mwifiex_11h_activate(priv, false)) {
+                        dev_err(priv->adapter->dev,
+                                "Failed to disable 11h extensions!!");
+                        return -1;
+                }
+                priv->state_11h.is_11h_active = true;
         }
 
-        if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_STOP,
-                             HostCmd_ACT_GEN_SET, 0, NULL, true)) {
-                wiphy_err(wiphy, "Failed to stop the BSS\n");
+        if (mwifiex_config_start_uap(priv, bss_cfg)) {
+                wiphy_err(wiphy, "Failed to start AP\n");
                 kfree(bss_cfg);
                 return -1;
         }
 
-        if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_SYS_CONFIG,
-                             HostCmd_ACT_GEN_SET,
-                             UAP_BSS_PARAMS_I, bss_cfg, false)) {
-                wiphy_err(wiphy, "Failed to set the SSID\n");
-                kfree(bss_cfg);
+        if (mwifiex_set_mgmt_ies(priv, &params->beacon))
                 return -1;
-        }
 
+        memcpy(&priv->bss_cfg, bss_cfg, sizeof(priv->bss_cfg));
         kfree(bss_cfg);
-
-        if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_START,
-                             HostCmd_ACT_GEN_SET, 0, NULL, false)) {
-                wiphy_err(wiphy, "Failed to start the BSS\n");
-                return -1;
-        }
-
-        if (priv->sec_info.wep_enabled)
-                priv->curr_pkt_filter |= HostCmd_ACT_MAC_WEP_ENABLE;
-        else
-                priv->curr_pkt_filter &= ~HostCmd_ACT_MAC_WEP_ENABLE;
-
-        if (mwifiex_send_cmd(priv, HostCmd_CMD_MAC_CONTROL,
-                             HostCmd_ACT_GEN_SET, 0,
-                             &priv->curr_pkt_filter, true))
-                return -1;
-
         return 0;
 }
 
@@ -1605,15 +1823,15 @@ static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
         ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
 
         band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
-        chan = __ieee80211_get_channel(priv->wdev->wiphy,
+        chan = __ieee80211_get_channel(priv->wdev.wiphy,
                         ieee80211_channel_to_frequency(bss_info.bss_chan,
                                                        band));
 
-        bss = cfg80211_inform_bss(priv->wdev->wiphy, chan,
+        bss = cfg80211_inform_bss(priv->wdev.wiphy, chan,
                                   CFG80211_BSS_FTYPE_UNKNOWN,
                                   bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
                                   0, ie_buf, ie_len, 0, GFP_KERNEL);
-        cfg80211_put_bss(priv->wdev->wiphy, bss);
+        cfg80211_put_bss(priv->wdev.wiphy, bss);
         memcpy(priv->cfg_bssid, bss_info.bssid, ETH_ALEN);
 
         return 0;
@@ -1734,12 +1952,12 @@ done:
 
                 /* Find the BSS we want using available scan results */
                 if (mode == NL80211_IFTYPE_ADHOC)
-                        bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
+                        bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
                                                bssid, ssid, ssid_len,
                                                WLAN_CAPABILITY_IBSS,
                                                WLAN_CAPABILITY_IBSS);
                 else
-                        bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
+                        bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
                                                bssid, ssid, ssid_len,
                                                WLAN_CAPABILITY_ESS,
                                                WLAN_CAPABILITY_ESS);
@@ -1796,7 +2014,7 @@ mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
                 return -EINVAL;
         }
 
-        if (priv->wdev && priv->wdev->current_bss) {
+        if (priv->wdev.current_bss) {
                 wiphy_warn(wiphy, "%s: already connected\n", dev->name);
                 return -EALREADY;
         }
@@ -1854,7 +2072,7 @@ mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
 static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
                                    struct cfg80211_ibss_params *params)
 {
-        struct wiphy *wiphy = priv->wdev->wiphy;
+        struct wiphy *wiphy = priv->wdev.wiphy;
         struct mwifiex_adapter *adapter = priv->adapter;
         int index = 0, i;
         u8 config_bands = 0;
@@ -2179,6 +2397,7 @@ mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
         ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
 }
 
+#define MWIFIEX_MAX_WQ_LEN  30
 /*
  *  create a new virtual interface with the given name
  */
@@ -2192,7 +2411,7 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
         struct mwifiex_private *priv;
         struct net_device *dev;
         void *mdev_priv;
-        struct wireless_dev *wdev;
+        char dfs_cac_str[MWIFIEX_MAX_WQ_LEN], dfs_chsw_str[MWIFIEX_MAX_WQ_LEN];
 
         if (!adapter)
                 return ERR_PTR(-EFAULT);
@@ -2201,20 +2420,22 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
         case NL80211_IFTYPE_UNSPECIFIED:
         case NL80211_IFTYPE_STATION:
         case NL80211_IFTYPE_ADHOC:
-                priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
-                if (priv->bss_mode) {
+                if (adapter->curr_iface_comb.sta_intf ==
+                    adapter->iface_limit.sta_intf) {
                         wiphy_err(wiphy,
                                   "cannot create multiple sta/adhoc ifaces\n");
                         return ERR_PTR(-EINVAL);
                 }
 
-                wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
-                if (!wdev)
-                        return ERR_PTR(-ENOMEM);
+                priv = mwifiex_get_unused_priv(adapter);
+                if (!priv) {
+                        wiphy_err(wiphy,
+                                  "could not get free private struct\n");
+                        return ERR_PTR(-EFAULT);
+                }
 
-                wdev->wiphy = wiphy;
-                priv->wdev = wdev;
-                wdev->iftype = NL80211_IFTYPE_STATION;
+                priv->wdev.wiphy = wiphy;
+                priv->wdev.iftype = NL80211_IFTYPE_STATION;
 
                 if (type == NL80211_IFTYPE_UNSPECIFIED)
                         priv->bss_mode = NL80211_IFTYPE_STATION;
@@ -2229,20 +2450,22 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
 
                 break;
         case NL80211_IFTYPE_AP:
-                priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP];
-
-                if (priv->bss_mode) {
-                        wiphy_err(wiphy, "Can't create multiple AP interfaces");
+                if (adapter->curr_iface_comb.uap_intf ==
+                    adapter->iface_limit.uap_intf) {
+                        wiphy_err(wiphy,
+                                  "cannot create multiple AP ifaces\n");
                         return ERR_PTR(-EINVAL);
                 }
 
-                wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
-                if (!wdev)
-                        return ERR_PTR(-ENOMEM);
+                priv = mwifiex_get_unused_priv(adapter);
+                if (!priv) {
+                        wiphy_err(wiphy,
+                                  "could not get free private struct\n");
+                        return ERR_PTR(-EFAULT);
+                }
 
-                priv->wdev = wdev;
-                wdev->wiphy = wiphy;
-                wdev->iftype = NL80211_IFTYPE_AP;
+                priv->wdev.wiphy = wiphy;
+                priv->wdev.iftype = NL80211_IFTYPE_AP;
 
                 priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
                 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
@@ -2254,24 +2477,25 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
 
                 break;
         case NL80211_IFTYPE_P2P_CLIENT:
-                priv = adapter->priv[MWIFIEX_BSS_TYPE_P2P];
-
-                if (priv->bss_mode) {
-                        wiphy_err(wiphy, "Can't create multiple P2P ifaces");
+                if (adapter->curr_iface_comb.p2p_intf ==
+                    adapter->iface_limit.p2p_intf) {
+                        wiphy_err(wiphy,
+                                  "cannot create multiple P2P ifaces\n");
                         return ERR_PTR(-EINVAL);
                 }
 
-                wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
-                if (!wdev)
-                        return ERR_PTR(-ENOMEM);
-
-                priv->wdev = wdev;
-                wdev->wiphy = wiphy;
+                priv = mwifiex_get_unused_priv(adapter);
+                if (!priv) {
+                        wiphy_err(wiphy,
+                                  "could not get free private struct\n");
+                        return ERR_PTR(-EFAULT);
+                }
 
+                priv->wdev.wiphy = wiphy;
                 /* At start-up, wpa_supplicant tries to change the interface
                  * to NL80211_IFTYPE_STATION if it is not managed mode.
                  */
-                wdev->iftype = NL80211_IFTYPE_P2P_CLIENT;
+                priv->wdev.iftype = NL80211_IFTYPE_P2P_CLIENT;
                 priv->bss_mode = NL80211_IFTYPE_P2P_CLIENT;
 
                 /* Setting bss_type to P2P tells firmware that this interface
@@ -2287,8 +2511,9 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
                 priv->bss_num = 0;
 
                 if (mwifiex_cfg80211_init_p2p_client(priv)) {
-                        wdev = ERR_PTR(-EFAULT);
-                        goto done;
+                        memset(&priv->wdev, 0, sizeof(priv->wdev));
+                        priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
+                        return ERR_PTR(-EFAULT);
                 }
 
                 break;
@@ -2302,9 +2527,10 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
                                IEEE80211_NUM_ACS, 1);
         if (!dev) {
                 wiphy_err(wiphy, "no memory available for netdevice\n");
+                memset(&priv->wdev, 0, sizeof(priv->wdev));
+                priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
                 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
-                wdev = ERR_PTR(-ENOMEM);
-                goto done;
+                return ERR_PTR(-ENOMEM);
         }
 
         mwifiex_init_priv_params(priv, dev);
@@ -2324,7 +2550,7 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
                         &wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap, priv);
 
         dev_net_set(dev, wiphy_net(wiphy));
-        dev->ieee80211_ptr = priv->wdev;
+        dev->ieee80211_ptr = &priv->wdev;
         dev->ieee80211_ptr->iftype = priv->bss_mode;
         memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
         SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
@@ -2345,10 +2571,47 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
                 free_netdev(dev);
                 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
                 priv->netdev = NULL;
-                wdev = ERR_PTR(-EFAULT);
-                goto done;
+                memset(&priv->wdev, 0, sizeof(priv->wdev));
+                priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
+                return ERR_PTR(-EFAULT);
+        }
+
+        strcpy(dfs_cac_str, "MWIFIEX_DFS_CAC");
+        strcat(dfs_cac_str, name);
+        priv->dfs_cac_workqueue = alloc_workqueue(dfs_cac_str,
+                                                  WQ_HIGHPRI |
+                                                  WQ_MEM_RECLAIM |
+                                                  WQ_UNBOUND, 1);
+        if (!priv->dfs_cac_workqueue) {
+                wiphy_err(wiphy, "cannot register virtual network device\n");
+                free_netdev(dev);
+                priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
+                priv->netdev = NULL;
+                memset(&priv->wdev, 0, sizeof(priv->wdev));
+                priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
+                return ERR_PTR(-ENOMEM);
+        }
+
+        INIT_DELAYED_WORK(&priv->dfs_cac_work, mwifiex_dfs_cac_work_queue);
+
+        strcpy(dfs_chsw_str, "MWIFIEX_DFS_CHSW");
+        strcat(dfs_chsw_str, name);
+        priv->dfs_chan_sw_workqueue = alloc_workqueue(dfs_chsw_str,
+                                                      WQ_HIGHPRI | WQ_UNBOUND |
+                                                      WQ_MEM_RECLAIM, 1);
+        if (!priv->dfs_chan_sw_workqueue) {
+                wiphy_err(wiphy, "cannot register virtual network device\n");
+                free_netdev(dev);
+                priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
+                priv->netdev = NULL;
+                memset(&priv->wdev, 0, sizeof(priv->wdev));
+                priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
+                return ERR_PTR(-ENOMEM);
         }
 
+        INIT_DELAYED_WORK(&priv->dfs_chan_sw_work,
+                          mwifiex_dfs_chan_sw_work_queue);
+
         sema_init(&priv->async_sem, 1);
 
         dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name);
@@ -2357,13 +2620,24 @@ struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
         mwifiex_dev_debugfs_init(priv);
 #endif
 
-done:
-        if (IS_ERR(wdev)) {
-                kfree(priv->wdev);
-                priv->wdev = NULL;
+        switch (type) {
+        case NL80211_IFTYPE_UNSPECIFIED:
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_ADHOC:
+                adapter->curr_iface_comb.sta_intf++;
+                break;
+        case NL80211_IFTYPE_AP:
+                adapter->curr_iface_comb.uap_intf++;
+                break;
+        case NL80211_IFTYPE_P2P_CLIENT:
+                adapter->curr_iface_comb.p2p_intf++;
+                break;
+        default:
+                wiphy_err(wiphy, "type not supported\n");
+                return ERR_PTR(-EINVAL);
         }
 
-        return wdev;
+        return &priv->wdev;
 }
 EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
 
@@ -2373,12 +2647,13 @@ EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
 int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
 {
         struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
+        struct mwifiex_adapter *adapter = priv->adapter;
 
 #ifdef CONFIG_DEBUG_FS
         mwifiex_dev_debugfs_remove(priv);
 #endif
 
-        mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
+        mwifiex_stop_net_dev_queue(priv->netdev, adapter);
 
         if (netif_carrier_ok(priv->netdev))
                 netif_carrier_off(priv->netdev);
@@ -2386,14 +2661,42 @@ int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
         if (wdev->netdev->reg_state == NETREG_REGISTERED)
                 unregister_netdevice(wdev->netdev);
 
+        if (priv->dfs_cac_workqueue) {
+                flush_workqueue(priv->dfs_cac_workqueue);
+                destroy_workqueue(priv->dfs_cac_workqueue);
+                priv->dfs_cac_workqueue = NULL;
+        }
+
+        if (priv->dfs_chan_sw_workqueue) {
+                flush_workqueue(priv->dfs_chan_sw_workqueue);
+                destroy_workqueue(priv->dfs_chan_sw_workqueue);
+                priv->dfs_chan_sw_workqueue = NULL;
+        }
         /* Clear the priv in adapter */
         priv->netdev->ieee80211_ptr = NULL;
         priv->netdev = NULL;
-        kfree(wdev);
-        priv->wdev = NULL;
+        priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
 
         priv->media_connected = false;
 
+        switch (priv->bss_mode) {
+        case NL80211_IFTYPE_UNSPECIFIED:
+        case NL80211_IFTYPE_STATION:
+        case NL80211_IFTYPE_ADHOC:
+                adapter->curr_iface_comb.sta_intf++;
+                break;
+        case NL80211_IFTYPE_AP:
+                adapter->curr_iface_comb.uap_intf++;
+                break;
+        case NL80211_IFTYPE_P2P_CLIENT:
+        case NL80211_IFTYPE_P2P_GO:
+                adapter->curr_iface_comb.p2p_intf++;
+                break;
+        default:
+                dev_err(adapter->dev, "del_virtual_intf: type not supported\n");
+                break;
+        }
+
         priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
 
         if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
@@ -2848,6 +3151,102 @@ mwifiex_cfg80211_add_station(struct wiphy *wiphy, struct net_device *dev,
 }
 
 static int
+mwifiex_cfg80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
+                                struct cfg80211_csa_settings *params)
+{
+        struct ieee_types_header *chsw_ie;
+        struct ieee80211_channel_sw_ie *channel_sw;
+        int chsw_msec;
+        struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
+
+        if (priv->adapter->scan_processing) {
+                dev_err(priv->adapter->dev,
+                        "radar detection: scan in process...\n");
+                return -EBUSY;
+        }
+
+        if (priv->wdev.cac_started)
+                return -EBUSY;
+
+        if (cfg80211_chandef_identical(&params->chandef,
+                                       &priv->dfs_chandef))
+                return -EINVAL;
+
+        chsw_ie = (void *)cfg80211_find_ie(WLAN_EID_CHANNEL_SWITCH,
+                                           params->beacon_csa.tail,
+                                           params->beacon_csa.tail_len);
+        if (!chsw_ie) {
+                dev_err(priv->adapter->dev,
+                        "Could not parse channel switch announcement IE\n");
+                return -EINVAL;
+        }
+
+        channel_sw = (void *)(chsw_ie + 1);
+        if (channel_sw->mode) {
+                if (netif_carrier_ok(priv->netdev))
+                        netif_carrier_off(priv->netdev);
+                mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
+        }
+
+        if (mwifiex_del_mgmt_ies(priv))
+                wiphy_err(wiphy, "Failed to delete mgmt IEs!\n");
+
+        if (mwifiex_set_mgmt_ies(priv, &params->beacon_csa)) {
+                wiphy_err(wiphy, "%s: setting mgmt ies failed\n", __func__);
+                return -EFAULT;
+        }
+
+        memcpy(&priv->dfs_chandef, &params->chandef, sizeof(priv->dfs_chandef));
+        memcpy(&priv->beacon_after, &params->beacon_after,
+               sizeof(priv->beacon_after));
+
+        chsw_msec = max(channel_sw->count * priv->bss_cfg.beacon_period, 100);
+        queue_delayed_work(priv->dfs_chan_sw_workqueue, &priv->dfs_chan_sw_work,
+                           msecs_to_jiffies(chsw_msec));
+        return 0;
+}
+
+static int
+mwifiex_cfg80211_start_radar_detection(struct wiphy *wiphy,
+                                       struct net_device *dev,
+                                       struct cfg80211_chan_def *chandef,
+                                       u32 cac_time_ms)
+{
+        struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
+        struct mwifiex_radar_params radar_params;
+
+        if (priv->adapter->scan_processing) {
+                dev_err(priv->adapter->dev,
+                        "radar detection: scan already in process...\n");
+                return -EBUSY;
+        }
+
+        if (!mwifiex_is_11h_active(priv)) {
+                dev_dbg(priv->adapter->dev, "Enable 11h extensions in FW\n");
+                if (mwifiex_11h_activate(priv, true)) {
+                        dev_err(priv->adapter->dev,
+                                "Failed to activate 11h extensions!!");
+                        return -1;
+                }
+                priv->state_11h.is_11h_active = true;
+        }
+
+        memset(&radar_params, 0, sizeof(struct mwifiex_radar_params));
+        radar_params.chandef = chandef;
+        radar_params.cac_time_ms = cac_time_ms;
+
+        memcpy(&priv->dfs_chandef, chandef, sizeof(priv->dfs_chandef));
+
+        if (mwifiex_send_cmd(priv, HostCmd_CMD_CHAN_REPORT_REQUEST,
+                             HostCmd_ACT_GEN_SET, 0, &radar_params, true))
+                return -1;
+
+        queue_delayed_work(priv->dfs_cac_workqueue, &priv->dfs_cac_work,
+                           msecs_to_jiffies(cac_time_ms));
+        return 0;
+}
+
+static int
 mwifiex_cfg80211_change_station(struct wiphy *wiphy, struct net_device *dev,
                                 const u8 *mac,
                                 struct station_parameters *params)
@@ -2911,6 +3310,8 @@ static struct cfg80211_ops mwifiex_cfg80211_ops = {
         .tdls_oper = mwifiex_cfg80211_tdls_oper,
         .add_station = mwifiex_cfg80211_add_station,
         .change_station = mwifiex_cfg80211_change_station,
+        .start_radar_detection = mwifiex_cfg80211_start_radar_detection,
+        .channel_switch = mwifiex_cfg80211_channel_switch,
 };
 
 #ifdef CONFIG_PM
@@ -3009,12 +3410,13 @@ int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
         wiphy->cipher_suites = mwifiex_cipher_suites;
         wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
 
-        memcpy(wiphy->perm_addr, priv->curr_addr, ETH_ALEN);
+        ether_addr_copy(wiphy->perm_addr, adapter->perm_addr);
         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
         wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
                         WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD |
                         WIPHY_FLAG_AP_UAPSD |
-                        WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
+                        WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
+                        WIPHY_FLAG_HAS_CHANNEL_SWITCH;
 
         if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
                 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |