ctx <= &sc->chanctx[ARRAY_SIZE(sc->chanctx) - 1];      \
             ctx++)
 
-void ath9k_fill_chanctx_ops(void);
 void ath9k_chanctx_force_active(struct ieee80211_hw *hw,
                                struct ieee80211_vif *vif);
 static inline struct ath_chanctx *
 void ath_roc_complete(struct ath_softc *sc, bool abort);
 
 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
+bool ath9k_is_chanctx_enabled(void);
+void ath9k_fill_chanctx_ops(void);
 int ath9k_init_p2p(struct ath_softc *sc);
 void ath9k_deinit_p2p(struct ath_softc *sc);
 void ath9k_p2p_remove_vif(struct ath_softc *sc,
                                struct ieee80211_vif *vif);
 void ath9k_p2p_ps_timer(void *priv);
 #else
+static inline bool ath9k_is_chanctx_enabled(void)
+{
+       return false;
+}
+static inline void ath9k_fill_chanctx_ops(void)
+{
+}
 static inline int ath9k_init_p2p(struct ath_softc *sc)
 {
        return 0;
 
 module_param_named(ps_enable, ath9k_ps_enable, int, 0444);
 MODULE_PARM_DESC(ps_enable, "Enable WLAN PowerSave");
 
+#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
+
 int ath9k_use_chanctx;
 module_param_named(use_chanctx, ath9k_use_chanctx, int, 0444);
 MODULE_PARM_DESC(use_chanctx, "Enable channel context for concurrency");
 
+#endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */
+
 bool is_ath9k_unloaded;
 
 #ifdef CONFIG_MAC80211_LEDS
        sc->tx99_power = MAX_RATE_POWER + 1;
        init_waitqueue_head(&sc->tx_wait);
        sc->cur_chan = &sc->chanctx[0];
-       if (!ath9k_use_chanctx)
+       if (!ath9k_is_chanctx_enabled())
                sc->cur_chan->hw_queue_base = 0;
 
        if (!pdata || pdata->use_eeprom) {
        { .max = 2048,  .types = BIT(NL80211_IFTYPE_WDS) },
 };
 
+#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
+
 static const struct ieee80211_iface_limit if_limits_multi[] = {
        { .max = 1,     .types = BIT(NL80211_IFTYPE_STATION) },
        { .max = 1,     .types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
                                 BIT(NL80211_IFTYPE_P2P_GO) },
 };
 
-static const struct ieee80211_iface_limit if_dfs_limits[] = {
-       { .max = 1,     .types = BIT(NL80211_IFTYPE_AP) |
-#ifdef CONFIG_MAC80211_MESH
-                                BIT(NL80211_IFTYPE_MESH_POINT) |
-#endif
-                                BIT(NL80211_IFTYPE_ADHOC) },
-};
-
 static const struct ieee80211_iface_combination if_comb_multi[] = {
        {
                .limits = if_limits_multi,
        },
 };
 
+#endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */
+
+static const struct ieee80211_iface_limit if_dfs_limits[] = {
+       { .max = 1,     .types = BIT(NL80211_IFTYPE_AP) |
+#ifdef CONFIG_MAC80211_MESH
+                                BIT(NL80211_IFTYPE_MESH_POINT) |
+#endif
+                                BIT(NL80211_IFTYPE_ADHOC) },
+};
+
 static const struct ieee80211_iface_combination if_comb[] = {
        {
                .limits = if_limits,
                        BIT(NL80211_IFTYPE_AP) |
                        BIT(NL80211_IFTYPE_STATION) |
                        BIT(NL80211_IFTYPE_ADHOC) |
-                       BIT(NL80211_IFTYPE_MESH_POINT);
-               if (!ath9k_use_chanctx) {
+                       BIT(NL80211_IFTYPE_MESH_POINT) |
+                       BIT(NL80211_IFTYPE_WDS);
+
                        hw->wiphy->iface_combinations = if_comb;
                        hw->wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
-                       hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_WDS);
-               } else {
-                       hw->wiphy->iface_combinations = if_comb_multi;
-                       hw->wiphy->n_iface_combinations =
-                               ARRAY_SIZE(if_comb_multi);
-                       hw->wiphy->max_scan_ssids = 255;
-                       hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
-                       hw->wiphy->max_remain_on_channel_duration = 10000;
-                       hw->chanctx_data_size = sizeof(void *);
-                       hw->extra_beacon_tailroom =
-                               sizeof(struct ieee80211_p2p_noa_attr) + 9;
-
-                       ath_dbg(common, CHAN_CTX, "Use channel contexts\n");
-               }
        }
 
+#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
+
+       if (ath9k_is_chanctx_enabled()) {
+               hw->wiphy->interface_modes &= ~ BIT(NL80211_IFTYPE_WDS);
+               hw->wiphy->iface_combinations = if_comb_multi;
+               hw->wiphy->n_iface_combinations = ARRAY_SIZE(if_comb_multi);
+               hw->wiphy->max_scan_ssids = 255;
+               hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
+               hw->wiphy->max_remain_on_channel_duration = 10000;
+               hw->chanctx_data_size = sizeof(void *);
+               hw->extra_beacon_tailroom =
+                       sizeof(struct ieee80211_p2p_noa_attr) + 9;
+
+               ath_dbg(common, CHAN_CTX, "Use channel contexts\n");
+       }
+
+#endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */
+
        hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
 
        hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 
        ath9k_hw_set_interrupts(ah);
        ath9k_hw_enable_interrupts(ah);
 
-       if (!ath9k_use_chanctx)
+       if (!ath9k_is_chanctx_enabled())
                ieee80211_wake_queues(sc->hw);
        else {
                if (sc->cur_chan == &sc->offchannel.chan)
                ath9k_beacon_assign_slot(sc, vif);
 
        avp->vif = vif;
-       if (!ath9k_use_chanctx) {
+       if (!ath9k_is_chanctx_enabled()) {
                avp->chanctx = sc->cur_chan;
                list_add_tail(&avp->list, &avp->chanctx->vifs);
        }
 
        sc->nvifs--;
        sc->tx99_vif = NULL;
-       if (!ath9k_use_chanctx)
+       if (!ath9k_is_chanctx_enabled())
                list_del(&avp->list);
 
        if (ath9k_uses_beacons(vif->type))
                }
        }
 
-       if (!ath9k_use_chanctx && (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
+       if (!ath9k_is_chanctx_enabled() && (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
                ctx->offchannel = !!(conf->flags & IEEE80211_CONF_OFFCHANNEL);
                ath_chanctx_set_channel(sc, ctx, &hw->conf.chandef);
        }
        clear_bit(ATH_OP_SCANNING, &common->op_flags);
 }
 
+#ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
+
 static int ath9k_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                         struct ieee80211_scan_request *hw_req)
 {
 
 void ath9k_fill_chanctx_ops(void)
 {
-       if (!ath9k_use_chanctx)
+       if (!ath9k_is_chanctx_enabled())
                return;
 
        ath9k_ops.hw_scan                  = ath9k_hw_scan;
        ath9k_ops.mgd_prepare_tx           = ath9k_chanctx_force_active;
 }
 
+#endif
+
 struct ieee80211_ops ath9k_ops = {
        .tx                 = ath9k_tx,
        .start              = ath9k_start,