__be16 control_port_ethertype;
        bool control_port_no_encrypt;
        bool control_port_over_nl80211;
+       bool control_port_no_preauth;
        struct key_params *wep_keys;
        int wep_tx_key;
        const u8 *psk;
 
        sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
        sdata->control_port_over_nl80211 =
                                params->crypto.control_port_over_nl80211;
+       sdata->control_port_no_preauth =
+                               params->crypto.control_port_no_preauth;
        sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
                                                        ¶ms->crypto,
                                                        sdata->vif.type);
                        params->crypto.control_port_no_encrypt;
                vlan->control_port_over_nl80211 =
                        params->crypto.control_port_over_nl80211;
+               vlan->control_port_no_preauth =
+                       params->crypto.control_port_no_preauth;
                vlan->encrypt_headroom =
                        ieee80211_cs_headroom(sdata->local,
                                              ¶ms->crypto,
 
        u16 sequence_number;
        __be16 control_port_protocol;
        bool control_port_no_encrypt;
+       bool control_port_no_preauth;
        bool control_port_over_nl80211;
        int encrypt_headroom;
 
 
                        master->control_port_no_encrypt;
                sdata->control_port_over_nl80211 =
                        master->control_port_over_nl80211;
+               sdata->control_port_no_preauth =
+                       master->control_port_no_preauth;
                sdata->vif.cab_queue = master->vif.cab_queue;
                memcpy(sdata->vif.hw_queue, master->vif.hw_queue,
                       sizeof(sdata->vif.hw_queue));
 
        sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
        sdata->control_port_no_encrypt = false;
+       sdata->control_port_over_nl80211 = false;
+       sdata->control_port_no_preauth = false;
        sdata->encrypt_headroom = IEEE80211_ENCRYPT_HEADROOM;
        sdata->vif.bss_conf.idle = true;
        sdata->vif.bss_conf.txpower = INT_MIN; /* unset */
 
        wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_FILS_STA);
        wiphy_ext_feature_set(wiphy,
                              NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211);
+       wiphy_ext_feature_set(wiphy,
+                             NL80211_EXT_FEATURE_CONTROL_PORT_NO_PREAUTH);
 
        if (!ops->hw_scan) {
                wiphy->features |= NL80211_FEATURE_LOW_PRIORITY_SCAN |
 
        sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
        sdata->control_port_over_nl80211 =
                                        req->crypto.control_port_over_nl80211;
+       sdata->control_port_no_preauth = req->crypto.control_port_no_preauth;
        sdata->encrypt_headroom = ieee80211_cs_headroom(local, &req->crypto,
                                                        sdata->vif.type);
 
 
        struct net_device *dev = sdata->dev;
 
        if (unlikely((skb->protocol == sdata->control_port_protocol ||
-                     skb->protocol == cpu_to_be16(ETH_P_PREAUTH)) &&
+                    (skb->protocol == cpu_to_be16(ETH_P_PREAUTH) &&
+                     !sdata->control_port_no_preauth)) &&
                     sdata->control_port_over_nl80211)) {
                struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
                bool noencrypt = !(status->flag & RX_FLAG_DECRYPTED);
 
                        return r;
 
                settings->control_port_over_nl80211 = true;
+
+               if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH])
+                       settings->control_port_no_preauth = true;
        }
 
        if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {