// SPDX-License-Identifier: GPL-2.0-only /* * NXP Wireless LAN device driver: AP specific command handling * * Copyright 2011-2024 NXP */ #include "main.h" #include "cmdevt.h" #include "11n.h" #include "11ac.h" #include "11ax.h" /* Parse BSS params and append WPA/WPA2 TLVs to the command buffer. */ static void nxpwifi_uap_bss_wpa(u8 **tlv_buf, void *cmd_buf, u16 *param_size) { struct host_cmd_tlv_pwk_cipher *pwk_cipher; struct host_cmd_tlv_gwk_cipher *gwk_cipher; struct host_cmd_tlv_passphrase *passphrase; struct host_cmd_tlv_akmp *tlv_akmp; struct nxpwifi_uap_bss_param *bss_cfg = cmd_buf; u16 cmd_size = *param_size; u8 *tlv = *tlv_buf; tlv_akmp = (struct host_cmd_tlv_akmp *)tlv; tlv_akmp->header.type = cpu_to_le16(TLV_TYPE_UAP_AKMP); tlv_akmp->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_akmp) - sizeof(struct nxpwifi_ie_types_header)); tlv_akmp->key_mgmt_operation = cpu_to_le16(bss_cfg->key_mgmt_operation); tlv_akmp->key_mgmt = cpu_to_le16(bss_cfg->key_mgmt); cmd_size += sizeof(struct host_cmd_tlv_akmp); tlv += sizeof(struct host_cmd_tlv_akmp); if (bss_cfg->wpa_cfg.pairwise_cipher_wpa & VALID_CIPHER_BITMAP) { pwk_cipher = (struct host_cmd_tlv_pwk_cipher *)tlv; pwk_cipher->header.type = cpu_to_le16(TLV_TYPE_PWK_CIPHER); pwk_cipher->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_pwk_cipher) - sizeof(struct nxpwifi_ie_types_header)); pwk_cipher->proto = cpu_to_le16(PROTOCOL_WPA); pwk_cipher->cipher = bss_cfg->wpa_cfg.pairwise_cipher_wpa; cmd_size += sizeof(struct host_cmd_tlv_pwk_cipher); tlv += sizeof(struct host_cmd_tlv_pwk_cipher); } if (bss_cfg->wpa_cfg.pairwise_cipher_wpa2 & VALID_CIPHER_BITMAP) { pwk_cipher = (struct host_cmd_tlv_pwk_cipher *)tlv; pwk_cipher->header.type = cpu_to_le16(TLV_TYPE_PWK_CIPHER); pwk_cipher->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_pwk_cipher) - sizeof(struct nxpwifi_ie_types_header)); pwk_cipher->proto = cpu_to_le16(PROTOCOL_WPA2); pwk_cipher->cipher = bss_cfg->wpa_cfg.pairwise_cipher_wpa2; cmd_size += sizeof(struct host_cmd_tlv_pwk_cipher); tlv += sizeof(struct host_cmd_tlv_pwk_cipher); } if (bss_cfg->wpa_cfg.group_cipher & VALID_CIPHER_BITMAP) { gwk_cipher = (struct host_cmd_tlv_gwk_cipher *)tlv; gwk_cipher->header.type = cpu_to_le16(TLV_TYPE_GWK_CIPHER); gwk_cipher->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_gwk_cipher) - sizeof(struct nxpwifi_ie_types_header)); gwk_cipher->cipher = bss_cfg->wpa_cfg.group_cipher; cmd_size += sizeof(struct host_cmd_tlv_gwk_cipher); tlv += sizeof(struct host_cmd_tlv_gwk_cipher); } if (bss_cfg->wpa_cfg.length) { passphrase = (struct host_cmd_tlv_passphrase *)tlv; passphrase->header.type = cpu_to_le16(TLV_TYPE_UAP_WPA_PASSPHRASE); passphrase->header.len = cpu_to_le16(bss_cfg->wpa_cfg.length); memcpy(passphrase->passphrase, bss_cfg->wpa_cfg.passphrase, bss_cfg->wpa_cfg.length); cmd_size += sizeof(struct nxpwifi_ie_types_header) + bss_cfg->wpa_cfg.length; tlv += sizeof(struct nxpwifi_ie_types_header) + bss_cfg->wpa_cfg.length; } *param_size = cmd_size; *tlv_buf = tlv; } /* Parse BSS params and append WEP TLVs to the command buffer. */ static void nxpwifi_uap_bss_wep(u8 **tlv_buf, void *cmd_buf, u16 *param_size) { struct host_cmd_tlv_wep_key *wep_key; u16 cmd_size = *param_size; int i; u8 *tlv = *tlv_buf; struct nxpwifi_uap_bss_param *bss_cfg = cmd_buf; for (i = 0; i < NUM_WEP_KEYS; i++) { if (bss_cfg->wep_cfg[i].length && (bss_cfg->wep_cfg[i].length == WLAN_KEY_LEN_WEP40 || bss_cfg->wep_cfg[i].length == WLAN_KEY_LEN_WEP104)) { wep_key = (struct host_cmd_tlv_wep_key *)tlv; wep_key->header.type = cpu_to_le16(TLV_TYPE_UAP_WEP_KEY); wep_key->header.len = cpu_to_le16(bss_cfg->wep_cfg[i].length + 2); wep_key->key_index = bss_cfg->wep_cfg[i].key_index; wep_key->is_default = bss_cfg->wep_cfg[i].is_default; memcpy(wep_key->key, bss_cfg->wep_cfg[i].key, bss_cfg->wep_cfg[i].length); cmd_size += sizeof(struct nxpwifi_ie_types_header) + 2 + bss_cfg->wep_cfg[i].length; tlv += sizeof(struct nxpwifi_ie_types_header) + 2 + bss_cfg->wep_cfg[i].length; } } *param_size = cmd_size; *tlv_buf = tlv; } /* Parse BSS params and append TLVs to the command buffer. */ static int nxpwifi_uap_bss_param_prepare(struct nxpwifi_private *priv, u8 *tlv, void *cmd_buf, u16 *param_size) { struct host_cmd_tlv_mac_addr *mac_tlv; struct host_cmd_tlv_dtim_period *dtim_period; struct host_cmd_tlv_beacon_period *beacon_period; struct host_cmd_tlv_ssid *ssid; struct host_cmd_tlv_bcast_ssid *bcast_ssid; struct host_cmd_tlv_channel_band *chan_band; struct host_cmd_tlv_frag_threshold *frag_threshold; struct host_cmd_tlv_rts_threshold *rts_threshold; struct host_cmd_tlv_retry_limit *retry_limit; struct host_cmd_tlv_encrypt_protocol *encrypt_protocol; struct host_cmd_tlv_auth_type *auth_type; struct host_cmd_tlv_rates *tlv_rates; struct host_cmd_tlv_ageout_timer *ao_timer, *ps_ao_timer; struct host_cmd_tlv_power_constraint *pwr_ct; struct nxpwifi_ie_types_htcap *htcap; struct nxpwifi_uap_bss_param *bss_cfg = cmd_buf; int i; u16 cmd_size = *param_size; mac_tlv = (struct host_cmd_tlv_mac_addr *)tlv; mac_tlv->header.type = cpu_to_le16(TLV_TYPE_UAP_MAC_ADDRESS); mac_tlv->header.len = cpu_to_le16(ETH_ALEN); memcpy(mac_tlv->mac_addr, bss_cfg->mac_addr, ETH_ALEN); cmd_size += sizeof(struct host_cmd_tlv_mac_addr); tlv += sizeof(struct host_cmd_tlv_mac_addr); if (bss_cfg->ssid.ssid_len) { ssid = (struct host_cmd_tlv_ssid *)tlv; ssid->header.type = cpu_to_le16(TLV_TYPE_UAP_SSID); ssid->header.len = cpu_to_le16((u16)bss_cfg->ssid.ssid_len); memcpy(ssid->ssid, bss_cfg->ssid.ssid, bss_cfg->ssid.ssid_len); cmd_size += sizeof(struct nxpwifi_ie_types_header) + bss_cfg->ssid.ssid_len; tlv += sizeof(struct nxpwifi_ie_types_header) + bss_cfg->ssid.ssid_len; bcast_ssid = (struct host_cmd_tlv_bcast_ssid *)tlv; bcast_ssid->header.type = cpu_to_le16(TLV_TYPE_UAP_BCAST_SSID); bcast_ssid->header.len = cpu_to_le16(sizeof(bcast_ssid->bcast_ctl)); bcast_ssid->bcast_ctl = bss_cfg->bcast_ssid_ctl; cmd_size += sizeof(struct host_cmd_tlv_bcast_ssid); tlv += sizeof(struct host_cmd_tlv_bcast_ssid); } if (bss_cfg->rates[0]) { tlv_rates = (struct host_cmd_tlv_rates *)tlv; tlv_rates->header.type = cpu_to_le16(TLV_TYPE_UAP_RATES); for (i = 0; i < NXPWIFI_SUPPORTED_RATES && bss_cfg->rates[i]; i++) tlv_rates->rates[i] = bss_cfg->rates[i]; tlv_rates->header.len = cpu_to_le16(i); cmd_size += sizeof(struct host_cmd_tlv_rates) + i; tlv += sizeof(struct host_cmd_tlv_rates) + i; } if (bss_cfg->channel && (((bss_cfg->band_cfg & BIT(0)) == BAND_CONFIG_BG && bss_cfg->channel <= MAX_CHANNEL_BAND_BG) || ((bss_cfg->band_cfg & BIT(0)) == BAND_CONFIG_A && bss_cfg->channel <= MAX_CHANNEL_BAND_A))) { chan_band = (struct host_cmd_tlv_channel_band *)tlv; chan_band->header.type = cpu_to_le16(TLV_TYPE_CHANNELBANDLIST); chan_band->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_channel_band) - sizeof(struct nxpwifi_ie_types_header)); chan_band->band_config = bss_cfg->band_cfg; chan_band->channel = bss_cfg->channel; cmd_size += sizeof(struct host_cmd_tlv_channel_band); tlv += sizeof(struct host_cmd_tlv_channel_band); } if (bss_cfg->beacon_period >= NXPWIFI_BEACON_PERIOD_MIN && bss_cfg->beacon_period <= NXPWIFI_BEACON_PERIOD_MAX) { beacon_period = (struct host_cmd_tlv_beacon_period *)tlv; beacon_period->header.type = cpu_to_le16(TLV_TYPE_UAP_BEACON_PERIOD); beacon_period->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_beacon_period) - sizeof(struct nxpwifi_ie_types_header)); beacon_period->period = cpu_to_le16(bss_cfg->beacon_period); cmd_size += sizeof(struct host_cmd_tlv_beacon_period); tlv += sizeof(struct host_cmd_tlv_beacon_period); } if (bss_cfg->dtim_period >= NXPWIFI_MIN_DTIM_PERIOD && bss_cfg->dtim_period <= NXPWIFI_MAX_DTIM_PERIOD) { dtim_period = (struct host_cmd_tlv_dtim_period *)tlv; dtim_period->header.type = cpu_to_le16(TLV_TYPE_UAP_DTIM_PERIOD); dtim_period->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_dtim_period) - sizeof(struct nxpwifi_ie_types_header)); dtim_period->period = bss_cfg->dtim_period; cmd_size += sizeof(struct host_cmd_tlv_dtim_period); tlv += sizeof(struct host_cmd_tlv_dtim_period); } if (bss_cfg->rts_threshold <= NXPWIFI_RTS_THRESHOLD_MAX) { rts_threshold = (struct host_cmd_tlv_rts_threshold *)tlv; rts_threshold->header.type = cpu_to_le16(TLV_TYPE_UAP_RTS_THRESHOLD); rts_threshold->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_rts_threshold) - sizeof(struct nxpwifi_ie_types_header)); rts_threshold->rts_thr = cpu_to_le16(bss_cfg->rts_threshold); cmd_size += sizeof(struct host_cmd_tlv_frag_threshold); tlv += sizeof(struct host_cmd_tlv_frag_threshold); } if (bss_cfg->frag_threshold >= NXPWIFI_FRAG_THRESHOLD_MIN && bss_cfg->frag_threshold <= NXPWIFI_FRAG_THRESHOLD_MAX) { frag_threshold = (struct host_cmd_tlv_frag_threshold *)tlv; frag_threshold->header.type = cpu_to_le16(TLV_TYPE_UAP_FRAG_THRESHOLD); frag_threshold->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_frag_threshold) - sizeof(struct nxpwifi_ie_types_header)); frag_threshold->frag_thr = cpu_to_le16(bss_cfg->frag_threshold); cmd_size += sizeof(struct host_cmd_tlv_frag_threshold); tlv += sizeof(struct host_cmd_tlv_frag_threshold); } if (bss_cfg->retry_limit <= NXPWIFI_RETRY_LIMIT_MAX) { retry_limit = (struct host_cmd_tlv_retry_limit *)tlv; retry_limit->header.type = cpu_to_le16(TLV_TYPE_UAP_RETRY_LIMIT); retry_limit->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_retry_limit) - sizeof(struct nxpwifi_ie_types_header)); retry_limit->limit = (u8)bss_cfg->retry_limit; cmd_size += sizeof(struct host_cmd_tlv_retry_limit); tlv += sizeof(struct host_cmd_tlv_retry_limit); } if ((bss_cfg->protocol & PROTOCOL_WPA) || (bss_cfg->protocol & PROTOCOL_WPA2) || (bss_cfg->protocol & PROTOCOL_EAP)) nxpwifi_uap_bss_wpa(&tlv, cmd_buf, &cmd_size); else nxpwifi_uap_bss_wep(&tlv, cmd_buf, &cmd_size); if (bss_cfg->auth_mode <= WLAN_AUTH_SHARED_KEY || bss_cfg->auth_mode == NXPWIFI_AUTH_MODE_AUTO) { auth_type = (struct host_cmd_tlv_auth_type *)tlv; auth_type->header.type = cpu_to_le16(TLV_TYPE_AUTH_TYPE); auth_type->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_auth_type) - sizeof(struct nxpwifi_ie_types_header)); auth_type->auth_type = (u8)bss_cfg->auth_mode; auth_type->pwe_derivation = 0; auth_type->transition_disable = 0; cmd_size += sizeof(struct host_cmd_tlv_auth_type); tlv += sizeof(struct host_cmd_tlv_auth_type); } if (bss_cfg->protocol) { encrypt_protocol = (struct host_cmd_tlv_encrypt_protocol *)tlv; encrypt_protocol->header.type = cpu_to_le16(TLV_TYPE_UAP_ENCRY_PROTOCOL); encrypt_protocol->header.len = cpu_to_le16(sizeof(struct host_cmd_tlv_encrypt_protocol) - sizeof(struct nxpwifi_ie_types_header)); encrypt_protocol->proto = cpu_to_le16(bss_cfg->protocol); cmd_size += sizeof(struct host_cmd_tlv_encrypt_protocol); tlv += sizeof(struct host_cmd_tlv_encrypt_protocol); } if (bss_cfg->ht_cap.cap_info) { htcap = (struct nxpwifi_ie_types_htcap *)tlv; htcap->header.type = cpu_to_le16(WLAN_EID_HT_CAPABILITY); htcap->header.len = cpu_to_le16(sizeof(struct ieee80211_ht_cap)); htcap->ht_cap.cap_info = bss_cfg->ht_cap.cap_info; htcap->ht_cap.ampdu_params_info = bss_cfg->ht_cap.ampdu_params_info; memcpy(&htcap->ht_cap.mcs, &bss_cfg->ht_cap.mcs, sizeof(struct ieee80211_mcs_info)); htcap->ht_cap.extended_ht_cap_info = bss_cfg->ht_cap.extended_ht_cap_info; htcap->ht_cap.tx_BF_cap_info = bss_cfg->ht_cap.tx_BF_cap_info; htcap->ht_cap.antenna_selection_info = bss_cfg->ht_cap.antenna_selection_info; cmd_size += sizeof(struct nxpwifi_ie_types_htcap); tlv += sizeof(struct nxpwifi_ie_types_htcap); } if (priv->wmm_enabled) { struct nxpwifi_ie_types_wmmcap *wmm_cap; struct nxpwifi_types_wmm_info *fw_wmm; const struct ieee80211_wmm_param_ie *ie; wmm_cap = (struct nxpwifi_ie_types_wmmcap *)tlv; fw_wmm = &wmm_cap->wmm_info; ie = &bss_cfg->wmm_element; wmm_cap->header.type = cpu_to_le16(WLAN_EID_VENDOR_SPECIFIC); wmm_cap->header.len = cpu_to_le16(sizeof(struct nxpwifi_types_wmm_info)); /* Map 802.11 WMM IE fields to FW WMM TLV payload */ fw_wmm->oui[0] = ie->oui[0]; fw_wmm->oui[1] = ie->oui[1]; fw_wmm->oui[2] = ie->oui[2]; fw_wmm->oui[3] = ie->oui_type; fw_wmm->subtype = ie->oui_subtype; fw_wmm->version = ie->version; fw_wmm->qos_info = ie->qos_info; fw_wmm->reserved = ie->reserved; memcpy(fw_wmm->ac, ie->ac, sizeof(fw_wmm->ac)); cmd_size += sizeof(*wmm_cap); tlv += sizeof(*wmm_cap); } if (bss_cfg->sta_ao_timer) { ao_timer = (struct host_cmd_tlv_ageout_timer *)tlv; ao_timer->header.type = cpu_to_le16(TLV_TYPE_UAP_AO_TIMER); ao_timer->header.len = cpu_to_le16(sizeof(*ao_timer) - sizeof(struct nxpwifi_ie_types_header)); ao_timer->sta_ao_timer = cpu_to_le32(bss_cfg->sta_ao_timer); cmd_size += sizeof(*ao_timer); tlv += sizeof(*ao_timer); } if (bss_cfg->power_constraint) { pwr_ct = (void *)tlv; pwr_ct->header.type = cpu_to_le16(TLV_TYPE_PWR_CONSTRAINT); pwr_ct->header.len = cpu_to_le16(sizeof(u8)); pwr_ct->constraint = bss_cfg->power_constraint; cmd_size += sizeof(*pwr_ct); tlv += sizeof(*pwr_ct); } if (bss_cfg->ps_sta_ao_timer) { ps_ao_timer = (struct host_cmd_tlv_ageout_timer *)tlv; ps_ao_timer->header.type = cpu_to_le16(TLV_TYPE_UAP_PS_AO_TIMER); ps_ao_timer->header.len = cpu_to_le16(sizeof(*ps_ao_timer) - sizeof(struct nxpwifi_ie_types_header)); ps_ao_timer->sta_ao_timer = cpu_to_le32(bss_cfg->ps_sta_ao_timer); cmd_size += sizeof(*ps_ao_timer); tlv += sizeof(*ps_ao_timer); } *param_size = cmd_size; return 0; } /* Parse custom IEs and write them to the command buffer. */ static int nxpwifi_uap_custom_ie_prepare(u8 *tlv, void *cmd_buf, u16 *ie_size) { struct nxpwifi_ie_list *ap_ie = cmd_buf; struct nxpwifi_ie_types_header *tlv_ie = (void *)tlv; if (!ap_ie || !ap_ie->len) return -EINVAL; *ie_size += le16_to_cpu(ap_ie->len) + sizeof(struct nxpwifi_ie_types_header); tlv_ie->type = cpu_to_le16(TLV_TYPE_MGMT_IE); tlv_ie->len = ap_ie->len; tlv += sizeof(struct nxpwifi_ie_types_header); memcpy(tlv, ap_ie->ie_list, le16_to_cpu(ap_ie->len)); return 0; } static int nxpwifi_cmd_uap_sys_config(struct nxpwifi_private *priv, struct host_cmd_ds_command *cmd, u16 cmd_no, void *data_buf, u16 cmd_action, u32 cmd_type) { u8 *tlv; u16 cmd_size, param_size, ie_size; struct host_cmd_ds_sys_config *sys_cfg; int ret = 0; cmd->command = cpu_to_le16(HOST_CMD_UAP_SYS_CONFIG); cmd_size = (u16)(sizeof(struct host_cmd_ds_sys_config) + S_DS_GEN); sys_cfg = &cmd->params.uap_sys_config; sys_cfg->action = cpu_to_le16(cmd_action); tlv = sys_cfg->tlv; switch (cmd_type) { case UAP_BSS_PARAMS_I: param_size = cmd_size; ret = nxpwifi_uap_bss_param_prepare(priv, tlv, data_buf, ¶m_size); if (ret) return ret; cmd->size = cpu_to_le16(param_size); break; case UAP_CUSTOM_IE_I: ie_size = cmd_size; ret = nxpwifi_uap_custom_ie_prepare(tlv, data_buf, &ie_size); if (ret) return ret; cmd->size = cpu_to_le16(ie_size); break; default: return -EINVAL; } return ret; } static int nxpwifi_cmd_uap_bss_start(struct nxpwifi_private *priv, struct host_cmd_ds_command *cmd, u16 cmd_no, void *data_buf, u16 cmd_action, u32 cmd_type) { struct nxpwifi_ie_types_host_mlme *tlv; int size; cmd->command = cpu_to_le16(HOST_CMD_UAP_BSS_START); size = S_DS_GEN; tlv = (struct nxpwifi_ie_types_host_mlme *)((u8 *)cmd + size); tlv->header.type = cpu_to_le16(TLV_TYPE_HOST_MLME); tlv->header.len = cpu_to_le16(sizeof(tlv->host_mlme)); tlv->host_mlme = 1; size += sizeof(struct nxpwifi_ie_types_host_mlme); cmd->size = cpu_to_le16(size); return 0; } static int nxpwifi_ret_uap_bss_start(struct nxpwifi_private *priv, struct host_cmd_ds_command *resp, u16 cmdresp_no, void *data_buf) { struct nxpwifi_adapter *adapter = priv->adapter; adapter->tx_lock_flag = false; adapter->pps_uapsd_mode = false; adapter->delay_null_pkt = false; priv->bss_started = 1; return 0; } static int nxpwifi_ret_uap_bss_stop(struct nxpwifi_private *priv, struct host_cmd_ds_command *resp, u16 cmdresp_no, void *data_buf) { priv->bss_started = 0; return 0; } static int nxpwifi_ret_apcmd_sta_list(struct nxpwifi_private *priv, struct host_cmd_ds_command *resp, u16 cmdresp_no, void *data_buf) { struct host_cmd_ds_sta_list *sta_list = &resp->params.sta_list; struct nxpwifi_ie_types_sta_info *sta_info; struct nxpwifi_sta_node *sta_node; u16 sta_count; u32 resp_size; u32 base; u32 required_size; int i; resp_size = le16_to_cpu(resp->size); sta_count = le16_to_cpu(sta_list->sta_count); /* End of fixed fields before sta_list.tlv[] */ base = offsetofend(struct host_cmd_ds_command, params.sta_list.sta_count); /* At least fixed fields must be present */ if (resp_size < base) return -EINVAL; required_size = base + sta_count * sizeof(*sta_info); /* Verify firmware did not claim more entries than the buffer holds */ if (resp_size < required_size) return -EINVAL; sta_info = (void *)sta_list->tlv; rcu_read_lock(); for (i = 0; i < sta_count; i++) { sta_node = nxpwifi_get_sta_entry(priv, sta_info->mac); if (unlikely(!sta_node)) { sta_info++; continue; } sta_node->stats.rssi = sta_info->rssi; sta_info++; } rcu_read_unlock(); return 0; } /* Build AP deauth command for the given MAC address. */ static int nxpwifi_cmd_uap_sta_deauth(struct nxpwifi_private *priv, struct host_cmd_ds_command *cmd, u16 cmd_no, void *data_buf, u16 cmd_action, u32 cmd_type) { struct host_cmd_ds_sta_deauth *sta_deauth = &cmd->params.sta_deauth; u8 *mac = (u8 *)data_buf; cmd->command = cpu_to_le16(HOST_CMD_UAP_STA_DEAUTH); memcpy(sta_deauth->mac, mac, ETH_ALEN); sta_deauth->reason = cpu_to_le16(WLAN_REASON_DEAUTH_LEAVING); cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_sta_deauth) + S_DS_GEN); return 0; } static int nxpwifi_cmd_uap_chan_report_request(struct nxpwifi_private *priv, struct host_cmd_ds_command *cmd, u16 cmd_no, void *data_buf, u16 cmd_action, u32 cmd_type) { return nxpwifi_cmd_issue_chan_report_request(priv, cmd, data_buf); } /* Build AP add-station command. */ static int nxpwifi_cmd_uap_add_new_station(struct nxpwifi_private *priv, struct host_cmd_ds_command *cmd, u16 cmd_no, void *data_buf, u16 cmd_action, u32 cmd_type) { struct host_cmd_ds_add_station *new_sta = &cmd->params.sta_info; struct nxpwifi_sta_info *add_sta = (struct nxpwifi_sta_info *)data_buf; struct station_parameters *params = add_sta->params; struct nxpwifi_sta_node *sta_ptr; u16 cmd_size; u8 *pos, *cmd_end; u16 tlv_len; struct nxpwifi_ie_types_sta_flag *sta_flag; int i; cmd->command = cpu_to_le16(HOST_CMD_ADD_NEW_STATION); new_sta->action = cpu_to_le16(cmd_action); cmd_size = sizeof(struct host_cmd_ds_add_station) + S_DS_GEN; if (cmd_action == HOST_ACT_ADD_STA) sta_ptr = nxpwifi_add_sta_entry(priv, add_sta->peer_mac); else sta_ptr = nxpwifi_get_sta_entry_rcu(priv, add_sta->peer_mac); if (!sta_ptr) return -EINVAL; memcpy(new_sta->peer_mac, add_sta->peer_mac, ETH_ALEN); if (cmd_action == HOST_ACT_REMOVE_STA) { cmd->size = cpu_to_le16(cmd_size); return 0; } new_sta->aid = cpu_to_le16(params->aid); new_sta->listen_interval = cpu_to_le32(params->listen_interval); new_sta->cap_info = cpu_to_le16(params->capability); pos = new_sta->tlv; cmd_end = (u8 *)cmd; cmd_end += (NXPWIFI_SIZE_OF_CMD_BUFFER - 1); if (params->sta_flags_set & NL80211_STA_FLAG_WME) sta_ptr->is_wmm_enabled = 1; sta_flag = (struct nxpwifi_ie_types_sta_flag *)pos; sta_flag->header.type = cpu_to_le16(TLV_TYPE_UAP_STA_FLAGS); sta_flag->header.len = cpu_to_le16(sizeof(__le32)); sta_flag->sta_flags = cpu_to_le32(params->sta_flags_set); pos += sizeof(struct nxpwifi_ie_types_sta_flag); cmd_size += sizeof(struct nxpwifi_ie_types_sta_flag); if (params->ext_capab_len) { u8 *data = (u8 *)params->ext_capab; u16 len = params->ext_capab_len; tlv_len = nxpwifi_append_data_tlv(WLAN_EID_EXT_CAPABILITY, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; } if (params->link_sta_params.supported_rates_len) { u8 *data = (u8 *)params->link_sta_params.supported_rates; u16 len = params->link_sta_params.supported_rates_len; tlv_len = nxpwifi_append_data_tlv(WLAN_EID_SUPP_RATES, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; } if (params->uapsd_queues || params->max_sp) { u8 qos_capability = params->uapsd_queues | (params->max_sp << 5); u8 *data = &qos_capability; u16 len = sizeof(u8); tlv_len = nxpwifi_append_data_tlv(WLAN_EID_QOS_CAPA, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; sta_ptr->is_wmm_enabled = 1; } if (params->link_sta_params.ht_capa) { u8 *data = (u8 *)params->link_sta_params.ht_capa; u16 len = sizeof(struct ieee80211_ht_cap); tlv_len = nxpwifi_append_data_tlv(WLAN_EID_HT_CAPABILITY, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; sta_ptr->is_11n_enabled = 1; sta_ptr->max_amsdu = le16_to_cpu(params->link_sta_params.ht_capa->cap_info) & IEEE80211_HT_CAP_MAX_AMSDU ? NXPWIFI_TX_DATA_BUF_SIZE_8K : NXPWIFI_TX_DATA_BUF_SIZE_4K; } if (params->link_sta_params.vht_capa) { u8 *data = (u8 *)params->link_sta_params.vht_capa; u16 len = sizeof(struct ieee80211_vht_cap); tlv_len = nxpwifi_append_data_tlv(WLAN_EID_VHT_CAPABILITY, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; sta_ptr->is_11ac_enabled = 1; } if (params->link_sta_params.opmode_notif_used) { u8 *data = ¶ms->link_sta_params.opmode_notif; u16 len = sizeof(u8); tlv_len = nxpwifi_append_data_tlv(WLAN_EID_OPMODE_NOTIF, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; } if (params->link_sta_params.he_capa_len) { u8 *data = (u8 *)params->link_sta_params.he_capa; u16 len = params->link_sta_params.he_capa_len; tlv_len = nxpwifi_append_data_tlv(WLAN_EID_EXT_HE_CAPABILITY, data, len, pos, cmd_end); if (!tlv_len) return -EINVAL; pos += tlv_len; cmd_size += tlv_len; sta_ptr->is_11ax_enabled = 1; } for (i = 0; i < MAX_NUM_TID; i++) { if (sta_ptr->is_11n_enabled || sta_ptr->is_11ax_enabled) sta_ptr->ampdu_sta[i] = priv->aggr_prio_tbl[i].ampdu_user; else sta_ptr->ampdu_sta[i] = BA_STREAM_NOT_ALLOWED; } memset(sta_ptr->rx_seq, 0xff, sizeof(sta_ptr->rx_seq)); cmd->size = cpu_to_le16(cmd_size); return 0; } static const struct nxpwifi_cmd_entry cmd_table_uap[] = { {.cmd_no = HOST_CMD_APCMD_SYS_RESET, .prepare_cmd = nxpwifi_cmd_fill_head_only, .cmd_resp = NULL}, {.cmd_no = HOST_CMD_UAP_SYS_CONFIG, .prepare_cmd = nxpwifi_cmd_uap_sys_config, .cmd_resp = NULL}, {.cmd_no = HOST_CMD_UAP_BSS_START, .prepare_cmd = nxpwifi_cmd_uap_bss_start, .cmd_resp = nxpwifi_ret_uap_bss_start}, {.cmd_no = HOST_CMD_UAP_BSS_STOP, .prepare_cmd = nxpwifi_cmd_fill_head_only, .cmd_resp = nxpwifi_ret_uap_bss_stop}, {.cmd_no = HOST_CMD_APCMD_STA_LIST, .prepare_cmd = nxpwifi_cmd_fill_head_only, .cmd_resp = nxpwifi_ret_apcmd_sta_list}, {.cmd_no = HOST_CMD_UAP_STA_DEAUTH, .prepare_cmd = nxpwifi_cmd_uap_sta_deauth, .cmd_resp = NULL}, {.cmd_no = HOST_CMD_CHAN_REPORT_REQUEST, .prepare_cmd = nxpwifi_cmd_uap_chan_report_request, .cmd_resp = NULL}, {.cmd_no = HOST_CMD_ADD_NEW_STATION, .prepare_cmd = nxpwifi_cmd_uap_add_new_station, .cmd_resp = NULL}, }; /* Prepare AP commands and dispatch to per-cmd builders before sending to firmware. */ int nxpwifi_uap_prepare_cmd(struct nxpwifi_private *priv, struct cmd_ctrl_node *cmd_node, u16 cmd_action, u32 type) { struct nxpwifi_adapter *adapter = priv->adapter; u16 cmd_no = cmd_node->cmd_no; struct host_cmd_ds_command *cmd = (struct host_cmd_ds_command *)cmd_node->skb->data; void *data_buf = cmd_node->data_buf; int i, ret = -EINVAL; for (i = 0; i < ARRAY_SIZE(cmd_table_uap); i++) { if (cmd_no == cmd_table_uap[i].cmd_no) { if (cmd_table_uap[i].prepare_cmd) ret = cmd_table_uap[i].prepare_cmd(priv, cmd, cmd_no, data_buf, cmd_action, type); cmd_node->cmd_resp = cmd_table_uap[i].cmd_resp; break; } } if (i == ARRAY_SIZE(cmd_table_uap)) nxpwifi_dbg(adapter, ERROR, "%s: unknown command: %#x\n", __func__, cmd_no); else nxpwifi_dbg(adapter, CMD, "%s: command: %#x\n", __func__, cmd_no); return ret; } /* Translate cfg80211_ap_settings security into bss_config for firmware. */ int nxpwifi_set_secure_params(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_config, struct cfg80211_ap_settings *params) { int i; struct nxpwifi_wep_key wep_key; if (!params->privacy) { bss_config->protocol = PROTOCOL_NO_SECURITY; bss_config->key_mgmt = KEY_MGMT_NONE; bss_config->wpa_cfg.length = 0; priv->sec_info.wep_enabled = 0; priv->sec_info.wpa_enabled = 0; priv->sec_info.wpa2_enabled = 0; return 0; } switch (params->auth_type) { case NL80211_AUTHTYPE_OPEN_SYSTEM: bss_config->auth_mode = WLAN_AUTH_OPEN; break; case NL80211_AUTHTYPE_SHARED_KEY: bss_config->auth_mode = WLAN_AUTH_SHARED_KEY; break; case NL80211_AUTHTYPE_NETWORK_EAP: bss_config->auth_mode = WLAN_AUTH_LEAP; break; default: bss_config->auth_mode = NXPWIFI_AUTH_MODE_AUTO; break; } bss_config->key_mgmt_operation |= KEY_MGMT_ON_HOST; bss_config->protocol = 0; if (params->crypto.wpa_versions & NL80211_WPA_VERSION_1) bss_config->protocol |= PROTOCOL_WPA; if (params->crypto.wpa_versions & NL80211_WPA_VERSION_2) bss_config->protocol |= PROTOCOL_WPA2; bss_config->key_mgmt = 0; for (i = 0; i < params->crypto.n_akm_suites; i++) { switch (params->crypto.akm_suites[i]) { case WLAN_AKM_SUITE_8021X: bss_config->key_mgmt |= KEY_MGMT_EAP; break; case WLAN_AKM_SUITE_PSK: bss_config->key_mgmt |= KEY_MGMT_PSK; break; case WLAN_AKM_SUITE_PSK_SHA256: bss_config->key_mgmt |= KEY_MGMT_PSK_SHA256; break; case WLAN_AKM_SUITE_OWE: bss_config->key_mgmt |= KEY_MGMT_OWE; break; case WLAN_AKM_SUITE_SAE: bss_config->key_mgmt |= KEY_MGMT_SAE; break; default: break; } } for (i = 0; i < params->crypto.n_ciphers_pairwise; i++) { switch (params->crypto.ciphers_pairwise[i]) { case WLAN_CIPHER_SUITE_WEP40: case WLAN_CIPHER_SUITE_WEP104: break; case WLAN_CIPHER_SUITE_TKIP: if (params->crypto.wpa_versions & NL80211_WPA_VERSION_1) bss_config->wpa_cfg.pairwise_cipher_wpa |= CIPHER_TKIP; if (params->crypto.wpa_versions & NL80211_WPA_VERSION_2) bss_config->wpa_cfg.pairwise_cipher_wpa2 |= CIPHER_TKIP; break; case WLAN_CIPHER_SUITE_CCMP: if (params->crypto.wpa_versions & NL80211_WPA_VERSION_1) bss_config->wpa_cfg.pairwise_cipher_wpa |= CIPHER_AES_CCMP; if (params->crypto.wpa_versions & NL80211_WPA_VERSION_2) bss_config->wpa_cfg.pairwise_cipher_wpa2 |= CIPHER_AES_CCMP; break; default: break; } } switch (params->crypto.cipher_group) { case WLAN_CIPHER_SUITE_WEP40: case WLAN_CIPHER_SUITE_WEP104: if (priv->sec_info.wep_enabled) { bss_config->protocol = PROTOCOL_STATIC_WEP; bss_config->key_mgmt = KEY_MGMT_NONE; bss_config->wpa_cfg.length = 0; for (i = 0; i < NUM_WEP_KEYS; i++) { wep_key = priv->wep_key[i]; bss_config->wep_cfg[i].key_index = i; if (priv->wep_key_curr_index == i) bss_config->wep_cfg[i].is_default = 1; else bss_config->wep_cfg[i].is_default = 0; bss_config->wep_cfg[i].length = wep_key.key_length; memcpy(&bss_config->wep_cfg[i].key, &wep_key.key_material, wep_key.key_length); } } break; case WLAN_CIPHER_SUITE_TKIP: bss_config->wpa_cfg.group_cipher = CIPHER_TKIP; break; case WLAN_CIPHER_SUITE_CCMP: bss_config->wpa_cfg.group_cipher = CIPHER_AES_CCMP; break; default: break; } return 0; } /* Update 11n HT params from beacon and fill bss_config. */ void nxpwifi_set_ht_params(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { const u8 *ht_ie; if (!ISSUPP_11NENABLED(priv->adapter->fw_cap_info)) return; ht_ie = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, params->beacon.tail, params->beacon.tail_len); if (ht_ie) { memcpy(&bss_cfg->ht_cap, ht_ie + 2, sizeof(struct ieee80211_ht_cap)); if (ISSUPP_BEAMFORMING(priv->adapter->hw_dot_11n_dev_cap)) bss_cfg->ht_cap.tx_BF_cap_info = cpu_to_le32(NXPWIFI_DEF_11N_TX_BF_CAP); priv->ap_11n_enabled = 1; } else { memset(&bss_cfg->ht_cap, 0, sizeof(struct ieee80211_ht_cap)); bss_cfg->ht_cap.cap_info = cpu_to_le16(NXPWIFI_DEF_HT_CAP); bss_cfg->ht_cap.ampdu_params_info = NXPWIFI_DEF_AMPDU; } } /* Update 11ac VHT params from beacon and fill bss_config. */ void nxpwifi_set_vht_params(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { const u8 *vht_ie; vht_ie = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, params->beacon.tail, params->beacon.tail_len); if (vht_ie) { memcpy(&bss_cfg->vht_cap, vht_ie + 2, sizeof(struct ieee80211_vht_cap)); priv->ap_11ac_enabled = 1; } else { priv->ap_11ac_enabled = 0; } } /* Extract TPC request from beacon and set power_constraint. */ void nxpwifi_set_tpc_params(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { const u8 *tpc_ie; tpc_ie = cfg80211_find_ie(WLAN_EID_TPC_REQUEST, params->beacon.tail, params->beacon.tail_len); if (tpc_ie) bss_cfg->power_constraint = *(tpc_ie + 2); else bss_cfg->power_constraint = 0; } /* Enable VHT only when VHT IE is present; otherwise disable VHT. */ void nxpwifi_set_vht_width(struct nxpwifi_private *priv, enum nl80211_chan_width width, bool ap_11ac_enable) { struct nxpwifi_adapter *adapter = priv->adapter; struct nxpwifi_11ac_vht_cfg vht_cfg; vht_cfg.band_config = VHT_CFG_5GHZ; vht_cfg.cap_info = adapter->hw_dot_11ac_dev_cap; if (!ap_11ac_enable) { vht_cfg.mcs_tx_set = DISABLE_VHT_MCS_SET; vht_cfg.mcs_rx_set = DISABLE_VHT_MCS_SET; } else { vht_cfg.mcs_tx_set = DEFAULT_VHT_MCS_SET; vht_cfg.mcs_rx_set = DEFAULT_VHT_MCS_SET; } vht_cfg.misc_config = VHT_CAP_UAP_ONLY; if (ap_11ac_enable && width >= NL80211_CHAN_WIDTH_80) vht_cfg.misc_config |= VHT_BW_80_160_80P80; nxpwifi_send_cmd(priv, HOST_CMD_11AC_CFG, HOST_ACT_GEN_SET, 0, &vht_cfg, true); } bool nxpwifi_check_11ax_capability(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { struct nxpwifi_adapter *adapter = priv->adapter; u8 band = bss_cfg->band_cfg & BAND_CFG_CHAN_BAND_MASK; if (band == BAND_2GHZ && !(adapter->fw_bands & BAND_GAX)) return false; if (band == BAND_5GHZ && !(adapter->fw_bands & BAND_AAX)) return false; if (params->he_cap) return true; else return false; } int nxpwifi_set_11ax_status(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { struct nxpwifi_11ax_he_cfg ax_cfg; u8 band = bss_cfg->band_cfg & BAND_CFG_CHAN_BAND_MASK; const struct element *he_cap; int ret; if (band == BAND_2GHZ) ax_cfg.band = BIT(0); else if (band == BAND_5GHZ) ax_cfg.band = BIT(1); else return -EINVAL; ret = nxpwifi_send_cmd(priv, HOST_CMD_11AX_CFG, HOST_ACT_GEN_GET, 0, &ax_cfg, true); if (ret) return ret; he_cap = cfg80211_find_ext_elem(WLAN_EID_EXT_HE_CAPABILITY, params->beacon.tail, params->beacon.tail_len); if (he_cap) { ax_cfg.he_cap_cfg.id = he_cap->id; ax_cfg.he_cap_cfg.len = he_cap->datalen; if (params->twt_responder == 0) { struct nxpwifi_11ax_he_cap_cfg *he_cap_cfg = (struct nxpwifi_11ax_he_cap_cfg *)he_cap; he_cap_cfg->cap_elem.mac_cap_info[0] &= ~HE_MAC_CAP_TWT_RESP_SUPPORT; } memcpy(ax_cfg.data + 4, he_cap->data, he_cap->datalen); } else { /* disable */ if (ax_cfg.he_cap_cfg.len && ax_cfg.he_cap_cfg.ext_id == WLAN_EID_EXT_HE_CAPABILITY) { memset(ax_cfg.he_cap_cfg.he_txrx_mcs_support, 0xff, sizeof(ax_cfg.he_cap_cfg.he_txrx_mcs_support)); } } return nxpwifi_send_cmd(priv, HOST_CMD_11AX_CFG, HOST_ACT_GEN_SET, 0, &ax_cfg, true); } /* Copy supported rates from beacon into bss_config. */ void nxpwifi_set_uap_rates(struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { struct element *rate_ie; int var_offset = offsetof(struct ieee80211_mgmt, u.beacon.variable); const u8 *var_pos = params->beacon.head + var_offset; int len = params->beacon.head_len - var_offset; u8 rate_len = 0; rate_ie = (void *)cfg80211_find_ie(WLAN_EID_SUPP_RATES, var_pos, len); if (rate_ie) { if (rate_ie->datalen > NXPWIFI_SUPPORTED_RATES) return; memcpy(bss_cfg->rates, rate_ie + 1, rate_ie->datalen); rate_len = rate_ie->datalen; } rate_ie = (void *)cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, params->beacon.tail, params->beacon.tail_len); if (rate_ie) { if (rate_ie->datalen > NXPWIFI_SUPPORTED_RATES - rate_len) return; memcpy(bss_cfg->rates + rate_len, rate_ie + 1, rate_ie->datalen); } } /* * Initialize bss_config fields to sentinel values. * Fields left with sentinel values are treated as unset and will not be * included in the corresponding firmware command. */ void nxpwifi_set_sys_config_invalid_data(struct nxpwifi_uap_bss_param *config) { config->radio_ctl = __NXPWIFI_RADIO_CTL_MAX; config->dtim_period = NXPWIFI_INVALID_DTIM_PERIOD; config->beacon_period = NXPWIFI_INVALID_BEACON_PERIOD; config->auth_mode = NXPWIFI_AUTH_MODE_AUTO; config->rts_threshold = NXPWIFI_INVALID_RTS; config->frag_threshold = NXPWIFI_INVALID_FRAG; config->retry_limit = NXPWIFI_INVALID_RETRY_LIMI; } /* Parse WMM params from cfg80211_ap_settings and update bss_config. */ void nxpwifi_set_wmm_params(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_ap_settings *params) { const u8 *vendor_ie; const struct ieee80211_wmm_param_ie *wmm; u8 ie_len; vendor_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, WLAN_OUI_TYPE_MICROSOFT_WMM, params->beacon.tail, params->beacon.tail_len); if (!vendor_ie) goto no_wmm; ie_len = vendor_ie[1]; if (ie_len < sizeof(struct ieee80211_wmm_param_ie) - 2) goto no_wmm; wmm = (const struct ieee80211_wmm_param_ie *)vendor_ie; if (memcmp(wmm->oui, "\x00\x50\xf2", 3)) goto no_wmm; if (wmm->oui_type != WLAN_OUI_TYPE_MICROSOFT_WMM) goto no_wmm; if (wmm->oui_subtype != 1) goto no_wmm; /* Only WMM version 1 is supported */ if (wmm->version != 1) goto no_wmm; memcpy(&bss_cfg->wmm_element, wmm, sizeof(struct ieee80211_wmm_param_ie)); priv->wmm_enabled = true; return; no_wmm: memset(&bss_cfg->wmm_element, 0, sizeof(bss_cfg->wmm_element)); priv->wmm_enabled = false; } /* Enable 11d when country IE is present. */ void nxpwifi_config_uap_11d(struct nxpwifi_private *priv, struct cfg80211_beacon_data *beacon_data) { enum state_11d_t state_11d; const u8 *country_ie; country_ie = cfg80211_find_ie(WLAN_EID_COUNTRY, beacon_data->tail, beacon_data->tail_len); if (country_ie) { /* Send cmd to FW to enable 11D function */ state_11d = ENABLE_11D; if (nxpwifi_send_cmd(priv, HOST_CMD_802_11_SNMP_MIB, HOST_ACT_GEN_SET, DOT11D_I, &state_11d, true)) { nxpwifi_dbg(priv->adapter, ERROR, "11D: failed to enable 11D\n"); } } } void nxpwifi_uap_set_channel(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg, struct cfg80211_chan_def chandef) { u8 config_bands = 0, old_bands = priv->config_bands; priv->bss_chandef = chandef; bss_cfg->channel = ieee80211_frequency_to_channel(chandef.chan->center_freq); nxpwifi_convert_chan_to_band_cfg(priv, &bss_cfg->band_cfg, &chandef); /* Set appropriate bands */ if (chandef.chan->band == NL80211_BAND_2GHZ) { config_bands = BAND_B | BAND_G; if (chandef.width > NL80211_CHAN_WIDTH_20_NOHT) config_bands |= BAND_GN | BAND_GAX; } else { config_bands = BAND_A; if (chandef.width > NL80211_CHAN_WIDTH_20_NOHT) config_bands |= BAND_AN; if (chandef.width > NL80211_CHAN_WIDTH_40) config_bands |= BAND_AAC | BAND_AAX; } priv->config_bands = config_bands; if (old_bands != config_bands) { if (nxpwifi_band_to_radio_type(priv->config_bands) == HOST_SCAN_RADIO_TYPE_BG) nxpwifi_send_domain_info_cmd_fw(priv->adapter->wiphy, NL80211_BAND_2GHZ); else nxpwifi_send_domain_info_cmd_fw(priv->adapter->wiphy, NL80211_BAND_5GHZ); } } int nxpwifi_config_start_uap(struct nxpwifi_private *priv, struct nxpwifi_uap_bss_param *bss_cfg) { int ret; ret = nxpwifi_send_cmd(priv, HOST_CMD_UAP_SYS_CONFIG, HOST_ACT_GEN_SET, UAP_BSS_PARAMS_I, bss_cfg, true); if (ret) { nxpwifi_dbg(priv->adapter, ERROR, "Failed to set AP configuration\n"); return ret; } ret = nxpwifi_send_cmd(priv, HOST_CMD_UAP_BSS_START, HOST_ACT_GEN_SET, 0, NULL, true); if (ret) { nxpwifi_dbg(priv->adapter, ERROR, "Failed to start the BSS\n"); return ret; } if (priv->sec_info.wep_enabled) priv->curr_pkt_filter |= HOST_ACT_MAC_WEP_ENABLE; else priv->curr_pkt_filter &= ~HOST_ACT_MAC_WEP_ENABLE; ret = nxpwifi_send_cmd(priv, HOST_CMD_MAC_CONTROL, HOST_ACT_GEN_SET, 0, &priv->curr_pkt_filter, true); return ret; }