wifi: nxpwifi: create nxpwifi to support iw61x
v2 cover wifi: nxpwifi: create nxpwifi to support iw61x
This series adds support for IW61x which is a new family of 2.4/5 GHz dual-band 1x1 Wi-Fi 6, Bluetooth/Bluetooth Low Energy 5.2 and 15.4 tri-radio single chip by NXP. These devices support 20/40/80MHz single spatial stream in both STA and AP mode. Communication to the IW61x is done via SDIO interface
This driver is a derivative of existing Mwifiex [1] and based on similar full-MAC architecture [2]. It has been tested with i.MX8M Mini evaluation kits in both AP and STA mode.
All code passes sparse and checkpatch
Data sheet (require registration):
https://www.nxp.com/products/wireless-connectivity/wi-fi-plus-bluetooth-
plus-802-15-4/2-4-5-ghz-dual-band-1x1-wi-fi-6-802-11ax-plus-bluetooth-5- 4-plus-802-15-4-tri-radio-solution:IW612
Known gaps to be addressed in the following patches,
- Enable 11ax capabilities. This initial patch support up to 11ac.
- Support DFS channel. This initial patch doesn't support DFS channel in both AP/STA mode.
This patch is presented as a request for comment with the intention of being made into a patch after initial feedbacks are addressed
[1] We had considered adding IW61x to mwifiex driver, however due to FW architecture, host command interface and supported features are significantly different, we have to create the new nxpwifi driver. Subsequent NXP chipsets will be added and sustained in this new driver.
[2] Some features, as of now, WPA2/WPA3 personal/enterprise are offloaded to host wpa_supplicant/hostapd.
v2:
- Rename ioctl.h and sta_ioctl.c to cfg.h and sta_cfg.c.
- Remove header file semaphore.h.
- Use static value for cookie instead of run time random number.
- Use ERR_PTR(), IS_ERR() and PTR_ERR().
- Use Kernel defined return error code.
- Remove unnecessary private ie definitions.
- Remove mutex async_mutex and related code.
- Consolidate multiple workqueue into one.
- Add the support for PSK SHA256.
- Use tasklet for Rx handler.
- Remove unused functions.
- Remove compile warning.
David Lin (43):
wifi: nxpwifi: add 11ac.c
wifi: nxpwifi: add 11ac.h
wifi: nxpwifi: add 11h.c
wifi: nxpwifi: add 11n_aggr.c
wifi: nxpwifi: add 11n_aggr.h
wifi: nxpwifi: add 11n.c
wifi: nxpwifi: add 11n.h
wifi: nxpwifi: add 11n_rxreorder.c
wifi: nxpwifi: add 11n_rxreorder.h
wifi: nxpwifi: add cfg80211.c
wifi: nxpwifi: add cfg80211.h
wifi: nxpwifi: add cfg.h
wifi: nxpwifi: add cfp.c
wifi: nxpwifi: add cmdevt.c
wifi: nxpwifi: add cmdevt.h
wifi: nxpwifi: add debugfs.c
wifi: nxpwifi: add decl.h
wifi: nxpwifi: add ethtool.c
wifi: nxpwifi: add fw.h
wifi: nxpwifi: add ie.c
wifi: nxpwifi: add init.c
wifi: nxpwifi: add join.c
wifi: nxpwifi: add main.c
wifi: nxpwifi: add main.h
wifi: nxpwifi: add scan.c
wifi: nxpwifi: add sdio.c
wifi: nxpwifi: add sdio.h
wifi: nxpwifi: add sta_cfg.c
wifi: nxpwifi: add sta_cmd.c
wifi: nxpwifi: add sta_event.c
wifi: nxpwifi: add sta_rx.c
wifi: nxpwifi: add sta_tx.c
wifi: nxpwifi: add txrx.c
wifi: nxpwifi: add uap_cmd.c
wifi: nxpwifi: add uap_event.c
wifi: nxpwifi: add uap_txrx.c
wifi: nxpwifi: add util.c
wifi: nxpwifi: add util.h
wifi: nxpwifi: add wmm.c
wifi: nxpwifi: add wmm.h
wifi: nxpwifi: add nxp sdio vendor id and iw61x device id
wifi: nxpwifi: add Makefile and Kconfig files for nxpwifi compilation
wifi: nxpwifi: add nxpwifi related information to MAINTAINERS
MAINTAINERS | 7 + drivers/net/wireless/Kconfig | 1 + drivers/net/wireless/Makefile | 1 + drivers/net/wireless/nxp/Kconfig | 17 + drivers/net/wireless/nxp/Makefile | 3 + drivers/net/wireless/nxp/nxpwifi/11ac.c | 366 ++ drivers/net/wireless/nxp/nxpwifi/11ac.h | 33 + drivers/net/wireless/nxp/nxpwifi/11h.c | 433 ++ drivers/net/wireless/nxp/nxpwifi/11n.c | 851 ++++ drivers/net/wireless/nxp/nxpwifi/11n.h | 163 + drivers/net/wireless/nxp/nxpwifi/11n_aggr.c | 276 ++ drivers/net/wireless/nxp/nxpwifi/11n_aggr.h | 21 + .../net/wireless/nxp/nxpwifi/11n_rxreorder.c | 917 ++++ .../net/wireless/nxp/nxpwifi/11n_rxreorder.h | 72 + drivers/net/wireless/nxp/nxpwifi/Kconfig | 22 + drivers/net/wireless/nxp/nxpwifi/Makefile | 38 + drivers/net/wireless/nxp/nxpwifi/cfg.h | 445 ++ drivers/net/wireless/nxp/nxpwifi/cfg80211.c | 3773 +++++++++++++++++ drivers/net/wireless/nxp/nxpwifi/cfg80211.h | 19 + drivers/net/wireless/nxp/nxpwifi/cfp.c | 484 +++ drivers/net/wireless/nxp/nxpwifi/cmdevt.c | 1285 ++++++ drivers/net/wireless/nxp/nxpwifi/cmdevt.h | 92 + drivers/net/wireless/nxp/nxpwifi/debugfs.c | 1041 +++++ drivers/net/wireless/nxp/nxpwifi/decl.h | 294 ++ drivers/net/wireless/nxp/nxpwifi/ethtool.c | 58 + drivers/net/wireless/nxp/nxpwifi/fw.h | 2249 ++++++++++ drivers/net/wireless/nxp/nxpwifi/ie.c | 501 +++ drivers/net/wireless/nxp/nxpwifi/init.c | 694 +++ drivers/net/wireless/nxp/nxpwifi/join.c | 915 ++++ drivers/net/wireless/nxp/nxpwifi/main.c | 1666 ++++++++ drivers/net/wireless/nxp/nxpwifi/main.h | 1478 +++++++ drivers/net/wireless/nxp/nxpwifi/scan.c | 2806 ++++++++++++ drivers/net/wireless/nxp/nxpwifi/sdio.c | 2648 ++++++++++++ drivers/net/wireless/nxp/nxpwifi/sdio.h | 340 ++ drivers/net/wireless/nxp/nxpwifi/sta_cfg.c | 1307 ++++++ drivers/net/wireless/nxp/nxpwifi/sta_cmd.c | 3233 ++++++++++++++ drivers/net/wireless/nxp/nxpwifi/sta_event.c | 864 ++++ drivers/net/wireless/nxp/nxpwifi/sta_rx.c | 244 ++ drivers/net/wireless/nxp/nxpwifi/sta_tx.c | 209 + drivers/net/wireless/nxp/nxpwifi/txrx.c | 358 ++ drivers/net/wireless/nxp/nxpwifi/uap_cmd.c | 1169 +++++ drivers/net/wireless/nxp/nxpwifi/uap_event.c | 491 +++ drivers/net/wireless/nxp/nxpwifi/uap_txrx.c | 499 +++ drivers/net/wireless/nxp/nxpwifi/util.c | 946 +++++ drivers/net/wireless/nxp/nxpwifi/util.h | 108 + drivers/net/wireless/nxp/nxpwifi/wmm.c | 1379 ++++++ drivers/net/wireless/nxp/nxpwifi/wmm.h | 78 + include/linux/mmc/sdio_ids.h | 3 + 48 files changed, 34897 insertions(+) create mode 100644 drivers/net/wireless/nxp/Kconfig create mode 100644 drivers/net/wireless/nxp/Makefile create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/11h.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/Kconfig create mode 100644 drivers/net/wireless/nxp/nxpwifi/Makefile create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfp.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/debugfs.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/decl.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/ethtool.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/fw.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/ie.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/init.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/join.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/scan.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_cfg.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_cmd.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_event.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_rx.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_tx.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/txrx.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_cmd.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_event.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_txrx.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/util.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/util.h create mode 100644 drivers/net/wireless/nxp/nxpwifi/wmm.c create mode 100644 drivers/net/wireless/nxp/nxpwifi/wmm.h
base-commit: 555ba98448f8916bff87067853a7e931949e6b57
Signature · 1 line
2.34.1
PATCH v2 1/43 wifi: nxpwifi: add 11ac.c
--- drivers/net/wireless/nxp/nxpwifi/11ac.c | 366 ++++++++++++++++++++++++ 1 file changed, 366 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.c
drivers/net/wireless/nxp/nxpwifi/11ac.c new file +366 -0
@@ -0,0 +1,366 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: 802.11ac +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "fw.h" +#include "main.h" +#include "11ac.h" + +/* Tables of the MCS map to the highest data rate (in Mbps) supported +* for long GI. +*/ +static const u16 max_rate_lgi_80MHZ[8 ][3 ] = { + {0x124 ,0x15F ,0x186 },/* NSS = 1 */ + {0x249 ,0x2BE ,0x30C },/* NSS = 2 */ + {0x36D ,0x41D ,0x492 },/* NSS = 3 */ + {0x492 ,0x57C ,0x618 },/* NSS = 4 */ + {0x5B6 ,0x6DB ,0x79E },/* NSS = 5 */ + {0x6DB ,0x83A ,0x0 },/* NSS = 6 */ + {0x7FF ,0x999 ,0xAAA },/* NSS = 7 */ + {0x924 ,0xAF8 ,0xC30 }/* NSS = 8 */ +}; + +static const u16 max_rate_lgi_160MHZ[8 ][3 ] = { + {0x249 ,0x2BE ,0x30C },/* NSS = 1 */ + {0x492 ,0x57C ,0x618 },/* NSS = 2 */ + {0x6DB ,0x83A ,0x0 },/* NSS = 3 */ + {0x924 ,0xAF8 ,0xC30 },/* NSS = 4 */ + {0xB6D ,0xDB6 ,0xF3C },/* NSS = 5 */ + {0xDB6 ,0x1074 ,0x1248 },/* NSS = 6 */ + {0xFFF ,0x1332 ,0x1554 },/* NSS = 7 */ + {0x1248 ,0x15F0 ,0x1860 }/* NSS = 8 */ +}; + +/* This function converts the 2-bit MCS map to the highest long GI +* VHT data rate. +*/ +static u16 +nxpwifi_convert_mcsmap_to_maxrate (struct nxpwifi_private *priv, +u8 bands,u16 mcs_map) +{ +u8 i, nss, mcs; +u16 max_rate =0 ; +u32 usr_vht_cap_info =0 ; +struct nxpwifi_adapter *adapter = priv->adapter; + +if (bands &BAND_AAC ) + usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_a; +else + usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_bg; + +/* find the max NSS supported */ + nss =1 ; +for (i =1 ; i <=8 ; i++) { + mcs =GET_VHTNSSMCS (mcs_map, i); +if (mcs <IEEE80211_VHT_MCS_NOT_SUPPORTED ) + nss = i; + } + mcs =GET_VHTNSSMCS (mcs_map, nss); + +/* if mcs is 3, nss must be 1 (NSS = 1). Default mcs to MCS 0~9 */ +if (mcs ==IEEE80211_VHT_MCS_NOT_SUPPORTED ) + mcs =IEEE80211_VHT_MCS_SUPPORT_0_9 ; + +if (GET_VHTCAP_CHWDSET (usr_vht_cap_info)) { +/* support 160 MHz */ + max_rate = max_rate_lgi_160MHZ[nss -1 ][mcs]; +if (!max_rate) +/* MCS9 is not supported in NSS6 */ + max_rate = max_rate_lgi_160MHZ[nss -1 ][mcs -1 ]; + }else { + max_rate = max_rate_lgi_80MHZ[nss -1 ][mcs]; +if (!max_rate) +/* MCS9 is not supported in NSS3 */ + max_rate = max_rate_lgi_80MHZ[nss -1 ][mcs -1 ]; + } + +return max_rate; +} + +static void +nxpwifi_fill_vht_cap_info (struct nxpwifi_private *priv, +struct ieee80211_vht_cap *vht_cap,u8 bands) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (bands &BAND_A ) + vht_cap->vht_cap_info = +cpu_to_le32 (adapter->usr_dot_11ac_dev_cap_a); +else + vht_cap->vht_cap_info = +cpu_to_le32 (adapter->usr_dot_11ac_dev_cap_bg); +} + +void nxpwifi_fill_vht_cap_tlv (struct nxpwifi_private *priv, +struct ieee80211_vht_cap *vht_cap,u8 bands) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +u16 mcs_map_user, mcs_map_resp, mcs_map_result; +u16 mcs_user, mcs_resp, nss, tmp; + +/* Fill VHT cap info */ +nxpwifi_fill_vht_cap_info (priv, vht_cap, bands); + +/* rx MCS Set: find the minimum of the user rx mcs and ap rx mcs */ + mcs_map_user =GET_DEVRXMCSMAP (adapter->usr_dot_11ac_mcs_support); + mcs_map_resp =le16_to_cpu (vht_cap->supp_mcs.rx_mcs_map); + mcs_map_result =0 ; + +for (nss =1 ; nss <=8 ; nss++) { + mcs_user =GET_VHTNSSMCS (mcs_map_user, nss); + mcs_resp =GET_VHTNSSMCS (mcs_map_resp, nss); + +if (mcs_user ==IEEE80211_VHT_MCS_NOT_SUPPORTED || + mcs_resp ==IEEE80211_VHT_MCS_NOT_SUPPORTED ) +SET_VHTNSSMCS (mcs_map_result, nss, +IEEE80211_VHT_MCS_NOT_SUPPORTED ); +else +SET_VHTNSSMCS (mcs_map_result, nss, +min (mcs_user, mcs_resp)); + } + + vht_cap->supp_mcs.rx_mcs_map =cpu_to_le16 (mcs_map_result); + + tmp =nxpwifi_convert_mcsmap_to_maxrate (priv, bands, mcs_map_result); + vht_cap->supp_mcs.rx_highest =cpu_to_le16 (tmp); + +/* tx MCS Set: find the minimum of the user tx mcs and ap tx mcs */ + mcs_map_user =GET_DEVTXMCSMAP (adapter->usr_dot_11ac_mcs_support); + mcs_map_resp =le16_to_cpu (vht_cap->supp_mcs.tx_mcs_map); + mcs_map_result =0 ; + +for (nss =1 ; nss <=8 ; nss++) { + mcs_user =GET_VHTNSSMCS (mcs_map_user, nss); + mcs_resp =GET_VHTNSSMCS (mcs_map_resp, nss); +if (mcs_user ==IEEE80211_VHT_MCS_NOT_SUPPORTED || + mcs_resp ==IEEE80211_VHT_MCS_NOT_SUPPORTED ) +SET_VHTNSSMCS (mcs_map_result, nss, +IEEE80211_VHT_MCS_NOT_SUPPORTED ); +else +SET_VHTNSSMCS (mcs_map_result, nss, +min (mcs_user, mcs_resp)); + } + + vht_cap->supp_mcs.tx_mcs_map =cpu_to_le16 (mcs_map_result); + + tmp =nxpwifi_convert_mcsmap_to_maxrate (priv, bands, mcs_map_result); + vht_cap->supp_mcs.tx_highest =cpu_to_le16 (tmp); +} + +int nxpwifi_cmd_append_11ac_tlv (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc, +u8 **buffer) +{ +struct nxpwifi_ie_types_vhtcap *vht_cap; +struct nxpwifi_ie_types_oper_mode_ntf *oper_ntf; +struct ieee_types_oper_mode_ntf *ieee_oper_ntf; +struct nxpwifi_ie_types_vht_oper *vht_op; +struct nxpwifi_adapter *adapter = priv->adapter; +u8 supp_chwd_set; +u32 usr_vht_cap_info; +int ret_len =0 ; + +if (bss_desc->bss_band &BAND_A ) + usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_a; +else + usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_bg; + +/* VHT Capabilities IE */ +if (bss_desc->bcn_vht_cap) { + vht_cap = (struct nxpwifi_ie_types_vhtcap *)*buffer; +memset (vht_cap,0 ,sizeof (*vht_cap)); + vht_cap->header.type =cpu_to_le16 (WLAN_EID_VHT_CAPABILITY ); + vht_cap->header.len = +cpu_to_le16 (sizeof (struct ieee80211_vht_cap )); +memcpy ((u8 *)vht_cap +sizeof (struct nxpwifi_ie_types_header ), + (u8 *)bss_desc->bcn_vht_cap, +le16_to_cpu (vht_cap->header.len)); + +nxpwifi_fill_vht_cap_tlv (priv, &vht_cap->vht_cap, + bss_desc->bss_band); + *buffer +=sizeof (*vht_cap); + ret_len +=sizeof (*vht_cap); + } + +/* VHT Operation IE */ +if (bss_desc->bcn_vht_oper) { +if (priv->bss_mode ==NL80211_IFTYPE_STATION ) { + vht_op = (struct nxpwifi_ie_types_vht_oper *)*buffer; +memset (vht_op,0 ,sizeof (*vht_op)); + vht_op->header.type = +cpu_to_le16 (WLAN_EID_VHT_OPERATION ); + vht_op->header.len =cpu_to_le16 (sizeof (*vht_op) - +sizeof (struct nxpwifi_ie_types_header )); +memcpy ((u8 *)vht_op + +sizeof (struct nxpwifi_ie_types_header ), + (u8 *)bss_desc->bcn_vht_oper, +le16_to_cpu (vht_op->header.len)); + +/* negotiate the channel width and central freq +* and keep the central freq as the peer suggests +*/ + supp_chwd_set =GET_VHTCAP_CHWDSET (usr_vht_cap_info); + +switch (supp_chwd_set) { +case 0 : + vht_op->chan_width = +min_t (u8,IEEE80211_VHT_CHANWIDTH_80MHZ , + bss_desc->bcn_vht_oper->chan_width); +break ; +case 1 : + vht_op->chan_width = +min_t (u8,IEEE80211_VHT_CHANWIDTH_160MHZ , + bss_desc->bcn_vht_oper->chan_width); +break ; +case 2 : + vht_op->chan_width = +min_t (u8,IEEE80211_VHT_CHANWIDTH_80P80MHZ , + bss_desc->bcn_vht_oper->chan_width); +break ; +default : + vht_op->chan_width = +IEEE80211_VHT_CHANWIDTH_USE_HT ; +break ; + } + + *buffer +=sizeof (*vht_op); + ret_len +=sizeof (*vht_op); + } + } + +/* Operating Mode Notification IE */ +if (bss_desc->oper_mode) { + ieee_oper_ntf = bss_desc->oper_mode; + oper_ntf = (void *)*buffer; +memset (oper_ntf,0 ,sizeof (*oper_ntf)); + oper_ntf->header.type =cpu_to_le16 (WLAN_EID_OPMODE_NOTIF ); + oper_ntf->header.len =cpu_to_le16 (sizeof (u8)); + oper_ntf->oper_mode = ieee_oper_ntf->oper_mode; + *buffer +=sizeof (*oper_ntf); + ret_len +=sizeof (*oper_ntf); + } + +return ret_len; +} + +int nxpwifi_cmd_11ac_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd,u16 cmd_action, +struct nxpwifi_11ac_vht_cfg *cfg) +{ +struct host_cmd_11ac_vht_cfg *vhtcfg = &cmd->params.vht_cfg; + + cmd->command =cpu_to_le16 (HOST_CMD_11AC_CFG ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_11ac_vht_cfg ) + +S_DS_GEN ); + vhtcfg->action =cpu_to_le16 (cmd_action); + vhtcfg->band_config = cfg->band_config; + vhtcfg->misc_config = cfg->misc_config; + vhtcfg->cap_info =cpu_to_le32 (cfg->cap_info); + vhtcfg->mcs_tx_set =cpu_to_le32 (cfg->mcs_tx_set); + vhtcfg->mcs_rx_set =cpu_to_le32 (cfg->mcs_rx_set); + +return 0 ; +} + +/* This function initializes the BlockACK setup information for given +* nxpwifi_private structure for 11ac enabled networks. +*/ +void nxpwifi_set_11ac_ba_params (struct nxpwifi_private *priv) +{ + priv->add_ba_param.timeout =NXPWIFI_DEFAULT_BLOCK_ACK_TIMEOUT ; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + priv->add_ba_param.tx_win_size = +NXPWIFI_11AC_UAP_AMPDU_DEF_TXWINSIZE ; + priv->add_ba_param.rx_win_size = +NXPWIFI_11AC_UAP_AMPDU_DEF_RXWINSIZE ; + }else { + priv->add_ba_param.tx_win_size = +NXPWIFI_11AC_STA_AMPDU_DEF_TXWINSIZE ; + priv->add_ba_param.rx_win_size = +NXPWIFI_11AC_STA_AMPDU_DEF_RXWINSIZE ; + } +} + +bool nxpwifi_is_bss_in_11ac_mode (struct nxpwifi_private *priv) +{ +struct nxpwifi_bssdescriptor *bss_desc; +struct ieee80211_vht_operation *vht_oper; + + bss_desc = &priv->curr_bss_params.bss_descriptor; + vht_oper = bss_desc->bcn_vht_oper; + +if (!bss_desc->bcn_vht_cap || !vht_oper) +return false; + +if (vht_oper->chan_width ==IEEE80211_VHT_CHANWIDTH_USE_HT ) +return false; + +return true; +} + +u8 nxpwifi_get_center_freq_index (struct nxpwifi_private *priv,u8 band, +u32 pri_chan,u8 chan_bw) +{ +u8 center_freq_idx =0 ; + +if (band &BAND_AAC ) { +switch (pri_chan) { +case 36 : +case 40 : +case 44 : +case 48 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =42 ; +break ; +case 52 : +case 56 : +case 60 : +case 64 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =58 ; +else if (chan_bw ==IEEE80211_VHT_CHANWIDTH_160MHZ ) + center_freq_idx =50 ; +break ; +case 100 : +case 104 : +case 108 : +case 112 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =106 ; +break ; +case 116 : +case 120 : +case 124 : +case 128 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =122 ; +else if (chan_bw ==IEEE80211_VHT_CHANWIDTH_160MHZ ) + center_freq_idx =114 ; +break ; +case 132 : +case 136 : +case 140 : +case 144 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =138 ; +break ; +case 149 : +case 153 : +case 157 : +case 161 : +if (chan_bw ==IEEE80211_VHT_CHANWIDTH_80MHZ ) + center_freq_idx =155 ; +break ; +default : + center_freq_idx =42 ; + } + } + +return center_freq_idx; +}
Signature · 1 line
2.34.1
PATCH v2 2/43 wifi: nxpwifi: add 11ac.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11ac.h | 33 +++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.h
drivers/net/wireless/nxp/nxpwifi/11ac.h new file +33 -0
@@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: 802.11ac +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_11AC_H_ +#define _NXPWIFI_11AC_H_ + +#define VHT_CFG_2GHZ BIT(0) +#define VHT_CFG_5GHZ BIT(1) + +enum vht_cfg_misc_config { +VHT_CAP_TX_OPERATION =1 , +VHT_CAP_ASSOCIATION , +VHT_CAP_UAP_ONLY +}; + +#define DEFAULT_VHT_MCS_SET 0xfffe +#define DISABLE_VHT_MCS_SET 0xffff + +#define VHT_BW_80_160_80P80 BIT(2) + +int nxpwifi_cmd_append_11ac_tlv (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc, +u8 **buffer); +int nxpwifi_cmd_11ac_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd,u16 cmd_action, +struct nxpwifi_11ac_vht_cfg *cfg); +void nxpwifi_fill_vht_cap_tlv (struct nxpwifi_private *priv, +struct ieee80211_vht_cap *vht_cap,u8 bands); +#endif /* _NXPWIFI_11AC_H_ */
Signature · 1 line
2.34.1
PATCH v2 3/43 wifi: nxpwifi: add 11h.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11h.c | 433 +++++++++++++++++++++++++ 1 file changed, 433 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11h.c
drivers/net/wireless/nxp/nxpwifi/11h.c new file +433 -0
@@ -0,0 +1,433 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: 802.11h +* +* Copyright 2011-2024 NXP +*/ + +#include "main.h" +#include "cmdevt.h" +#include "fw.h" +#include "cfg80211.h" + +void nxpwifi_init_11h_params (struct nxpwifi_private *priv) +{ + priv->state_11h.is_11h_enabled = true; + priv->state_11h.is_11h_active = false; +} + +inline int nxpwifi_is_11h_active (struct nxpwifi_private *priv) +{ +return priv->state_11h.is_11h_active; +} + +/* This function appends 11h info to a buffer while joining an +* infrastructure BSS +*/ +static void +nxpwifi_11h_process_infra_join (struct nxpwifi_private *priv,u8 **buffer, +struct nxpwifi_bssdescriptor *bss_desc) +{ +struct nxpwifi_ie_types_header *ie_header; +struct nxpwifi_ie_types_pwr_capability *cap; +struct nxpwifi_ie_types_local_pwr_constraint *constraint; +struct ieee80211_supported_band *sband; +u8 radio_type; +int i; + +if (!buffer || !(*buffer)) +return ; + + radio_type =nxpwifi_band_to_radio_type ((u8 )bss_desc->bss_band); + sband = priv->wdev.wiphy->bands[radio_type]; + + cap = (struct nxpwifi_ie_types_pwr_capability *)*buffer; + cap->header.type =cpu_to_le16 (WLAN_EID_PWR_CAPABILITY ); + cap->header.len =cpu_to_le16 (2 ); + cap->min_pwr =0 ; + cap->max_pwr =0 ; + *buffer +=sizeof (*cap); + + constraint = (struct nxpwifi_ie_types_local_pwr_constraint *)*buffer; + constraint->header.type =cpu_to_le16 (WLAN_EID_PWR_CONSTRAINT ); + constraint->header.len =cpu_to_le16 (2 ); + constraint->chan = bss_desc->channel; + constraint->constraint = bss_desc->local_constraint; + *buffer +=sizeof (*constraint); + + ie_header = (struct nxpwifi_ie_types_header *)*buffer; + ie_header->type =cpu_to_le16 (TLV_TYPE_PASSTHROUGH ); + ie_header->len =cpu_to_le16 (2 * sband->n_channels +2 ); + *buffer +=sizeof (*ie_header); + *(*buffer)++ =WLAN_EID_SUPPORTED_CHANNELS ; + *(*buffer)++ =2 * sband->n_channels; +for (i =0 ; i < sband->n_channels; i++) { +u32 center_freq; + + center_freq = sband->channels[i].center_freq; + *(*buffer)++ =ieee80211_frequency_to_channel (center_freq); + *(*buffer)++ =1 ;/* one channel in the subband */ + } +} + +/* Enable or disable the 11h extensions in the firmware */ +int nxpwifi_11h_activate (struct nxpwifi_private *priv,bool flag) +{ +u32 enable = flag; + +/* enable master mode radar detection on AP interface */ +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) && enable) + enable |=NXPWIFI_MASTER_RADAR_DET_MASK ; + +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_SNMP_MIB , +HOST_ACT_GEN_SET ,DOT11H_I , &enable, true); +} + +/* This functions processes TLV buffer for a pending BSS Join command. +* +* Activate 11h functionality in the firmware if the spectrum management +* capability bit is found in the network we are joining. Also, necessary +* TLVs are set based on requested network's 11h capability. +*/ +void nxpwifi_11h_process_join (struct nxpwifi_private *priv,u8 **buffer, +struct nxpwifi_bssdescriptor *bss_desc) +{ +if (bss_desc->sensed_11h) { +/* Activate 11h functions in firmware, turns on capability +* bit +*/ +nxpwifi_11h_activate (priv, true); + priv->state_11h.is_11h_active = true; + bss_desc->cap_info_bitmap |=WLAN_CAPABILITY_SPECTRUM_MGMT ; +nxpwifi_11h_process_infra_join (priv, buffer, bss_desc); + }else { +/* Deactivate 11h functions in the firmware */ +nxpwifi_11h_activate (priv, false); + priv->state_11h.is_11h_active = false; + bss_desc->cap_info_bitmap &= ~WLAN_CAPABILITY_SPECTRUM_MGMT ; + } +} + +/* This is DFS CAC work function. +* This delayed work emits CAC finished event for cfg80211 if +* CAC was started earlier. +*/ +void nxpwifi_dfs_cac_work (struct work_struct *work) +{ +struct cfg80211_chan_def chandef; +struct delayed_work *delayed_work =to_delayed_work (work); +struct nxpwifi_private *priv =container_of (delayed_work, + struct nxpwifi_private, + dfs_cac_work); + + chandef = priv->dfs_chandef; +if (priv->wdev.cac_started) { +nxpwifi_dbg (priv->adapter,MSG , +"CAC timer finished; No radar detected\n" ); +cfg80211_cac_event (priv->netdev, &chandef, +NL80211_RADAR_CAC_FINISHED , +GFP_KERNEL ); + } +} + +static u8 nxpwifi_get_channel_2_offset (int chan) +{ +u8 chan2_offset =SEC_CHAN_NONE ; + +switch (chan) { +case 36 : +case 44 : +case 52 : +case 60 : +case 100 : +case 108 : +case 116 : +case 124 : +case 132 : +case 140 : +case 149 : +case 157 : +case 165 : +case 173 : + chan2_offset =SEC_CHAN_ABOVE ; +break ; +case 40 : +case 48 : +case 56 : +case 64 : +case 104 : +case 112 : +case 120 : +case 128 : +case 136 : +case 144 : +case 153 : +case 161 : +case 169 : +case 177 : + chan2_offset =SEC_CHAN_BELOW ; +break ; + } + +return chan2_offset; +} + +static void nxpwifi_convert_chan_to_band_cfg (u8 *band_cfg, +struct cfg80211_chan_def *chan_def) +{ +u8 chan_band =0 , chan_width =0 , chan2_offset =0 ; + +switch (chan_def->chan->band) { +case NL80211_BAND_2GHZ : + chan_band =BAND_2GHZ ; +break ; +case NL80211_BAND_5GHZ : + chan_band =BAND_5GHZ ; +break ; +default : +break ; + } + +switch (chan_def->width) { +case NL80211_CHAN_WIDTH_20_NOHT : +case NL80211_CHAN_WIDTH_20 : + chan_width =CHAN_BW_20MHZ ; +break ; +case NL80211_CHAN_WIDTH_40 : + chan_width =CHAN_BW_40MHZ ; +if (chan_def->center_freq1 > chan_def->chan->center_freq) + chan2_offset =SEC_CHAN_ABOVE ; +else + chan2_offset =SEC_CHAN_BELOW ; +break ; +case NL80211_CHAN_WIDTH_80 : + chan2_offset = +nxpwifi_get_channel_2_offset (chan_def->chan->hw_value); + chan_width =CHAN_BW_80MHZ ; +break ; +case NL80211_CHAN_WIDTH_80P80 : +case NL80211_CHAN_WIDTH_160 : +default : +break ; + } + + *band_cfg = ((chan2_offset <<BAND_CFG_CHAN2_SHIFT_BIT ) & +BAND_CFG_CHAN2_OFFSET_MASK ) | + ((chan_width <<BAND_CFG_CHAN_WIDTH_SHIFT_BIT ) & +BAND_CFG_CHAN_WIDTH_MASK ) | + ((chan_band <<BAND_CFG_CHAN_BAND_SHIFT_BIT ) & +BAND_CFG_CHAN_BAND_MASK ); +} + +/* This function prepares channel report request command to FW for +* starting radar detection. +*/ +int nxpwifi_cmd_issue_chan_report_request (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +void *data_buf) +{ +struct host_cmd_ds_chan_rpt_req *cr_req = &cmd->params.chan_rpt_req; +struct nxpwifi_radar_params *radar_params = (void *)data_buf; +u16 size; + + cmd->command =cpu_to_le16 (HOST_CMD_CHAN_REPORT_REQUEST ); + size =S_DS_GEN ; + + cr_req->chan_desc.start_freq =cpu_to_le16 (NXPWIFI_A_BAND_START_FREQ ); +nxpwifi_convert_chan_to_band_cfg (&cr_req->chan_desc.band_cfg, + radar_params->chandef); + cr_req->chan_desc.chan_num = radar_params->chandef->chan->hw_value; + cr_req->msec_dwell_time =cpu_to_le32 (radar_params->cac_time_ms); + size +=sizeof (*cr_req); + +if (radar_params->cac_time_ms) { +struct nxpwifi_ie_types_chan_rpt_data *rpt; + + rpt = (struct nxpwifi_ie_types_chan_rpt_data *)((u8 *)cmd + size); + rpt->header.type =cpu_to_le16 (TLV_TYPE_CHANRPT_11H_BASIC ); + rpt->header.len =cpu_to_le16 (sizeof (u8)); + rpt->meas_rpt_map =1 <<MEAS_RPT_MAP_RADAR_SHIFT_BIT ; + size +=sizeof (*rpt); + +nxpwifi_dbg (priv->adapter,MSG , +"11h: issuing DFS Radar check for channel=%d\n" , + radar_params->chandef->chan->hw_value); + }else { +nxpwifi_dbg (priv->adapter,MSG ,"cancelling CAC\n" ); + } + + cmd->size =cpu_to_le16 (size); + +return 0 ; +} + +int nxpwifi_stop_radar_detection (struct nxpwifi_private *priv, +struct cfg80211_chan_def *chandef) +{ +struct nxpwifi_radar_params radar_params; + +memset (&radar_params,0 ,sizeof (struct nxpwifi_radar_params )); + radar_params.chandef = chandef; + radar_params.cac_time_ms =0 ; + +return nxpwifi_send_cmd (priv,HOST_CMD_CHAN_REPORT_REQUEST , +HOST_ACT_GEN_SET ,0 , &radar_params, true); +} + +/* This function is to abort ongoing CAC upon stopping AP operations +* or during unload. +*/ +void nxpwifi_abort_cac (struct nxpwifi_private *priv) +{ +if (priv->wdev.cac_started) { +if (nxpwifi_stop_radar_detection (priv, &priv->dfs_chandef)) +nxpwifi_dbg (priv->adapter,ERROR , +"failed to stop CAC in FW\n" ); +nxpwifi_dbg (priv->adapter,MSG , +"Aborting delayed work for CAC.\n" ); +cancel_delayed_work_sync (&priv->dfs_cac_work); +cfg80211_cac_event (priv->netdev, &priv->dfs_chandef, +NL80211_RADAR_CAC_ABORTED ,GFP_KERNEL ); + } +} + +/* This function handles channel report event from FW during CAC period. +* If radar is detected during CAC, driver indicates the same to cfg80211 +* and also cancels ongoing delayed work. +*/ +int nxpwifi_11h_handle_chanrpt_ready (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct host_cmd_ds_chan_rpt_event *rpt_event; +struct nxpwifi_ie_types_chan_rpt_data *rpt; +u16 event_len, tlv_len; + + rpt_event = (void *)(skb->data +sizeof (u32)); + event_len = skb->len - (sizeof (struct host_cmd_ds_chan_rpt_event ) + +sizeof (u32)); + +if (le32_to_cpu (rpt_event->result) !=HOST_RESULT_OK ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Error in channel report event\n" ); +return -EINVAL ; + } + +while (event_len >=sizeof (struct nxpwifi_ie_types_header )) { + rpt = (void *)&rpt_event->tlvbuf; + tlv_len =le16_to_cpu (rpt->header.len); + +switch (le16_to_cpu (rpt->header.type)) { +case TLV_TYPE_CHANRPT_11H_BASIC : +if (rpt->meas_rpt_map &MEAS_RPT_MAP_RADAR_MASK ) { +nxpwifi_dbg (priv->adapter,MSG , +"RADAR Detected on channel %d!\n" , + priv->dfs_chandef.chan->hw_value); +cancel_delayed_work_sync (&priv->dfs_cac_work); +cfg80211_cac_event (priv->netdev, + &priv->dfs_chandef, +NL80211_RADAR_CAC_ABORTED , +GFP_KERNEL ); +cfg80211_radar_event (priv->adapter->wiphy, + &priv->dfs_chandef, +GFP_KERNEL ); + } +break ; +default : +break ; + } + + event_len -= (tlv_len +sizeof (rpt->header)); + } + +return 0 ; +} + +/* Handler for radar detected event from FW.*/ +int nxpwifi_11h_handle_radar_detected (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct nxpwifi_radar_det_event *rdr_event; + + rdr_event = (void *)(skb->data +sizeof (u32)); + +nxpwifi_dbg (priv->adapter,MSG , +"radar detected; indicating kernel\n" ); +if (priv->wdev.cac_started) { +if (nxpwifi_stop_radar_detection (priv, &priv->dfs_chandef)) +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to stop CAC in FW\n" ); +cancel_delayed_work_sync (&priv->dfs_cac_work); +cfg80211_cac_event (priv->netdev, &priv->dfs_chandef, +NL80211_RADAR_CAC_ABORTED ,GFP_KERNEL ); + } +cfg80211_radar_event (priv->adapter->wiphy, &priv->dfs_chandef, +GFP_KERNEL ); +nxpwifi_dbg (priv->adapter,MSG ,"regdomain: %d\n" , + rdr_event->reg_domain); +nxpwifi_dbg (priv->adapter,MSG ,"radar detection type: %d\n" , + rdr_event->det_type); + +return 0 ; +} + +/* This is work function for channel switch handling. +* This function takes care of updating new channel definitin to +* bss config structure, restart AP and indicate channel switch success +* to cfg80211. +*/ +void nxpwifi_dfs_chan_sw_work (struct work_struct *work) +{ +struct nxpwifi_uap_bss_param *bss_cfg; +struct delayed_work *delayed_work =to_delayed_work (work); +struct nxpwifi_private *priv =container_of (delayed_work, + struct nxpwifi_private, + dfs_chan_sw_work); +struct nxpwifi_adapter *adapter = priv->adapter; + +if (nxpwifi_del_mgmt_ies (priv)) +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to delete mgmt IEs!\n" ); + + bss_cfg = &priv->bss_cfg; +if (!bss_cfg->beacon_period) { +nxpwifi_dbg (adapter,ERROR , +"channel switch: AP already stopped\n" ); +return ; + } + +if (nxpwifi_send_cmd (priv,HOST_CMD_UAP_BSS_STOP , +HOST_ACT_GEN_SET ,0 ,NULL , true)) { +nxpwifi_dbg (adapter,ERROR , +"channel switch: Failed to stop the BSS\n" ); +return ; + } + +if (nxpwifi_cfg80211_change_beacon_data (adapter->wiphy, + priv->netdev, + &priv->beacon_after)) { +nxpwifi_dbg (adapter,ERROR , +"channel switch: Failed to set beacon\n" ); +return ; + } + +nxpwifi_uap_set_channel (priv, bss_cfg, priv->dfs_chandef); + +if (nxpwifi_config_start_uap (priv, bss_cfg)) { +nxpwifi_dbg (adapter,ERROR , +"Failed to start AP after channel switch\n" ); +return ; + } + +nxpwifi_dbg (adapter,MSG , +"indicating channel switch completion to kernel\n" ); +wiphy_lock (priv->wdev.wiphy); +cfg80211_ch_switch_notify (priv->netdev, &priv->dfs_chandef,0 ); +wiphy_unlock (priv->wdev.wiphy); + +if (priv->uap_stop_tx) { +if (!netif_carrier_ok (priv->netdev)) +netif_carrier_on (priv->netdev); +nxpwifi_wake_up_net_dev_queue (priv->netdev, adapter); + priv->uap_stop_tx = false; + } +}
Signature · 1 line
2.34.1
PATCH v2 4/43 wifi: nxpwifi: add 11n_aggr.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11n_aggr.c | 276 ++++++++++++++++++++ 1 file changed, 276 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.c
drivers/net/wireless/nxp/nxpwifi/11n_aggr.c new file +276 -0
@@ -0,0 +1,276 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: 802.11n Aggregation +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "wmm.h" +#include "11n.h" +#include "11n_aggr.h" + +/* Creates an AMSDU subframe for aggregation into one AMSDU packet. +* +* The resultant AMSDU subframe format is - +* +* +---- ~ -----+---- ~ ------+---- ~ -----+----- ~ -----+---- ~ -----+ +* | DA | SA | Length | SNAP header | MSDU | +* | data[0..5] | data[6..11] | | | data[14..] | +* +---- ~ -----+---- ~ ------+---- ~ -----+----- ~ -----+---- ~ -----+ +* <--6-bytes--> <--6-bytes--> <--2-bytes--><--8-bytes--> <--n-bytes--> +* +* This function also computes the amount of padding required to make the +* buffer length multiple of 4 bytes. +* +* Data => |DA|SA|SNAP-TYPE|........ .| +* MSDU => |DA|SA|Length|SNAP|...... ..| +*/ +static int +nxpwifi_11n_form_amsdu_pkt (struct sk_buff *skb_aggr, +struct sk_buff *skb_src,int *pad) + +{ +int dt_offset; +struct rfc_1042_hdr snap = { +0xaa ,/* LLC DSAP */ +0xaa ,/* LLC SSAP */ +0x03 ,/* LLC CTRL */ + {0x00 ,0x00 ,0x00 },/* SNAP OUI */ +0x0000 /* SNAP type */ +/* This field will be overwritten +* later with ethertype +*/ + }; +struct tx_packet_hdr *tx_header; + + tx_header =skb_put (skb_aggr,sizeof (*tx_header)); + +/* Copy DA and SA */ + dt_offset =2 *ETH_ALEN ; +memcpy (&tx_header->eth803_hdr, skb_src->data, dt_offset); + +/* Copy SNAP header */ + snap.snap_type = ((struct ethhdr *)skb_src->data)->h_proto; + + dt_offset +=sizeof (__be16); + +memcpy (&tx_header->rfc1042_hdr, &snap,sizeof (struct rfc_1042_hdr )); + +skb_pull (skb_src, dt_offset); + +/* Update Length field */ + tx_header->eth803_hdr.h_proto =htons (skb_src->len +LLC_SNAP_LEN ); + +/* Add payload */ +skb_put_data (skb_aggr, skb_src->data, skb_src->len); + +/* Add padding for new MSDU to start from 4 byte boundary */ + *pad = (4 - ((unsigned long )skb_aggr->tail &0x3 )) %4 ; + +return skb_aggr->len + *pad; +} + +/* Adds TxPD to AMSDU header. +* +* Each AMSDU packet will contain one TxPD at the beginning, +* followed by multiple AMSDU subframes. +*/ +static void +nxpwifi_11n_form_amsdu_txpd (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct txpd *local_tx_pd; + +skb_push (skb,sizeof (*local_tx_pd)); + + local_tx_pd = (struct txpd *)skb->data; +memset (local_tx_pd,0 ,sizeof (struct txpd )); + +/* Original priority has been overwritten */ + local_tx_pd->priority = (u8 )skb->priority; + local_tx_pd->pkt_delay_2ms = +nxpwifi_wmm_compute_drv_pkt_delay (priv, skb); + local_tx_pd->bss_num = priv->bss_num; + local_tx_pd->bss_type = priv->bss_type; +/* Always zero as the data is followed by struct txpd */ + local_tx_pd->tx_pkt_offset =cpu_to_le16 (sizeof (struct txpd )); + local_tx_pd->tx_pkt_type =cpu_to_le16 (PKT_TYPE_AMSDU ); + local_tx_pd->tx_pkt_length =cpu_to_le16 (skb->len - +sizeof (*local_tx_pd)); + +if (local_tx_pd->tx_control ==0 ) +/* TxCtrl set by user or default */ + local_tx_pd->tx_control =cpu_to_le32 (priv->pkt_tx_ctrl); + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA && + priv->adapter->pps_uapsd_mode) { +if (nxpwifi_check_last_packet_indication (priv)) { + priv->adapter->tx_lock_flag = true; + local_tx_pd->flags = + NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET; + } + } +} + +/* Create aggregated packet. +* +* This function creates an aggregated MSDU packet, by combining buffers +* from the RA list. Each individual buffer is encapsulated as an AMSDU +* subframe and all such subframes are concatenated together to form the +* AMSDU packet. +* +* A TxPD is also added to the front of the resultant AMSDU packets for +* transmission. The resultant packets format is - +* +* +---- ~ ----+------ ~ ------+------ ~ ------+-..-+------ ~ ------+ +* | TxPD |AMSDU sub-frame|AMSDU sub-frame| .. |AMSDU sub-frame| +* | | 1 | 2 | .. | n | +* +---- ~ ----+------ ~ ------+------ ~ ------+ .. +------ ~ ------+ +*/ +int +nxpwifi_11n_aggregate_pkt (struct nxpwifi_private *priv, +struct nxpwifi_ra_list_tbl *pra_list, +int ptrindex) + __releases(&priv->wmm.ra_list_spinlock) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct sk_buff *skb_aggr, *skb_src; +struct nxpwifi_txinfo *tx_info_aggr, *tx_info_src; +int pad =0 , aggr_num =0 , ret; +struct nxpwifi_tx_param tx_param; +struct txpd *ptx_pd =NULL ; +int headroom = adapter->intf_hdr_len; + + skb_src =skb_peek (&pra_list->skb_head); +if (!skb_src) { +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +return 0 ; + } + + tx_info_src =NXPWIFI_SKB_TXCB (skb_src); + skb_aggr =nxpwifi_alloc_dma_align_buf (adapter->tx_buf_size, +GFP_ATOMIC ); +if (!skb_aggr) { +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +return -ENOMEM ; + } + +/* skb_aggr->data already 64 byte align, just reserve bus interface +* header and txpd. +*/ +skb_reserve (skb_aggr, headroom +sizeof (struct txpd )); + tx_info_aggr =NXPWIFI_SKB_TXCB (skb_aggr); + +memset (tx_info_aggr,0 ,sizeof (*tx_info_aggr)); + tx_info_aggr->bss_type = tx_info_src->bss_type; + tx_info_aggr->bss_num = tx_info_src->bss_num; + + tx_info_aggr->flags |=NXPWIFI_BUF_FLAG_AGGR_PKT ; + skb_aggr->priority = skb_src->priority; + skb_aggr->tstamp = skb_src->tstamp; + +do { +/* Check if AMSDU can accommodate this MSDU */ +if ((skb_aggr->len + skb_src->len +LLC_SNAP_LEN ) > + adapter->tx_buf_size) +break ; + + skb_src =skb_dequeue (&pra_list->skb_head); + pra_list->total_pkt_count--; +atomic_dec (&priv->wmm.tx_pkts_queued); + aggr_num++; +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +nxpwifi_11n_form_amsdu_pkt (skb_aggr, skb_src, &pad); + +nxpwifi_write_data_complete (adapter, skb_src,0 ,0 ); + +spin_lock_bh (&priv->wmm.ra_list_spinlock); + +if (!nxpwifi_is_ralist_valid (priv, pra_list, ptrindex)) { +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +return -ENOENT ; + } + +if (skb_tailroom (skb_aggr) < pad) { + pad =0 ; +break ; + } +skb_put (skb_aggr, pad); + + skb_src =skb_peek (&pra_list->skb_head); + + }while (skb_src); + +spin_unlock_bh (&priv->wmm.ra_list_spinlock); + +/* Last AMSDU packet does not need padding */ +skb_trim (skb_aggr, skb_aggr->len - pad); + +/* Form AMSDU */ +nxpwifi_11n_form_amsdu_txpd (priv, skb_aggr); +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) + ptx_pd = (struct txpd *)skb_aggr->data; + +skb_push (skb_aggr, headroom); + tx_info_aggr->aggr_num = aggr_num *2 ; +if (adapter->data_sent || adapter->tx_lock_flag) { +atomic_add (aggr_num *2 , &adapter->tx_queued); +skb_queue_tail (&adapter->tx_data_q, skb_aggr); +return 0 ; + } + +if (skb_src) + tx_param.next_pkt_len = skb_src->len +sizeof (struct txpd ); +else + tx_param.next_pkt_len =0 ; + + ret = adapter->if_ops.host_to_card (adapter,NXPWIFI_TYPE_DATA , + skb_aggr, &tx_param); + +switch (ret) { +case -EBUSY : +spin_lock_bh (&priv->wmm.ra_list_spinlock); +if (!nxpwifi_is_ralist_valid (priv, pra_list, ptrindex)) { +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +nxpwifi_write_data_complete (adapter, skb_aggr,1 ,-1 ); +return -EINVAL ; + } +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA && + adapter->pps_uapsd_mode && adapter->tx_lock_flag) { + priv->adapter->tx_lock_flag = false; +if (ptx_pd) + ptx_pd->flags =0 ; + } + +skb_queue_tail (&pra_list->skb_head, skb_aggr); + + pra_list->total_pkt_count++; + +atomic_inc (&priv->wmm.tx_pkts_queued); + + tx_info_aggr->flags |=NXPWIFI_BUF_FLAG_REQUEUED_PKT ; +spin_unlock_bh (&priv->wmm.ra_list_spinlock); +nxpwifi_dbg (adapter,ERROR ,"data: -EBUSY is returned\n" ); +break ; +case -EINPROGRESS : +break ; +case 0 : +nxpwifi_write_data_complete (adapter, skb_aggr,1 , ret); +break ; +default : +nxpwifi_dbg (adapter,ERROR ,"%s: host_to_card failed: %#x\n" , + __func__, ret); + adapter->dbg.num_tx_host_to_card_failure++; +nxpwifi_write_data_complete (adapter, skb_aggr,1 , ret); +break ; + } +if (ret != -EBUSY ) +nxpwifi_rotate_priolists (priv, pra_list, ptrindex); + +return 0 ; +}
Signature · 1 line
2.34.1
PATCH v2 5/43 wifi: nxpwifi: add 11n_aggr.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11n_aggr.h | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.h
drivers/net/wireless/nxp/nxpwifi/11n_aggr.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: 802.11n Aggregation +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_11N_AGGR_H_ +#define _NXPWIFI_11N_AGGR_H_ + +#define PKT_TYPE_AMSDU 0xE6 +#define MIN_NUM_AMSDU 2 + +int nxpwifi_11n_deaggregate_pkt (struct nxpwifi_private *priv, +struct sk_buff *skb); +int nxpwifi_11n_aggregate_pkt(struct nxpwifi_private *priv, + struct nxpwifi_ra_list_tbl *ptr, + int ptr_index) + __releases(&priv->wmm.ra_list_spinlock); + +#endif /* !_NXPWIFI_11N_AGGR_H_ */
Signature · 1 line
2.34.1
PATCH v2 6/43 wifi: nxpwifi: add 11n.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11n.c | 851 +++++++++++++++++++++++++ 1 file changed, 851 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.c
drivers/net/wireless/nxp/nxpwifi/11n.c new file +851 -0
@@ -0,0 +1,851 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: 802.11n +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" + +/* Fills HT capability information field, AMPDU Parameters field, HT extended +* capability field, and supported MCS set fields. +* +* HT capability information field, AMPDU Parameters field, supported MCS set +* fields are retrieved from cfg80211 stack +* +* RD responder bit to set to clear in the extended capability header. +*/ +int nxpwifi_fill_cap_info (struct nxpwifi_private *priv,u8 radio_type, +struct ieee80211_ht_cap *ht_cap) +{ +u16 ht_cap_info; +u16 bcn_ht_cap =le16_to_cpu (ht_cap->cap_info); +u16 ht_ext_cap =le16_to_cpu (ht_cap->extended_ht_cap_info); +struct ieee80211_supported_band *sband = + priv->wdev.wiphy->bands[radio_type]; + +if (WARN_ON_ONCE (!sband)) { +nxpwifi_dbg (priv->adapter,ERROR ,"Invalid radio type!\n" ); +return -EINVAL ; + } + + ht_cap->ampdu_params_info = + (sband->ht_cap.ampdu_factor & +IEEE80211_HT_AMPDU_PARM_FACTOR ) | + ((sband->ht_cap.ampdu_density << +IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT ) & +IEEE80211_HT_AMPDU_PARM_DENSITY ); + +memcpy ((u8 *)&ht_cap->mcs, &sband->ht_cap.mcs, +sizeof (sband->ht_cap.mcs)); + +if (priv->bss_mode ==NL80211_IFTYPE_STATION || + (sband->ht_cap.cap &IEEE80211_HT_CAP_SUP_WIDTH_20_40 && + priv->adapter->sec_chan_offset !=IEEE80211_HT_PARAM_CHA_SEC_NONE )) +/* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */ +SETHT_MCS32 (ht_cap->mcs.rx_mask); + +/* Clear RD responder bit */ + ht_ext_cap &= ~IEEE80211_HT_EXT_CAP_RD_RESPONDER ; + + ht_cap_info = sband->ht_cap.cap; +if (bcn_ht_cap) { +if (!(bcn_ht_cap &IEEE80211_HT_CAP_SUP_WIDTH_20_40 )) + ht_cap_info &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40 ; +if (!(bcn_ht_cap &IEEE80211_HT_CAP_SGI_40 )) + ht_cap_info &= ~IEEE80211_HT_CAP_SGI_40 ; +if (!(bcn_ht_cap &IEEE80211_HT_CAP_40MHZ_INTOLERANT )) + ht_cap_info &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT ; + } + ht_cap->cap_info =cpu_to_le16 (ht_cap_info); + ht_cap->extended_ht_cap_info =cpu_to_le16 (ht_ext_cap); + +if (ISSUPP_BEAMFORMING (priv->adapter->hw_dot_11n_dev_cap)) + ht_cap->tx_BF_cap_info =cpu_to_le32 (NXPWIFI_DEF_11N_TX_BF_CAP ); + +return 0 ; +} + +/* This function returns the pointer to an entry in BA Stream +* table which matches the requested BA status. +*/ +static struct nxpwifi_tx_ba_stream_tbl * +nxpwifi_get_ba_status (struct nxpwifi_private *priv, +enum nxpwifi_ba_status ba_status) +{ +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry (tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { +if (tx_ba_tsr_tbl->ba_status == ba_status) { +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); +return tx_ba_tsr_tbl; + } + } +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); +return NULL ; +} + +/* This function handles the command response of delete a block +* ack request. +* +* The function checks the response success status and takes action +* accordingly (send an add BA request in case of success, or recreate +* the deleted stream in case of failure, if the add BA was also +* initiated by us). +*/ +int nxpwifi_ret_11n_delba (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +int tid; +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tbl; +struct host_cmd_ds_11n_delba *del_ba = &resp->params.del_ba; +u16 del_ba_param_set =le16_to_cpu (del_ba->del_ba_param_set); + + tid = del_ba_param_set >>DELBA_TID_POS ; +if (del_ba->del_result ==BA_RESULT_SUCCESS ) { +nxpwifi_del_ba_tbl (priv, tid, del_ba->peer_mac_addr, +TYPE_DELBA_SENT , +INITIATOR_BIT (del_ba_param_set)); + + tx_ba_tbl =nxpwifi_get_ba_status (priv,BA_SETUP_INPROGRESS ); +if (tx_ba_tbl) +nxpwifi_send_addba (priv, tx_ba_tbl->tid, + tx_ba_tbl->ra); + }else {/* +* In case of failure, recreate the deleted stream in case +* we initiated the DELBA +*/ +if (!INITIATOR_BIT (del_ba_param_set)) +return 0 ; + +nxpwifi_create_ba_tbl (priv, del_ba->peer_mac_addr, tid, +BA_SETUP_INPROGRESS ); + + tx_ba_tbl =nxpwifi_get_ba_status (priv,BA_SETUP_INPROGRESS ); + +if (tx_ba_tbl) +nxpwifi_del_ba_tbl (priv, tx_ba_tbl->tid, tx_ba_tbl->ra, +TYPE_DELBA_SENT , true); + } + +return 0 ; +} + +/* This function handles the command response of add a block +* ack request. +* +* Handling includes changing the header fields to CPU formats, checking +* the response success status and taking actions accordingly (delete the +* BA stream table in case of failure). +*/ +int nxpwifi_ret_11n_addba_req (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +int tid, tid_down; +struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &resp->params.add_ba_rsp; +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tbl; +struct nxpwifi_ra_list_tbl *ra_list; +u16 block_ack_param_set =le16_to_cpu (add_ba_rsp->block_ack_param_set); + + add_ba_rsp->ssn =cpu_to_le16 ((le16_to_cpu (add_ba_rsp->ssn)) + &SSN_MASK ); + + tid = (block_ack_param_set &IEEE80211_ADDBA_PARAM_TID_MASK ) + >>BLOCKACKPARAM_TID_POS ; + + tid_down =nxpwifi_wmm_downgrade_tid (priv, tid); + ra_list =nxpwifi_wmm_get_ralist_node (priv, tid_down, + add_ba_rsp->peer_mac_addr); +if (le16_to_cpu (add_ba_rsp->status_code) !=BA_RESULT_SUCCESS ) { +if (ra_list) { + ra_list->ba_status =BA_SETUP_NONE ; + ra_list->amsdu_in_ampdu = false; + } +nxpwifi_del_ba_tbl (priv, tid, add_ba_rsp->peer_mac_addr, +TYPE_DELBA_SENT , true); +if (add_ba_rsp->add_rsp_result !=BA_RESULT_TIMEOUT ) + priv->aggr_prio_tbl[tid].ampdu_ap = +BA_STREAM_NOT_ALLOWED ; +return 0 ; + } + + tx_ba_tbl =nxpwifi_get_ba_tbl (priv, tid, add_ba_rsp->peer_mac_addr); +if (tx_ba_tbl) { +nxpwifi_dbg (priv->adapter,EVENT ,"info: BA stream complete\n" ); + tx_ba_tbl->ba_status =BA_SETUP_COMPLETE ; +if ((block_ack_param_set &BLOCKACKPARAM_AMSDU_SUPP_MASK ) && + priv->add_ba_param.tx_amsdu && + priv->aggr_prio_tbl[tid].amsdu !=BA_STREAM_NOT_ALLOWED ) + tx_ba_tbl->amsdu = true; +else + tx_ba_tbl->amsdu = false; +if (ra_list) { + ra_list->amsdu_in_ampdu = tx_ba_tbl->amsdu; + ra_list->ba_status =BA_SETUP_COMPLETE ; + } + }else { +nxpwifi_dbg (priv->adapter,ERROR ,"BA stream not created\n" ); + } + +return 0 ; +} + +/* This function prepares command of reconfigure Tx buffer. +* +* Preparation includes - +* - Setting command ID, action and proper size +* - Setting Tx buffer size (for SET only) +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_recfg_tx_buf (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd,int cmd_action, +u16 *buf_size) +{ +struct host_cmd_ds_txbuf_cfg *tx_buf = &cmd->params.tx_buf; +u16 action = (u16 )cmd_action; + + cmd->command =cpu_to_le16 (HOST_CMD_RECONFIGURE_TX_BUFF ); + cmd->size = +cpu_to_le16 (sizeof (struct host_cmd_ds_txbuf_cfg ) +S_DS_GEN ); + tx_buf->action =cpu_to_le16 (action); +switch (action) { +case HOST_ACT_GEN_SET : +nxpwifi_dbg (priv->adapter,CMD , +"cmd: set tx_buf=%d\n" , *buf_size); + tx_buf->buff_size =cpu_to_le16 (*buf_size); +break ; +case HOST_ACT_GEN_GET : +default : + tx_buf->buff_size =0 ; +break ; + } +return 0 ; +} + +/* This function prepares command of AMSDU aggregation control. +* +* Preparation includes - +* - Setting command ID, action and proper size +* - Setting AMSDU control parameters (for SET only) +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_amsdu_aggr_ctrl (struct host_cmd_ds_command *cmd, +int cmd_action, +struct nxpwifi_ds_11n_amsdu_aggr_ctrl *aa_ctrl) +{ +struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl = + &cmd->params.amsdu_aggr_ctrl; +u16 action = (u16 )cmd_action; + + cmd->command =cpu_to_le16 (HOST_CMD_AMSDU_AGGR_CTRL ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_amsdu_aggr_ctrl ) + +S_DS_GEN ); + amsdu_ctrl->action =cpu_to_le16 (action); +switch (action) { +case HOST_ACT_GEN_SET : + amsdu_ctrl->enable =cpu_to_le16 (aa_ctrl->enable); + amsdu_ctrl->curr_buf_size =0 ; +break ; +case HOST_ACT_GEN_GET : +default : + amsdu_ctrl->curr_buf_size =0 ; +break ; + } +return 0 ; +} + +/* This function prepares 11n configuration command. +* +* Preparation includes - +* - Setting command ID, action and proper size +* - Setting HT Tx capability and HT Tx information fields +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_11n_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd,u16 cmd_action, +struct nxpwifi_ds_11n_tx_cfg *txcfg) +{ +struct host_cmd_ds_11n_cfg *htcfg = &cmd->params.htcfg; + + cmd->command =cpu_to_le16 (HOST_CMD_11N_CFG ); + cmd->size =cpu_to_le16 (sizeof (struct host_cmd_ds_11n_cfg ) +S_DS_GEN ); + htcfg->action =cpu_to_le16 (cmd_action); + htcfg->ht_tx_cap =cpu_to_le16 (txcfg->tx_htcap); + htcfg->ht_tx_info =cpu_to_le16 (txcfg->tx_htinfo); + +if (priv->adapter->is_hw_11ac_capable) + htcfg->misc_config =cpu_to_le16 (txcfg->misc_config); + +return 0 ; +} + +/* This function appends an 11n TLV to a buffer. +* +* Buffer allocation is responsibility of the calling +* function. No size validation is made here. +* +* The function fills up the following sections, if applicable - +* - HT capability IE +* - HT information IE (with channel list) +* - 20/40 BSS Coexistence IE +* - HT Extended Capabilities IE +*/ +int +nxpwifi_cmd_append_11n_tlv (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc, +u8 **buffer) +{ +struct nxpwifi_ie_types_htcap *ht_cap; +struct nxpwifi_ie_types_chan_list_param_set *chan_list; +struct nxpwifi_ie_types_2040bssco *bss_co_2040; +struct nxpwifi_ie_types_extcap *ext_cap; +int ret_len =0 ; +struct ieee80211_supported_band *sband; +struct element *hdr; +u8 radio_type; + +if (!buffer || !*buffer) +return ret_len; + + radio_type =nxpwifi_band_to_radio_type ((u8 )bss_desc->bss_band); + sband = priv->wdev.wiphy->bands[radio_type]; + +if (bss_desc->bcn_ht_cap) { + ht_cap = (struct nxpwifi_ie_types_htcap *)*buffer; +memset (ht_cap,0 ,sizeof (struct nxpwifi_ie_types_htcap )); + ht_cap->header.type =cpu_to_le16 (WLAN_EID_HT_CAPABILITY ); + ht_cap->header.len = +cpu_to_le16 (sizeof (struct ieee80211_ht_cap )); +memcpy ((u8 *)ht_cap +sizeof (struct nxpwifi_ie_types_header ), + (u8 *)bss_desc->bcn_ht_cap, +le16_to_cpu (ht_cap->header.len)); + +nxpwifi_fill_cap_info (priv, radio_type, &ht_cap->ht_cap); +/* Update HT40 capability from current channel information */ +if (bss_desc->bcn_ht_oper) { +u8 ht_param = bss_desc->bcn_ht_oper->ht_param; +u8 radio = +nxpwifi_band_to_radio_type (bss_desc->bss_band); +int freq = +ieee80211_channel_to_frequency (bss_desc->channel, + radio); +struct ieee80211_channel *chan = +ieee80211_get_channel (priv->adapter->wiphy, freq); + +switch (ht_param &IEEE80211_HT_PARAM_CHA_SEC_OFFSET ) { +case IEEE80211_HT_PARAM_CHA_SEC_ABOVE : +if (chan->flags &IEEE80211_CHAN_NO_HT40PLUS ) { + ht_cap->ht_cap.cap_info &= +cpu_to_le16 + (~IEEE80211_HT_CAP_SUP_WIDTH_20_40 ); + ht_cap->ht_cap.cap_info &= +cpu_to_le16 (~IEEE80211_HT_CAP_SGI_40 ); + } +break ; +case IEEE80211_HT_PARAM_CHA_SEC_BELOW : +if (chan->flags &IEEE80211_CHAN_NO_HT40MINUS ) { + ht_cap->ht_cap.cap_info &= +cpu_to_le16 + (~IEEE80211_HT_CAP_SUP_WIDTH_20_40 ); + ht_cap->ht_cap.cap_info &= +cpu_to_le16 (~IEEE80211_HT_CAP_SGI_40 ); + } +break ; + } + } + + *buffer +=sizeof (struct nxpwifi_ie_types_htcap ); + ret_len +=sizeof (struct nxpwifi_ie_types_htcap ); + } + +if (bss_desc->bcn_ht_oper) { + chan_list = + (struct nxpwifi_ie_types_chan_list_param_set *)*buffer; +memset (chan_list,0 ,struct_size (chan_list, chan_scan_param,1 )); + chan_list->header.type =cpu_to_le16 (TLV_TYPE_CHANLIST ); + chan_list->header.len = +cpu_to_le16 (sizeof (struct nxpwifi_chan_scan_param_set )); + chan_list->chan_scan_param[0 ].chan_number = + bss_desc->bcn_ht_oper->primary_chan; + chan_list->chan_scan_param[0 ].radio_type = +nxpwifi_band_to_radio_type ((u8 )bss_desc->bss_band); + +if (sband->ht_cap.cap &IEEE80211_HT_CAP_SUP_WIDTH_20_40 && + bss_desc->bcn_ht_oper->ht_param & +IEEE80211_HT_PARAM_CHAN_WIDTH_ANY ) +SET_SECONDARYCHAN + (chan_list->chan_scan_param[0 ].radio_type, + (bss_desc->bcn_ht_oper->ht_param & +IEEE80211_HT_PARAM_CHA_SEC_OFFSET )); + + *buffer +=struct_size (chan_list, chan_scan_param,1 ); + ret_len +=struct_size (chan_list, chan_scan_param,1 ); + } + +if (bss_desc->bcn_bss_co_2040) { + bss_co_2040 = (struct nxpwifi_ie_types_2040bssco *)*buffer; +memset (bss_co_2040,0 , +sizeof (struct nxpwifi_ie_types_2040bssco )); + bss_co_2040->header.type =cpu_to_le16 (WLAN_EID_BSS_COEX_2040 ); + bss_co_2040->header.len = +cpu_to_le16 (sizeof (bss_co_2040->bss_co_2040)); + +memcpy ((u8 *)bss_co_2040 + +sizeof (struct nxpwifi_ie_types_header ), + bss_desc->bcn_bss_co_2040 + +sizeof (struct element ), +le16_to_cpu (bss_co_2040->header.len)); + + *buffer +=sizeof (struct nxpwifi_ie_types_2040bssco ); + ret_len +=sizeof (struct nxpwifi_ie_types_2040bssco ); + } + +if (bss_desc->bcn_ext_cap) { + hdr = (void *)bss_desc->bcn_ext_cap; + ext_cap = (struct nxpwifi_ie_types_extcap *)*buffer; +memset (ext_cap,0 ,sizeof (struct nxpwifi_ie_types_extcap )); + ext_cap->header.type =cpu_to_le16 (WLAN_EID_EXT_CAPABILITY ); + ext_cap->header.len =cpu_to_le16 (hdr->datalen); + +memcpy ((u8 *)ext_cap->ext_capab, + bss_desc->bcn_ext_cap +sizeof (struct element ), +le16_to_cpu (ext_cap->header.len)); + +if (hdr->datalen >3 && + ext_cap->ext_capab[3 ] &WLAN_EXT_CAPA4_INTERWORKING_ENABLED ) + priv->hs2_enabled = true; +else + priv->hs2_enabled = false; + + *buffer +=sizeof (struct nxpwifi_ie_types_extcap ) + hdr->datalen; + ret_len +=sizeof (struct nxpwifi_ie_types_extcap ) + hdr->datalen; + } + +return ret_len; +} + +/* This function checks if the given pointer is valid entry of +* Tx BA Stream table. +*/ +static int +nxpwifi_is_tx_ba_stream_ptr_valid (struct nxpwifi_private *priv, +struct nxpwifi_tx_ba_stream_tbl *tx_tbl_ptr) +{ +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl; + +list_for_each_entry (tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { +if (tx_ba_tsr_tbl == tx_tbl_ptr) +return true; + } + +return false; +} + +/* This function deletes the given entry in Tx BA Stream table. +* +* The function also performs a validity check on the supplied +* pointer before trying to delete. +*/ +void +nxpwifi_11n_delete_tx_ba_stream_tbl_entry (struct nxpwifi_private *priv, +struct nxpwifi_tx_ba_stream_tbl *tbl) +{ +if (!tbl &&nxpwifi_is_tx_ba_stream_ptr_valid (priv, tbl)) +return ; + +nxpwifi_dbg (priv->adapter,INFO , +"info: tx_ba_tsr_tbl %p\n" , tbl); + +list_del (&tbl->list); + +kfree (tbl); +} + +/* This function deletes all the entries in Tx BA Stream table. +*/ +void nxpwifi_11n_delete_all_tx_ba_stream_tbl (struct nxpwifi_private *priv) +{ +int i; +struct nxpwifi_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry_safe (del_tbl_ptr, tmp_node, + &priv->tx_ba_stream_tbl_ptr, list) +nxpwifi_11n_delete_tx_ba_stream_tbl_entry (priv, del_tbl_ptr); +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); + +INIT_LIST_HEAD (&priv->tx_ba_stream_tbl_ptr); + +for (i =0 ; i <MAX_NUM_TID ; ++i) + priv->aggr_prio_tbl[i].ampdu_ap = + priv->aggr_prio_tbl[i].ampdu_user; +} + +/* This function returns the pointer to an entry in BA Stream +* table which matches the given RA/TID pair. +*/ +struct nxpwifi_tx_ba_stream_tbl * +nxpwifi_get_ba_tbl (struct nxpwifi_private *priv,int tid,u8 *ra) +{ +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry (tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { +if (ether_addr_equal_unaligned (tx_ba_tsr_tbl->ra, ra) && + tx_ba_tsr_tbl->tid == tid) { +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); +return tx_ba_tsr_tbl; + } + } +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); +return NULL ; +} + +/* This function creates an entry in Tx BA stream table for the +* given RA/TID pair. +*/ +void nxpwifi_create_ba_tbl (struct nxpwifi_private *priv,u8 *ra,int tid, +enum nxpwifi_ba_status ba_status) +{ +struct nxpwifi_tx_ba_stream_tbl *new_node; +struct nxpwifi_ra_list_tbl *ra_list; +int tid_down; + +if (!nxpwifi_get_ba_tbl (priv, tid, ra)) { + new_node =kzalloc (sizeof (*new_node),GFP_ATOMIC ); +if (!new_node) +return ; + + tid_down =nxpwifi_wmm_downgrade_tid (priv, tid); + ra_list =nxpwifi_wmm_get_ralist_node (priv, tid_down, ra); +if (ra_list) { + ra_list->ba_status = ba_status; + ra_list->amsdu_in_ampdu = false; + } +INIT_LIST_HEAD (&new_node->list); + + new_node->tid = tid; + new_node->ba_status = ba_status; +memcpy (new_node->ra, ra,ETH_ALEN ); + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_add_tail (&new_node->list, &priv->tx_ba_stream_tbl_ptr); +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); + } +} + +/* This function sends an add BA request to the given TID/RA pair. +*/ +int nxpwifi_send_addba (struct nxpwifi_private *priv,int tid,u8 *peer_mac) +{ +struct host_cmd_ds_11n_addba_req add_ba_req; +u32 tx_win_size = priv->add_ba_param.tx_win_size; +static u8 dialog_tok; +int ret; +u16 block_ack_param_set; + +nxpwifi_dbg (priv->adapter,CMD ,"cmd: %s: tid %d\n" , __func__, tid); + +memset (&add_ba_req,0 ,sizeof (add_ba_req)); + + block_ack_param_set = (u16)((tid <<BLOCKACKPARAM_TID_POS ) | + tx_win_size <<BLOCKACKPARAM_WINSIZE_POS | +IMMEDIATE_BLOCK_ACK ); + +/* enable AMSDU inside AMPDU */ +if (priv->add_ba_param.tx_amsdu && + priv->aggr_prio_tbl[tid].amsdu !=BA_STREAM_NOT_ALLOWED ) + block_ack_param_set |=BLOCKACKPARAM_AMSDU_SUPP_MASK ; + + add_ba_req.block_ack_param_set =cpu_to_le16 (block_ack_param_set); + add_ba_req.block_ack_tmo =cpu_to_le16 ((u16 )priv->add_ba_param.timeout); + + ++dialog_tok; + +if (dialog_tok ==0 ) + dialog_tok =1 ; + + add_ba_req.dialog_token = dialog_tok; +memcpy (&add_ba_req.peer_mac_addr, peer_mac,ETH_ALEN ); + +/* We don't wait for the response of this command */ + ret =nxpwifi_send_cmd (priv,HOST_CMD_11N_ADDBA_REQ , +0 ,0 , &add_ba_req, false); + +return ret; +} + +/* This function sends a delete BA request to the given TID/RA pair. +*/ +int nxpwifi_send_delba (struct nxpwifi_private *priv,int tid,u8 *peer_mac, +int initiator) +{ +struct host_cmd_ds_11n_delba delba; +int ret; +u16 del_ba_param_set; + +memset (&delba,0 ,sizeof (delba)); + + del_ba_param_set = tid <<DELBA_TID_POS ; + +if (initiator) + del_ba_param_set |=IEEE80211_DELBA_PARAM_INITIATOR_MASK ; +else + del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK ; + + delba.del_ba_param_set =cpu_to_le16 (del_ba_param_set); +memcpy (&delba.peer_mac_addr, peer_mac,ETH_ALEN ); + +/* We don't wait for the response of this command */ + ret =nxpwifi_send_cmd (priv,HOST_CMD_11N_DELBA , +HOST_ACT_GEN_SET ,0 , &delba, false); + +return ret; +} + +/* This function sends delba to specific tid +*/ +void nxpwifi_11n_delba (struct nxpwifi_private *priv,int tid) +{ +struct nxpwifi_rx_reorder_tbl *rx_reor_tbl_ptr; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry (rx_reor_tbl_ptr, &priv->rx_reorder_tbl_ptr, list) { +if (rx_reor_tbl_ptr->tid == tid) { +dev_dbg (priv->adapter->dev, +"Send delba to tid=%d, %pM\n" , + tid, rx_reor_tbl_ptr->ta); +nxpwifi_send_delba (priv, tid, rx_reor_tbl_ptr->ta,0 ); + goto exit; + } + } +exit: +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +} + +/* This function handles the command response of a delete BA request. +*/ +void nxpwifi_11n_delete_ba_stream (struct nxpwifi_private *priv,u8 *del_ba) +{ +struct host_cmd_ds_11n_delba *cmd_del_ba = + (struct host_cmd_ds_11n_delba *)del_ba; +u16 del_ba_param_set =le16_to_cpu (cmd_del_ba->del_ba_param_set); +int tid; + + tid = del_ba_param_set >>DELBA_TID_POS ; + +nxpwifi_del_ba_tbl (priv, tid, cmd_del_ba->peer_mac_addr, +TYPE_DELBA_RECEIVE ,INITIATOR_BIT (del_ba_param_set)); +} + +/* This function retrieves the Rx reordering table. +*/ +int nxpwifi_get_rx_reorder_tbl (struct nxpwifi_private *priv, +struct nxpwifi_ds_rx_reorder_tbl *buf) +{ +int i; +struct nxpwifi_ds_rx_reorder_tbl *rx_reo_tbl = buf; +struct nxpwifi_rx_reorder_tbl *rx_reorder_tbl_ptr; +int count =0 ; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry (rx_reorder_tbl_ptr, &priv->rx_reorder_tbl_ptr, + list) { + rx_reo_tbl->tid = (u16 )rx_reorder_tbl_ptr->tid; +memcpy (rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta,ETH_ALEN ); + rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win; + rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size; +for (i =0 ; i < rx_reorder_tbl_ptr->win_size; ++i) { +if (rx_reorder_tbl_ptr->rx_reorder_ptr[i]) + rx_reo_tbl->buffer[i] = true; +else + rx_reo_tbl->buffer[i] = false; + } + rx_reo_tbl++; + count++; + +if (count >=NXPWIFI_MAX_RX_BASTREAM_SUPPORTED ) +break ; + } +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +return count; +} + +/* This function retrieves the Tx BA stream table. +*/ +int nxpwifi_get_tx_ba_stream_tbl (struct nxpwifi_private *priv, +struct nxpwifi_ds_tx_ba_stream_tbl *buf) +{ +struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl; +struct nxpwifi_ds_tx_ba_stream_tbl *rx_reo_tbl = buf; +int count =0 ; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry (tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { + rx_reo_tbl->tid = (u16 )tx_ba_tsr_tbl->tid; +nxpwifi_dbg (priv->adapter,DATA ,"data: %s tid=%d\n" , + __func__, rx_reo_tbl->tid); +memcpy (rx_reo_tbl->ra, tx_ba_tsr_tbl->ra,ETH_ALEN ); + rx_reo_tbl->amsdu = tx_ba_tsr_tbl->amsdu; + rx_reo_tbl++; + count++; +if (count >=NXPWIFI_MAX_TX_BASTREAM_SUPPORTED ) +break ; + } +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); + +return count; +} + +/* This function retrieves the entry for specific tx BA stream table by RA and +* deletes it. +*/ +void nxpwifi_del_tx_ba_stream_tbl_by_ra (struct nxpwifi_private *priv,u8 *ra) +{ +struct nxpwifi_tx_ba_stream_tbl *tbl, *tmp; + +if (!ra) +return ; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry_safe (tbl, tmp, &priv->tx_ba_stream_tbl_ptr, list) +if (!memcmp (tbl->ra, ra,ETH_ALEN )) +nxpwifi_11n_delete_tx_ba_stream_tbl_entry (priv, tbl); +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); +} + +/* This function initializes the BlockACK setup information for given +* nxpwifi_private structure. +*/ +void nxpwifi_set_ba_params (struct nxpwifi_private *priv) +{ + priv->add_ba_param.timeout =NXPWIFI_DEFAULT_BLOCK_ACK_TIMEOUT ; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + priv->add_ba_param.tx_win_size = +NXPWIFI_UAP_AMPDU_DEF_TXWINSIZE ; + priv->add_ba_param.rx_win_size = +NXPWIFI_UAP_AMPDU_DEF_RXWINSIZE ; + }else { + priv->add_ba_param.tx_win_size = +NXPWIFI_STA_AMPDU_DEF_TXWINSIZE ; + priv->add_ba_param.rx_win_size = +NXPWIFI_STA_AMPDU_DEF_RXWINSIZE ; + } + + priv->add_ba_param.tx_amsdu = true; + priv->add_ba_param.rx_amsdu = true; +} + +u8 nxpwifi_get_sec_chan_offset (int chan) +{ +u8 sec_offset; + +switch (chan) { +case 36 : +case 44 : +case 52 : +case 60 : +case 100 : +case 108 : +case 116 : +case 124 : +case 132 : +case 140 : +case 149 : +case 157 : + sec_offset =IEEE80211_HT_PARAM_CHA_SEC_ABOVE ; +break ; +case 40 : +case 48 : +case 56 : +case 64 : +case 104 : +case 112 : +case 120 : +case 128 : +case 136 : +case 144 : +case 153 : +case 161 : + sec_offset =IEEE80211_HT_PARAM_CHA_SEC_BELOW ; +break ; +case 165 : +default : + sec_offset =IEEE80211_HT_PARAM_CHA_SEC_NONE ; +break ; + } + +return sec_offset; +} + +/* This function will send DELBA to entries in the priv's +* Tx BA stream table +*/ +static void +nxpwifi_send_delba_txbastream_tbl (struct nxpwifi_private *priv,u8 tid) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_tx_ba_stream_tbl *tx_ba_stream_tbl_ptr; + +list_for_each_entry (tx_ba_stream_tbl_ptr, + &priv->tx_ba_stream_tbl_ptr, list) { +if (tx_ba_stream_tbl_ptr->ba_status ==BA_SETUP_COMPLETE ) { +if (tid == tx_ba_stream_tbl_ptr->tid) { +dev_dbg (adapter->dev, +"Tx:Send delba to tid=%d, %pM\n" , tid, + tx_ba_stream_tbl_ptr->ra); +nxpwifi_send_delba (priv, + tx_ba_stream_tbl_ptr->tid, + tx_ba_stream_tbl_ptr->ra,1 ); +return ; + } + } + } +} + +/* This function updates all the tx_win_size +*/ +void nxpwifi_update_ampdu_txwinsize (struct nxpwifi_adapter *adapter) +{ +u8 i, j; +u32 tx_win_size; +struct nxpwifi_private *priv; + +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i]) +continue ; + priv = adapter->priv[i]; + tx_win_size = priv->add_ba_param.tx_win_size; + +if (priv->bss_type ==NXPWIFI_BSS_TYPE_STA ) + priv->add_ba_param.tx_win_size = +NXPWIFI_STA_AMPDU_DEF_TXWINSIZE ; + +if (priv->bss_type ==NXPWIFI_BSS_TYPE_UAP ) + priv->add_ba_param.tx_win_size = +NXPWIFI_UAP_AMPDU_DEF_TXWINSIZE ; + +if (adapter->coex_win_size) { +if (adapter->coex_tx_win_size) + priv->add_ba_param.tx_win_size = + adapter->coex_tx_win_size; + } + +if (tx_win_size != priv->add_ba_param.tx_win_size) { +if (!priv->media_connected) +continue ; +for (j =0 ; j <MAX_NUM_TID ; j++) +nxpwifi_send_delba_txbastream_tbl (priv, j); + } + } +}
Signature · 1 line
2.34.1
PATCH v2 7/43 wifi: nxpwifi: add 11n.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/11n.h | 163 +++++++++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.h
drivers/net/wireless/nxp/nxpwifi/11n.h new file +163 -0
@@ -0,0 +1,163 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: 802.11n +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_11N_H_ +#define _NXPWIFI_11N_H_ + +#include "11n_aggr.h" +#include "11n_rxreorder.h" +#include "wmm.h" + +int nxpwifi_ret_11n_delba (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +int nxpwifi_ret_11n_addba_req (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp); +int nxpwifi_cmd_11n_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd,u16 cmd_action, +struct nxpwifi_ds_11n_tx_cfg *txcfg); +int nxpwifi_cmd_append_11n_tlv (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc, +u8 **buffer); +int nxpwifi_fill_cap_info (struct nxpwifi_private *priv,u8 radio_type, +struct ieee80211_ht_cap *ht_cap); +int nxpwifi_set_get_11n_htcap_cfg (struct nxpwifi_private *priv, +u16 action,int *htcap_cfg); +void nxpwifi_11n_delete_tx_ba_stream_tbl_entry (struct nxpwifi_private *priv, +struct nxpwifi_tx_ba_stream_tbl + *tx_tbl); +void nxpwifi_11n_delete_all_tx_ba_stream_tbl (struct nxpwifi_private *priv); +struct nxpwifi_tx_ba_stream_tbl *nxpwifi_get_ba_tbl (struct nxpwifi_private + *priv,int tid,u8 *ra); +void nxpwifi_create_ba_tbl (struct nxpwifi_private *priv,u8 *ra,int tid, +enum nxpwifi_ba_status ba_status); +int nxpwifi_send_addba (struct nxpwifi_private *priv,int tid,u8 *peer_mac); +int nxpwifi_send_delba (struct nxpwifi_private *priv,int tid,u8 *peer_mac, +int initiator); +void nxpwifi_11n_delete_ba_stream (struct nxpwifi_private *priv,u8 *del_ba); +int nxpwifi_get_rx_reorder_tbl (struct nxpwifi_private *priv, +struct nxpwifi_ds_rx_reorder_tbl *buf); +int nxpwifi_get_tx_ba_stream_tbl (struct nxpwifi_private *priv, +struct nxpwifi_ds_tx_ba_stream_tbl *buf); +int nxpwifi_cmd_recfg_tx_buf (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +int cmd_action,u16 *buf_size); +int nxpwifi_cmd_amsdu_aggr_ctrl (struct host_cmd_ds_command *cmd, +int cmd_action, +struct nxpwifi_ds_11n_amsdu_aggr_ctrl *aa_ctrl); +void nxpwifi_del_tx_ba_stream_tbl_by_ra (struct nxpwifi_private *priv,u8 *ra); +u8 nxpwifi_get_sec_chan_offset (int chan); + +static inline u8 +nxpwifi_is_station_ampdu_allowed (struct nxpwifi_private *priv, +struct nxpwifi_ra_list_tbl *ptr,int tid) +{ +struct nxpwifi_sta_node *node =nxpwifi_get_sta_entry (priv, ptr->ra); + +if (unlikely (!node)) +return false; + +return (node->ampdu_sta[tid] !=BA_STREAM_NOT_ALLOWED ) ? true : false; +} + +/* This function checks whether AMPDU is allowed or not for a particular TID. */ +static inline u8 +nxpwifi_is_ampdu_allowed (struct nxpwifi_private *priv, +struct nxpwifi_ra_list_tbl *ptr,int tid) +{ +u8 ret; + +if (is_broadcast_ether_addr (ptr->ra)) +return false; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) + ret =nxpwifi_is_station_ampdu_allowed (priv, ptr, tid); +else + ret = (priv->aggr_prio_tbl[tid].ampdu_ap != +BA_STREAM_NOT_ALLOWED ) ? true : false; + +return ret; +} + +/* This function checks whether AMSDU is allowed or not for a particular TID. +*/ +static inline u8 +nxpwifi_is_amsdu_allowed (struct nxpwifi_private *priv,int tid) +{ +return (((priv->aggr_prio_tbl[tid].amsdu !=BA_STREAM_NOT_ALLOWED ) && + (priv->is_data_rate_auto || !(priv->bitmap_rates[2 ] &0x03 ))) + ? true : false); +} + +/* This function checks whether a space is available for new BA stream or not. +*/ +static inline u8 +nxpwifi_space_avail_for_new_ba_stream (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +u8 i; +size_t ba_stream_num =0 , ba_stream_max; + + ba_stream_max =NXPWIFI_MAX_TX_BASTREAM_SUPPORTED ; + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv) + ba_stream_num += +list_count_nodes (&priv->tx_ba_stream_tbl_ptr); + } + +if (adapter->fw_api_ver ==NXPWIFI_FW_V15 ) { + ba_stream_max = +GETSUPP_TXBASTREAMS (adapter->hw_dot_11n_dev_cap); +if (!ba_stream_max) + ba_stream_max =NXPWIFI_MAX_TX_BASTREAM_SUPPORTED ; + } + +return ((ba_stream_num < ba_stream_max) ? true : false); +} + +/* This function finds the correct Tx BA stream to delete. +* +* Upon successfully locating, both the TID and the RA are returned. +*/ +static inline u8 +nxpwifi_find_stream_to_delete (struct nxpwifi_private *priv,int ptr_tid, +int *ptid,u8 *ra) +{ +int tid; +u8 ret = false; +struct nxpwifi_tx_ba_stream_tbl *tx_tbl; + + tid = priv->aggr_prio_tbl[ptr_tid].ampdu_user; + +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +list_for_each_entry (tx_tbl, &priv->tx_ba_stream_tbl_ptr, list) { +if (tid > priv->aggr_prio_tbl[tx_tbl->tid].ampdu_user) { + tid = priv->aggr_prio_tbl[tx_tbl->tid].ampdu_user; + *ptid = tx_tbl->tid; +memcpy (ra, tx_tbl->ra,ETH_ALEN ); + ret = true; + } + } +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); + +return ret; +} + +/* This function checks whether associated station is 11n enabled +*/ +static inline int nxpwifi_is_sta_11n_enabled (struct nxpwifi_private *priv, +struct nxpwifi_sta_node *node) +{ +if (!node || (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP && + !priv->ap_11n_enabled)) +return 0 ; + +return node->is_11n_enabled; +} + +#endif /* !_NXPWIFI_11N_H_ */
Signature · 1 line
2.34.1
PATCH v2 8/43 wifi: nxpwifi: add 11n_rxreorder.c
In reply to David Lin--- .../net/wireless/nxp/nxpwifi/11n_rxreorder.c | 917 ++++++++++++++++++ 1 file changed, 917 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c
drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c new file +917 -0
@@ -0,0 +1,917 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: 802.11n RX Re-ordering +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" +#include "11n_rxreorder.h" + +/* This function will dispatch amsdu packet and forward it to kernel/upper +* layer. +*/ +static int nxpwifi_11n_dispatch_amsdu_pkt (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct rxpd *local_rx_pd = (struct rxpd *)(skb->data); +int ret; + +if (le16_to_cpu (local_rx_pd->rx_pkt_type) ==PKT_TYPE_AMSDU ) { +struct sk_buff_head list; +struct sk_buff *rx_skb; + +__skb_queue_head_init (&list); + +skb_pull (skb,le16_to_cpu (local_rx_pd->rx_pkt_offset)); +skb_trim (skb,le16_to_cpu (local_rx_pd->rx_pkt_length)); + +ieee80211_amsdu_to_8023s (skb, &list, priv->curr_addr, + priv->wdev.iftype,0 ,NULL ,NULL , false); + +while (!skb_queue_empty (&list)) { + rx_skb =__skb_dequeue (&list); + +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) + ret =nxpwifi_uap_recv_packet (priv, rx_skb); +else + ret =nxpwifi_recv_packet (priv, rx_skb); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"Rx of A-MSDU failed" ); + } +return 0 ; + } + +return -EINVAL ; +} + +/* This function will process the rx packet and forward it to kernel/upper +* layer. +*/ +static int nxpwifi_11n_dispatch_pkt (struct nxpwifi_private *priv, +struct sk_buff *payload) +{ +int ret; + +if (!payload) { +nxpwifi_dbg (priv->adapter,INFO ,"info: fw drop data\n" ); +return 0 ; + } + + ret =nxpwifi_11n_dispatch_amsdu_pkt (priv, payload); +if (!ret) +return 0 ; + +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) +return nxpwifi_handle_uap_rx_forward (priv, payload); + +return nxpwifi_process_rx_packet (priv, payload); +} + +/* This function dispatches all packets in the Rx reorder table until the +* start window. +* +* There could be holes in the buffer, which are skipped by the function. +* Since the buffer is linear, the function uses rotation to simulate +* circular buffer. +*/ +static void +nxpwifi_11n_dispatch_pkt_until_start_win (struct nxpwifi_private *priv, +struct nxpwifi_rx_reorder_tbl *tbl, +int start_win) +{ +struct sk_buff_head list; +struct sk_buff *skb; +int pkt_to_send, i; + +__skb_queue_head_init (&list); +spin_lock_bh (&priv->rx_reorder_tbl_lock); + + pkt_to_send = (start_win > tbl->start_win) ? +min ((start_win - tbl->start_win), tbl->win_size) : + tbl->win_size; + +for (i =0 ; i < pkt_to_send; ++i) { +if (tbl->rx_reorder_ptr[i]) { + skb = tbl->rx_reorder_ptr[i]; +__skb_queue_tail (&list, skb); + tbl->rx_reorder_ptr[i] =NULL ; + } + } + +/* We don't have a circular buffer, hence use rotation to simulate +* circular buffer +*/ +for (i =0 ; i < tbl->win_size - pkt_to_send; ++i) { + tbl->rx_reorder_ptr[i] = tbl->rx_reorder_ptr[pkt_to_send + i]; + tbl->rx_reorder_ptr[pkt_to_send + i] =NULL ; + } + + tbl->start_win = start_win; +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +while ((skb =__skb_dequeue (&list))) +nxpwifi_11n_dispatch_pkt (priv, skb); +} + +/* This function dispatches all packets in the Rx reorder table until +* a hole is found. +* +* The start window is adjusted automatically when a hole is located. +* Since the buffer is linear, the function uses rotation to simulate +* circular buffer. +*/ +static void +nxpwifi_11n_scan_and_dispatch (struct nxpwifi_private *priv, +struct nxpwifi_rx_reorder_tbl *tbl) +{ +struct sk_buff_head list; +struct sk_buff *skb; +int i, j, xchg; + +__skb_queue_head_init (&list); +spin_lock_bh (&priv->rx_reorder_tbl_lock); + +for (i =0 ; i < tbl->win_size; ++i) { +if (!tbl->rx_reorder_ptr[i]) +break ; + skb = tbl->rx_reorder_ptr[i]; +__skb_queue_tail (&list, skb); + tbl->rx_reorder_ptr[i] =NULL ; + } + +/* We don't have a circular buffer, hence use rotation to simulate +* circular buffer +*/ +if (i >0 ) { + xchg = tbl->win_size - i; +for (j =0 ; j < xchg; ++j) { + tbl->rx_reorder_ptr[j] = tbl->rx_reorder_ptr[i + j]; + tbl->rx_reorder_ptr[i + j] =NULL ; + } + } + tbl->start_win = (tbl->start_win + i) & (MAX_TID_VALUE -1 ); + +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +while ((skb =__skb_dequeue (&list))) +nxpwifi_11n_dispatch_pkt (priv, skb); +} + +/* This function deletes the Rx reorder table and frees the memory. +* +* The function stops the associated timer and dispatches all the +* pending packets in the Rx reorder table before deletion. +*/ +static void +nxpwifi_del_rx_reorder_entry (struct nxpwifi_private *priv, +struct nxpwifi_rx_reorder_tbl *tbl) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int start_win; + +if (!tbl) +return ; + +tasklet_disable (&adapter->rx_task); + + start_win = (tbl->start_win + tbl->win_size) & (MAX_TID_VALUE -1 ); +nxpwifi_11n_dispatch_pkt_until_start_win (priv, tbl, start_win); + +del_timer_sync (&tbl->timer_context.timer); + tbl->timer_context.timer_is_set = false; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_del (&tbl->list); +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +kfree (tbl->rx_reorder_ptr); +kfree (tbl); + +tasklet_enable (&adapter->rx_task); +} + +/* This function returns the pointer to an entry in Rx reordering +* table which matches the given TA/TID pair. +*/ +struct nxpwifi_rx_reorder_tbl * +nxpwifi_11n_get_rx_reorder_tbl (struct nxpwifi_private *priv,int tid,u8 *ta) +{ +struct nxpwifi_rx_reorder_tbl *tbl; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry (tbl, &priv->rx_reorder_tbl_ptr, list) { +if (!memcmp (tbl->ta, ta,ETH_ALEN ) && tbl->tid == tid) { +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +return tbl; + } + } +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +return NULL ; +} + +/* This function retrieves the pointer to an entry in Rx reordering +* table which matches the given TA and deletes it. +*/ +void nxpwifi_11n_del_rx_reorder_tbl_by_ta (struct nxpwifi_private *priv,u8 *ta) +{ +struct nxpwifi_rx_reorder_tbl *tbl, *tmp; + +if (!ta) +return ; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry_safe (tbl, tmp, &priv->rx_reorder_tbl_ptr, list) { +if (!memcmp (tbl->ta, ta,ETH_ALEN )) { +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +nxpwifi_del_rx_reorder_entry (priv, tbl); +spin_lock_bh (&priv->rx_reorder_tbl_lock); + } + } +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +} + +/* This function finds the last sequence number used in the packets +* buffered in Rx reordering table. +*/ +static int +nxpwifi_11n_find_last_seq_num (struct reorder_tmr_cnxt *ctx) +{ +struct nxpwifi_rx_reorder_tbl *rx_reorder_tbl_ptr = ctx->ptr; +struct nxpwifi_private *priv = ctx->priv; +int i; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +for (i = rx_reorder_tbl_ptr->win_size -1 ; i >=0 ; --i) { +if (rx_reorder_tbl_ptr->rx_reorder_ptr[i]) { +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +return i; + } + } +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +return -EINVAL ; +} + +/* This function flushes all the packets in Rx reordering table. +* +* The function checks if any packets are currently buffered in the +* table or not. In case there are packets available, it dispatches +* them and then dumps the Rx reordering table. +*/ +static void +nxpwifi_flush_data (struct timer_list *t) +{ +struct reorder_tmr_cnxt *ctx = +from_timer (ctx, t, timer); +int start_win, seq_num; + + ctx->timer_is_set = false; + seq_num =nxpwifi_11n_find_last_seq_num (ctx); + +if (seq_num <0 ) +return ; + +nxpwifi_dbg (ctx->priv->adapter,INFO ,"info: flush data %d\n" , seq_num); + start_win = (ctx->ptr->start_win + seq_num +1 ) & (MAX_TID_VALUE -1 ); +nxpwifi_11n_dispatch_pkt_until_start_win (ctx->priv, ctx->ptr, + start_win); +} + +/* This function creates an entry in Rx reordering table for the +* given TA/TID. +* +* The function also initializes the entry with sequence number, window +* size as well as initializes the timer. +* +* If the received TA/TID pair is already present, all the packets are +* dispatched and the window size is moved until the SSN. +*/ +static void +nxpwifi_11n_create_rx_reorder_tbl (struct nxpwifi_private *priv,u8 *ta, +int tid,int win_size,int seq_num) +{ +int i; +struct nxpwifi_rx_reorder_tbl *tbl, *new_node; +u16 last_seq =0 ; +struct nxpwifi_sta_node *node; + +/* If we get a TID, ta pair which is already present dispatch all +* the packets and move the window size until the ssn +*/ + tbl =nxpwifi_11n_get_rx_reorder_tbl (priv, tid, ta); +if (tbl) { +nxpwifi_11n_dispatch_pkt_until_start_win (priv, tbl, seq_num); +return ; + } +/* if !tbl then create one */ + new_node =kzalloc (sizeof (*new_node),GFP_KERNEL ); +if (!new_node) +return ; + +INIT_LIST_HEAD (&new_node->list); + new_node->tid = tid; +memcpy (new_node->ta, ta,ETH_ALEN ); + new_node->start_win = seq_num; + new_node->init_win = seq_num; + new_node->flags =0 ; + +spin_lock_bh (&priv->sta_list_spinlock); +if (nxpwifi_queuing_ra_based (priv)) { +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) { + node =nxpwifi_get_sta_entry (priv, ta); +if (node) + last_seq = node->rx_seq[tid]; + } + }else { + node =nxpwifi_get_sta_entry (priv, ta); +if (node) + last_seq = node->rx_seq[tid]; +else + last_seq = priv->rx_seq[tid]; + } +spin_unlock_bh (&priv->sta_list_spinlock); + +nxpwifi_dbg (priv->adapter,INFO , +"info: last_seq=%d start_win=%d\n" , + last_seq, new_node->start_win); + +if (last_seq !=NXPWIFI_DEF_11N_RX_SEQ_NUM && + last_seq >= new_node->start_win) { + new_node->start_win = last_seq +1 ; + new_node->flags |=RXREOR_INIT_WINDOW_SHIFT ; + } + + new_node->win_size = win_size; + + new_node->rx_reorder_ptr =kcalloc (win_size,sizeof (void *), +GFP_KERNEL ); +if (!new_node->rx_reorder_ptr) { +kfree (new_node); +nxpwifi_dbg (priv->adapter,ERROR , +"%s: failed to alloc reorder_ptr\n" , __func__); +return ; + } + + new_node->timer_context.ptr = new_node; + new_node->timer_context.priv = priv; + new_node->timer_context.timer_is_set = false; + +timer_setup (&new_node->timer_context.timer, nxpwifi_flush_data,0 ); + +for (i =0 ; i < win_size; ++i) + new_node->rx_reorder_ptr[i] =NULL ; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_add_tail (&new_node->list, &priv->rx_reorder_tbl_ptr); +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +} + +static void +nxpwifi_11n_rxreorder_timer_restart (struct nxpwifi_rx_reorder_tbl *tbl) +{ +u32 min_flush_time; + +if (tbl->win_size >=NXPWIFI_BA_WIN_SIZE_32 ) + min_flush_time =MIN_FLUSH_TIMER_15_MS ; +else + min_flush_time =MIN_FLUSH_TIMER_MS ; + +mod_timer (&tbl->timer_context.timer, + jiffies +msecs_to_jiffies (min_flush_time * tbl->win_size)); + + tbl->timer_context.timer_is_set = true; +} + +/* This function prepares command for adding a BA request. +* +* Preparation includes - +* - Setting command ID and proper size +* - Setting add BA request buffer +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_11n_addba_req (struct host_cmd_ds_command *cmd,void *data_buf) +{ +struct host_cmd_ds_11n_addba_req *add_ba_req = &cmd->params.add_ba_req; + + cmd->command =cpu_to_le16 (HOST_CMD_11N_ADDBA_REQ ); + cmd->size =cpu_to_le16 (sizeof (*add_ba_req) +S_DS_GEN ); +memcpy (add_ba_req, data_buf,sizeof (*add_ba_req)); + +return 0 ; +} + +/* This function prepares command for adding a BA response. +* +* Preparation includes - +* - Setting command ID and proper size +* - Setting add BA response buffer +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_11n_addba_rsp_gen (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +struct host_cmd_ds_11n_addba_req + *cmd_addba_req) +{ +struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &cmd->params.add_ba_rsp; +u32 rx_win_size = priv->add_ba_param.rx_win_size; +u8 tid; +int win_size; +u16 block_ack_param_set; + + cmd->command =cpu_to_le16 (HOST_CMD_11N_ADDBA_RSP ); + cmd->size =cpu_to_le16 (sizeof (*add_ba_rsp) +S_DS_GEN ); + +memcpy (add_ba_rsp->peer_mac_addr, cmd_addba_req->peer_mac_addr, +ETH_ALEN ); + add_ba_rsp->dialog_token = cmd_addba_req->dialog_token; + add_ba_rsp->block_ack_tmo = cmd_addba_req->block_ack_tmo; + add_ba_rsp->ssn = cmd_addba_req->ssn; + + block_ack_param_set =le16_to_cpu (cmd_addba_req->block_ack_param_set); + tid = (block_ack_param_set &IEEE80211_ADDBA_PARAM_TID_MASK ) + >>BLOCKACKPARAM_TID_POS ; + add_ba_rsp->status_code =cpu_to_le16 (ADDBA_RSP_STATUS_ACCEPT ); + block_ack_param_set &= ~IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK ; + +/* If we don't support AMSDU inside AMPDU, reset the bit */ +if (!priv->add_ba_param.rx_amsdu || + priv->aggr_prio_tbl[tid].amsdu ==BA_STREAM_NOT_ALLOWED ) + block_ack_param_set &= ~BLOCKACKPARAM_AMSDU_SUPP_MASK ; + block_ack_param_set |= rx_win_size <<BLOCKACKPARAM_WINSIZE_POS ; + add_ba_rsp->block_ack_param_set =cpu_to_le16 (block_ack_param_set); + win_size = (le16_to_cpu (add_ba_rsp->block_ack_param_set) + &IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK ) + >>BLOCKACKPARAM_WINSIZE_POS ; + cmd_addba_req->block_ack_param_set =cpu_to_le16 (block_ack_param_set); + +nxpwifi_11n_create_rx_reorder_tbl (priv, cmd_addba_req->peer_mac_addr, + tid, win_size, +le16_to_cpu (cmd_addba_req->ssn)); +return 0 ; +} + +/* This function prepares command for deleting a BA request. +* +* Preparation includes - +* - Setting command ID and proper size +* - Setting del BA request buffer +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_11n_delba (struct host_cmd_ds_command *cmd,void *data_buf) +{ +struct host_cmd_ds_11n_delba *del_ba = &cmd->params.del_ba; + + cmd->command =cpu_to_le16 (HOST_CMD_11N_DELBA ); + cmd->size =cpu_to_le16 (sizeof (*del_ba) +S_DS_GEN ); +memcpy (del_ba, data_buf,sizeof (*del_ba)); + +return 0 ; +} + +/* This function identifies if Rx reordering is needed for a received packet. +* +* In case reordering is required, the function will do the reordering +* before sending it to kernel. +* +* The Rx reorder table is checked first with the received TID/TA pair. If +* not found, the received packet is dispatched immediately. But if found, +* the packet is reordered and all the packets in the updated Rx reordering +* table is dispatched until a hole is found. +* +* For sequence number less than the starting window, the packet is dropped. +*/ +int nxpwifi_11n_rx_reorder_pkt (struct nxpwifi_private *priv, +u16 seq_num,u16 tid, +u8 *ta,u8 pkt_type,void *payload) +{ +struct nxpwifi_rx_reorder_tbl *tbl; +int prev_start_win, start_win, end_win, win_size; +u16 pkt_index; +bool init_window_shift = false; +int ret =0 ; + + tbl =nxpwifi_11n_get_rx_reorder_tbl (priv, tid, ta); +if (!tbl) { +if (pkt_type !=PKT_TYPE_BAR ) +nxpwifi_11n_dispatch_pkt (priv, payload); +return ret; + } + +if (pkt_type ==PKT_TYPE_AMSDU && !tbl->amsdu) { +nxpwifi_11n_dispatch_pkt (priv, payload); +return ret; + } + + start_win = tbl->start_win; + prev_start_win = start_win; + win_size = tbl->win_size; + end_win = ((start_win + win_size) -1 ) & (MAX_TID_VALUE -1 ); +if (tbl->flags &RXREOR_INIT_WINDOW_SHIFT ) { + init_window_shift = true; + tbl->flags &= ~RXREOR_INIT_WINDOW_SHIFT ; + } + +if (tbl->flags &RXREOR_FORCE_NO_DROP ) { +nxpwifi_dbg (priv->adapter,INFO , +"RXREOR_FORCE_NO_DROP when HS is activated\n" ); + tbl->flags &= ~RXREOR_FORCE_NO_DROP ; + }else if (init_window_shift && seq_num < start_win && + seq_num >= tbl->init_win) { +nxpwifi_dbg (priv->adapter,INFO , +"Sender TID sequence number reset %d->%d for SSN %d\n" , + start_win, seq_num, tbl->init_win); + start_win = seq_num; + tbl->start_win = start_win; + end_win = ((start_win + win_size) -1 ) & (MAX_TID_VALUE -1 ); + }else { +/* If seq_num is less then starting win then ignore and drop +* the packet +*/ +if ((start_win +TWOPOW11 ) > (MAX_TID_VALUE -1 )) { +if (seq_num >= ((start_win +TWOPOW11 ) & + (MAX_TID_VALUE -1 )) && + seq_num < start_win) { + ret = -EINVAL ; + goto done; + } + }else if ((seq_num < start_win) || + (seq_num >= (start_win +TWOPOW11 ))) { + ret = -EINVAL ; + goto done; + } + } + +/* If this packet is a BAR we adjust seq_num as +* WinStart = seq_num +*/ +if (pkt_type ==PKT_TYPE_BAR ) + seq_num = ((seq_num + win_size) -1 ) & (MAX_TID_VALUE -1 ); + +if ((end_win < start_win && + seq_num < start_win && seq_num > end_win) || + (end_win > start_win && (seq_num > end_win || + seq_num < start_win))) { + end_win = seq_num; +if (((end_win - win_size) +1 ) >=0 ) + start_win = (end_win - win_size) +1 ; +else + start_win = (MAX_TID_VALUE - (win_size - end_win)) +1 ; +nxpwifi_11n_dispatch_pkt_until_start_win (priv, tbl, start_win); + } + +if (pkt_type !=PKT_TYPE_BAR ) { +if (seq_num >= start_win) + pkt_index = seq_num - start_win; +else + pkt_index = (seq_num +MAX_TID_VALUE ) - start_win; + +if (tbl->rx_reorder_ptr[pkt_index]) { + ret = -EINVAL ; + goto done; + } + + tbl->rx_reorder_ptr[pkt_index] = payload; + } + +/* Dispatch all packets sequentially from start_win until a +* hole is found and adjust the start_win appropriately +*/ +nxpwifi_11n_scan_and_dispatch (priv, tbl); + +done: +if (!tbl->timer_context.timer_is_set || + prev_start_win != tbl->start_win) +nxpwifi_11n_rxreorder_timer_restart (tbl); +return ret; +} + +/* This function deletes an entry for a given TID/TA pair. +* +* The TID/TA are taken from del BA event body. +*/ +void +nxpwifi_del_ba_tbl (struct nxpwifi_private *priv,int tid,u8 *peer_mac, +u8 type,int initiator) +{ +struct nxpwifi_rx_reorder_tbl *tbl; +struct nxpwifi_tx_ba_stream_tbl *ptx_tbl; +struct nxpwifi_ra_list_tbl *ra_list; +u8 cleanup_rx_reorder_tbl; +int tid_down; + +if (type ==TYPE_DELBA_RECEIVE ) + cleanup_rx_reorder_tbl = (initiator) ? true : false; +else + cleanup_rx_reorder_tbl = (initiator) ? false : true; + +nxpwifi_dbg (priv->adapter,EVENT ,"event: DELBA: %pM tid=%d initiator=%d\n" , + peer_mac, tid, initiator); + +if (cleanup_rx_reorder_tbl) { + tbl =nxpwifi_11n_get_rx_reorder_tbl (priv, tid, peer_mac); +if (!tbl) { +nxpwifi_dbg (priv->adapter,EVENT , +"event: TID, TA not found in table\n" ); +return ; + } +nxpwifi_del_rx_reorder_entry (priv, tbl); + }else { + ptx_tbl =nxpwifi_get_ba_tbl (priv, tid, peer_mac); +if (!ptx_tbl) { +nxpwifi_dbg (priv->adapter,EVENT , +"event: TID, RA not found in table\n" ); +return ; + } + + tid_down =nxpwifi_wmm_downgrade_tid (priv, tid); + ra_list =nxpwifi_wmm_get_ralist_node (priv, tid_down, peer_mac); +if (ra_list) { + ra_list->amsdu_in_ampdu = false; + ra_list->ba_status =BA_SETUP_NONE ; + } +spin_lock_bh (&priv->tx_ba_stream_tbl_lock); +nxpwifi_11n_delete_tx_ba_stream_tbl_entry (priv, ptx_tbl); +spin_unlock_bh (&priv->tx_ba_stream_tbl_lock); + } +} + +/* This function handles the command response of an add BA response. +* +* Handling includes changing the header fields into CPU format and +* creating the stream, provided the add BA is accepted. +*/ +int nxpwifi_ret_11n_addba_resp (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &resp->params.add_ba_rsp; +int tid, win_size; +struct nxpwifi_rx_reorder_tbl *tbl; +u16 block_ack_param_set; + + block_ack_param_set =le16_to_cpu (add_ba_rsp->block_ack_param_set); + + tid = (block_ack_param_set &IEEE80211_ADDBA_PARAM_TID_MASK ) + >>BLOCKACKPARAM_TID_POS ; +/* Check if we had rejected the ADDBA, if yes then do not create +* the stream +*/ +if (le16_to_cpu (add_ba_rsp->status_code) !=BA_RESULT_SUCCESS ) { +nxpwifi_dbg (priv->adapter,ERROR ,"ADDBA RSP: failed %pM tid=%d)\n" , + add_ba_rsp->peer_mac_addr, tid); + + tbl =nxpwifi_11n_get_rx_reorder_tbl (priv, tid, + add_ba_rsp->peer_mac_addr); +if (tbl) +nxpwifi_del_rx_reorder_entry (priv, tbl); + +return 0 ; + } + + win_size = (block_ack_param_set &IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK ) + >>BLOCKACKPARAM_WINSIZE_POS ; + + tbl =nxpwifi_11n_get_rx_reorder_tbl (priv, tid, + add_ba_rsp->peer_mac_addr); +if (tbl) { +if ((block_ack_param_set &BLOCKACKPARAM_AMSDU_SUPP_MASK ) && + priv->add_ba_param.rx_amsdu && + priv->aggr_prio_tbl[tid].amsdu !=BA_STREAM_NOT_ALLOWED ) + tbl->amsdu = true; +else + tbl->amsdu = false; + } + +nxpwifi_dbg (priv->adapter,CMD , +"cmd: ADDBA RSP: %pM tid=%d ssn=%d win_size=%d\n" , + add_ba_rsp->peer_mac_addr, tid, add_ba_rsp->ssn, win_size); + +return 0 ; +} + +/* This function handles BA stream timeout event by preparing and sending +* a command to the firmware. +*/ +void nxpwifi_11n_ba_stream_timeout (struct nxpwifi_private *priv, +struct host_cmd_ds_11n_batimeout *event) +{ +struct host_cmd_ds_11n_delba delba; + +memset (&delba,0 ,sizeof (struct host_cmd_ds_11n_delba )); +memcpy (delba.peer_mac_addr, event->peer_mac_addr,ETH_ALEN ); + + delba.del_ba_param_set |= +cpu_to_le16 ((u16 )event->tid <<DELBA_TID_POS ); + delba.del_ba_param_set |= +cpu_to_le16 ((u16 )event->origninator <<DELBA_INITIATOR_POS ); + delba.reason_code =cpu_to_le16 (WLAN_REASON_QSTA_TIMEOUT ); +nxpwifi_send_cmd (priv,HOST_CMD_11N_DELBA ,0 ,0 , &delba, false); +} + +/* This function cleans up the Rx reorder table by deleting all the entries +* and re-initializing. +*/ +void nxpwifi_11n_cleanup_reorder_tbl (struct nxpwifi_private *priv) +{ +struct nxpwifi_rx_reorder_tbl *del_tbl_ptr, *tmp_node; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry_safe (del_tbl_ptr, tmp_node, + &priv->rx_reorder_tbl_ptr, list) { +spin_unlock_bh (&priv->rx_reorder_tbl_lock); +nxpwifi_del_rx_reorder_entry (priv, del_tbl_ptr); +spin_lock_bh (&priv->rx_reorder_tbl_lock); + } +INIT_LIST_HEAD (&priv->rx_reorder_tbl_ptr); +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + +nxpwifi_reset_11n_rx_seq_num (priv); +} + +/* This function updates all rx_reorder_tbl's flags. +*/ +void nxpwifi_update_rxreor_flags (struct nxpwifi_adapter *adapter,u8 flags) +{ +struct nxpwifi_private *priv; +struct nxpwifi_rx_reorder_tbl *tbl; +int i; + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (!priv) +continue ; + +spin_lock_bh (&priv->rx_reorder_tbl_lock); +list_for_each_entry (tbl, &priv->rx_reorder_tbl_ptr, list) + tbl->flags = flags; +spin_unlock_bh (&priv->rx_reorder_tbl_lock); + } +} + +/* This function update all the rx_win_size based on coex flag +*/ +static void nxpwifi_update_ampdu_rxwinsize (struct nxpwifi_adapter *adapter, +bool coex_flag) +{ +u8 i; +u32 rx_win_size; +struct nxpwifi_private *priv; + +dev_dbg (adapter->dev,"Update rxwinsize %d\n" , coex_flag); + +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i]) +continue ; + priv = adapter->priv[i]; + rx_win_size = priv->add_ba_param.rx_win_size; +if (coex_flag) { +if (priv->bss_type ==NXPWIFI_BSS_TYPE_STA ) + priv->add_ba_param.rx_win_size = +NXPWIFI_STA_COEX_AMPDU_DEF_RXWINSIZE ; +if (priv->bss_type ==NXPWIFI_BSS_TYPE_UAP ) + priv->add_ba_param.rx_win_size = +NXPWIFI_UAP_COEX_AMPDU_DEF_RXWINSIZE ; + }else { +if (priv->bss_type ==NXPWIFI_BSS_TYPE_STA ) + priv->add_ba_param.rx_win_size = +NXPWIFI_STA_AMPDU_DEF_RXWINSIZE ; +if (priv->bss_type ==NXPWIFI_BSS_TYPE_UAP ) + priv->add_ba_param.rx_win_size = +NXPWIFI_UAP_AMPDU_DEF_RXWINSIZE ; + } + +if (adapter->coex_win_size && adapter->coex_rx_win_size) + priv->add_ba_param.rx_win_size = + adapter->coex_rx_win_size; + +if (rx_win_size != priv->add_ba_param.rx_win_size) { +if (!priv->media_connected) +continue ; +for (i =0 ; i <MAX_NUM_TID ; i++) +nxpwifi_11n_delba (priv, i); + } + } +} + +/* This function check coex for RX BA +*/ +void nxpwifi_coex_ampdu_rxwinsize (struct nxpwifi_adapter *adapter) +{ +u8 i; +struct nxpwifi_private *priv; +u8 count =0 ; + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + priv = adapter->priv[i]; +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) { +if (priv->media_connected) + count++; + } +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { +if (priv->bss_started) + count++; + } + } +if (count >=NXPWIFI_BSS_COEX_COUNT ) +break ; + } +if (count >=NXPWIFI_BSS_COEX_COUNT ) +nxpwifi_update_ampdu_rxwinsize (adapter, true); +else +nxpwifi_update_ampdu_rxwinsize (adapter, false); +} + +/* This function handles rxba_sync event +*/ +void nxpwifi_11n_rxba_sync_event (struct nxpwifi_private *priv, +u8 *event_buf,u16 len) +{ +struct nxpwifi_ie_types_rxba_sync *tlv_rxba = (void *)event_buf; +u16 tlv_type, tlv_len; +struct nxpwifi_rx_reorder_tbl *rx_reor_tbl_ptr; +u8 i, j; +u16 seq_num, tlv_seq_num, tlv_bitmap_len; +int tlv_buf_left = len; +int ret; +u8 *tmp; + +nxpwifi_dbg_dump (priv->adapter,EVT_D ,"RXBA_SYNC event:" , + event_buf, len); +while (tlv_buf_left >sizeof (*tlv_rxba)) { + tlv_type =le16_to_cpu (tlv_rxba->header.type); + tlv_len =le16_to_cpu (tlv_rxba->header.len); +if (size_add (sizeof (tlv_rxba->header), tlv_len) > tlv_buf_left) { +nxpwifi_dbg (priv->adapter,WARN , +"TLV size (%zu) overflows event_buf buf_left=%d\n" , +size_add (sizeof (tlv_rxba->header), tlv_len), + tlv_buf_left); +return ; + } + +if (tlv_type !=TLV_TYPE_RXBA_SYNC ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Wrong TLV id=0x%x\n" , tlv_type); +return ; + } + + tlv_seq_num =le16_to_cpu (tlv_rxba->seq_num); + tlv_bitmap_len =le16_to_cpu (tlv_rxba->bitmap_len); +if (size_add (sizeof (*tlv_rxba), tlv_bitmap_len) > tlv_buf_left) { +nxpwifi_dbg (priv->adapter,WARN , +"TLV size (%zu) overflows event_buf buf_left=%d\n" , +size_add (sizeof (*tlv_rxba), tlv_bitmap_len), + tlv_buf_left); +return ; + } + +nxpwifi_dbg (priv->adapter,INFO , +"%pM tid=%d seq_num=%d bitmap_len=%d\n" , + tlv_rxba->mac, tlv_rxba->tid, tlv_seq_num, + tlv_bitmap_len); + + rx_reor_tbl_ptr = +nxpwifi_11n_get_rx_reorder_tbl (priv, tlv_rxba->tid, + tlv_rxba->mac); +if (!rx_reor_tbl_ptr) { +nxpwifi_dbg (priv->adapter,ERROR , +"Can not find rx_reorder_tbl!" ); +return ; + } + +for (i =0 ; i < tlv_bitmap_len; i++) { +for (j =0 ; j <8 ; j++) { +if (tlv_rxba->bitmap[i] & (1 << j)) { + seq_num = (MAX_TID_VALUE -1 ) & + (tlv_seq_num + i *8 + j); + +nxpwifi_dbg (priv->adapter,ERROR , +"drop packet,seq=%d\n" , + seq_num); + + ret =nxpwifi_11n_rx_reorder_pkt + (priv, seq_num, tlv_rxba->tid, + tlv_rxba->mac,0 ,NULL ); + +if (ret) +nxpwifi_dbg (priv->adapter, +ERROR , +"Fail to drop packet" ); + } + } + } + + tlv_buf_left -= (sizeof (tlv_rxba->header) + tlv_len); + tmp = (u8 *)tlv_rxba +sizeof (tlv_rxba->header) + tlv_len; + tlv_rxba = (struct nxpwifi_ie_types_rxba_sync *)tmp; + } +}
Signature · 1 line
2.34.1
PATCH v2 9/43 wifi: nxpwifi: add 11n_rxreorder.h
In reply to David Lin--- .../net/wireless/nxp/nxpwifi/11n_rxreorder.h | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h
drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h new file +72 -0
@@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: 802.11n RX Re-ordering +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_11N_RXREORDER_H_ +#define _NXPWIFI_11N_RXREORDER_H_ + +#define MIN_FLUSH_TIMER_MS 50 +#define MIN_FLUSH_TIMER_15_MS 15 +#define NXPWIFI_BA_WIN_SIZE_32 32 + +#define PKT_TYPE_BAR 0xE7 +#define MAX_TID_VALUE (2 << 11) +#define TWOPOW11 (2 << 10) + +#define BLOCKACKPARAM_TID_POS 2 +#define BLOCKACKPARAM_AMSDU_SUPP_MASK 0x1 +#define BLOCKACKPARAM_WINSIZE_POS 6 +#define DELBA_TID_POS 12 +#define DELBA_INITIATOR_POS 11 +#define TYPE_DELBA_SENT 1 +#define TYPE_DELBA_RECEIVE 2 +#define IMMEDIATE_BLOCK_ACK 0x2 + +#define ADDBA_RSP_STATUS_ACCEPT 0 + +#define NXPWIFI_DEF_11N_RX_SEQ_NUM 0xffff +#define BA_SETUP_MAX_PACKET_THRESHOLD 16 +#define BA_SETUP_PACKET_OFFSET 16 + +enum nxpwifi_rxreor_flags { +RXREOR_FORCE_NO_DROP =1 <<0 , +RXREOR_INIT_WINDOW_SHIFT =1 <<1 , +}; + +static inline void nxpwifi_reset_11n_rx_seq_num (struct nxpwifi_private *priv) +{ +memset (priv->rx_seq,0xff ,sizeof (priv->rx_seq)); +} + +int nxpwifi_11n_rx_reorder_pkt (struct nxpwifi_private *, +u16 seqNum, +u16 tid,u8 *ta, +u8 pkttype,void *payload); +void nxpwifi_del_ba_tbl (struct nxpwifi_private *priv,int tid, +u8 *peer_mac,u8 type,int initiator); +void nxpwifi_11n_ba_stream_timeout (struct nxpwifi_private *priv, +struct host_cmd_ds_11n_batimeout *event); +int nxpwifi_ret_11n_addba_resp (struct nxpwifi_private *priv, +struct host_cmd_ds_command + *resp); +int nxpwifi_cmd_11n_delba (struct host_cmd_ds_command *cmd, +void *data_buf); +int nxpwifi_cmd_11n_addba_rsp_gen (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +struct host_cmd_ds_11n_addba_req + *cmd_addba_req); +int nxpwifi_cmd_11n_addba_req (struct host_cmd_ds_command *cmd, +void *data_buf); +void nxpwifi_11n_cleanup_reorder_tbl (struct nxpwifi_private *priv); +struct nxpwifi_rx_reorder_tbl * +nxpwifi_11n_get_rxreorder_tbl (struct nxpwifi_private *priv,int tid,u8 *ta); +struct nxpwifi_rx_reorder_tbl * +nxpwifi_11n_get_rx_reorder_tbl (struct nxpwifi_private *priv,int tid,u8 *ta); +void nxpwifi_11n_del_rx_reorder_tbl_by_ta (struct nxpwifi_private *priv,u8 *ta); +void nxpwifi_update_rxreor_flags (struct nxpwifi_adapter *adapter,u8 flags); +void nxpwifi_11n_rxba_sync_event (struct nxpwifi_private *priv, +u8 *event_buf,u16 len); +#endif /* _NXPWIFI_11N_RXREORDER_H_ */
Signature · 1 line
2.34.1
PATCH v2 10/43 wifi: nxpwifi: add cfg80211.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cfg80211.c | 3773 +++++++++++++++++++ 1 file changed, 3773 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.c
drivers/net/wireless/nxp/nxpwifi/cfg80211.c new file +3773 -0
@@ -0,0 +1,3773 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: CFG80211 +* +* Copyright 2011-2024 NXP +*/ + +#include "cfg80211.h" +#include "main.h" +#include "cmdevt.h" +#include "11n.h" +#include "wmm.h" + +static const struct ieee80211_iface_limit nxpwifi_ap_sta_limits[] = { + { + .max =NXPWIFI_MAX_BSS_NUM , + .types =BIT (NL80211_IFTYPE_STATION ) | +BIT (NL80211_IFTYPE_AP ), + }, +}; + +static const struct ieee80211_iface_combination +nxpwifi_iface_comb_ap_sta = { + .limits = nxpwifi_ap_sta_limits, + .num_different_channels =1 , + .n_limits =ARRAY_SIZE (nxpwifi_ap_sta_limits), + .max_interfaces =NXPWIFI_MAX_BSS_NUM , + .beacon_int_infra_match = true, + .radar_detect_widths =BIT (NL80211_CHAN_WIDTH_20_NOHT ) | +BIT (NL80211_CHAN_WIDTH_20 ) | +BIT (NL80211_CHAN_WIDTH_40 ), +}; + +static const struct ieee80211_iface_combination +nxpwifi_iface_comb_ap_sta_vht = { + .limits = nxpwifi_ap_sta_limits, + .num_different_channels =1 , + .n_limits =ARRAY_SIZE (nxpwifi_ap_sta_limits), + .max_interfaces =NXPWIFI_MAX_BSS_NUM , + .beacon_int_infra_match = true, + .radar_detect_widths =BIT (NL80211_CHAN_WIDTH_20_NOHT ) | +BIT (NL80211_CHAN_WIDTH_20 ) | +BIT (NL80211_CHAN_WIDTH_40 ) | +BIT (NL80211_CHAN_WIDTH_80 ), +}; + +/* This function maps the nl802.11 channel type into driver channel type. +* +* The mapping is as follows - +* NL80211_CHAN_NO_HT -> IEEE80211_HT_PARAM_CHA_SEC_NONE +* NL80211_CHAN_HT20 -> IEEE80211_HT_PARAM_CHA_SEC_NONE +* NL80211_CHAN_HT40PLUS -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE +* NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW +* Others -> IEEE80211_HT_PARAM_CHA_SEC_NONE +*/ +u8 nxpwifi_chan_type_to_sec_chan_offset (enum nl80211_channel_type chan_type) +{ +switch (chan_type) { +case NL80211_CHAN_NO_HT : +case NL80211_CHAN_HT20 : +return IEEE80211_HT_PARAM_CHA_SEC_NONE ; +case NL80211_CHAN_HT40PLUS : +return IEEE80211_HT_PARAM_CHA_SEC_ABOVE ; +case NL80211_CHAN_HT40MINUS : +return IEEE80211_HT_PARAM_CHA_SEC_BELOW ; +default : +return IEEE80211_HT_PARAM_CHA_SEC_NONE ; + } +} + +/* This function maps IEEE HT secondary channel type to NL80211 channel type +*/ +u8 nxpwifi_get_chan_type (struct nxpwifi_private *priv) +{ +struct nxpwifi_channel_band channel_band; +int ret; + + ret =nxpwifi_get_chan_info (priv, &channel_band); + +if (!ret) { +switch (channel_band.band_config.chan_width) { +case CHAN_BW_20MHZ : +if (IS_11N_ENABLED (priv)) +return NL80211_CHAN_HT20 ; +else +return NL80211_CHAN_NO_HT ; +case CHAN_BW_40MHZ : +if (channel_band.band_config.chan2_offset == +SEC_CHAN_ABOVE ) +return NL80211_CHAN_HT40PLUS ; +else +return NL80211_CHAN_HT40MINUS ; +default : +return NL80211_CHAN_HT20 ; + } + } + +return NL80211_CHAN_HT20 ; +} + +/* This function retrieves the private structure from kernel wiphy structure. +*/ +static void *nxpwifi_cfg80211_get_adapter (struct wiphy *wiphy) +{ +return (void *)(*(unsigned long *)wiphy_priv (wiphy)); +} + +/* CFG802.11 operation handler to delete a network key. +*/ +static int +nxpwifi_cfg80211_del_key (struct wiphy *wiphy,struct net_device *netdev, +int link_id,u8 key_index,bool pairwise, +const u8 *mac_addr) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (netdev); +static const u8 bc_mac[] = {0xff ,0xff ,0xff ,0xff ,0xff ,0xff }; +const u8 *peer_mac = pairwise ? mac_addr : bc_mac; +int ret; + + ret =nxpwifi_set_encode (priv,NULL ,NULL ,0 , key_index, peer_mac,1 ); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"crypto keys deleted failed %d\n" , ret); +else +nxpwifi_dbg (priv->adapter,INFO ,"info: crypto keys deleted\n" ); + +return ret; +} + +/* This function forms an skb for management frame. +*/ +static void +nxpwifi_form_mgmt_frame (struct sk_buff *skb,const u8 *buf,size_t len) +{ +u8 addr[ETH_ALEN ] = {0xFF ,0xFF ,0xFF ,0xFF ,0xFF ,0xFF }; +u16 pkt_len; +u32 tx_control =0 , pkt_type =PKT_TYPE_MGMT ; + + pkt_len = len +ETH_ALEN ; + +skb_reserve (skb,NXPWIFI_MIN_DATA_HEADER_LEN + +NXPWIFI_MGMT_FRAME_HEADER_SIZE +sizeof (pkt_len)); +memcpy (skb_push (skb,sizeof (pkt_len)), &pkt_len,sizeof (pkt_len)); + +memcpy (skb_push (skb,sizeof (tx_control)), + &tx_control,sizeof (tx_control)); + +memcpy (skb_push (skb,sizeof (pkt_type)), &pkt_type,sizeof (pkt_type)); + +/* Add packet data and address4 */ +skb_put_data (skb, buf,sizeof (struct ieee80211_hdr_3addr )); +skb_put_data (skb, addr,ETH_ALEN ); +skb_put_data (skb, buf +sizeof (struct ieee80211_hdr_3addr ), + len -sizeof (struct ieee80211_hdr_3addr )); + + skb->priority =LOW_PRIO_TID ; +__net_timestamp (skb); +} + +/* CFG802.11 operation handler to transmit a management frame. +*/ +static int +nxpwifi_cfg80211_mgmt_tx (struct wiphy *wiphy,struct wireless_dev *wdev, +struct cfg80211_mgmt_tx_params *params,u64 *cookie) +{ +const u8 *buf = params->buf; +size_t len = params->len; +struct sk_buff *skb; +u16 pkt_len; +const struct ieee80211_mgmt *mgmt; +struct nxpwifi_txinfo *tx_info; +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (wdev->netdev); + +if (!buf || !len) { +nxpwifi_dbg (priv->adapter,ERROR ,"invalid buffer and length\n" ); +return -EINVAL ; + } + + mgmt = (const struct ieee80211_mgmt *)buf; +if (GET_BSS_ROLE (priv) !=NXPWIFI_BSS_ROLE_STA && +ieee80211_is_probe_resp (mgmt->frame_control)) { +/* Since we support offload probe resp, we need to skip probe +* resp in AP or GO mode +*/ +nxpwifi_dbg (priv->adapter,INFO , +"info: skip to send probe resp in AP or GO mode\n" ); +return 0 ; + } + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { +if (ieee80211_is_auth (mgmt->frame_control)) +nxpwifi_dbg (priv->adapter,MSG , +"auth: send auth to %pM\n" , mgmt->da); +if (ieee80211_is_deauth (mgmt->frame_control)) +nxpwifi_dbg (priv->adapter,MSG , +"auth: send deauth to %pM\n" , mgmt->da); +if (ieee80211_is_disassoc (mgmt->frame_control)) +nxpwifi_dbg (priv->adapter,MSG , +"assoc: send disassoc to %pM\n" , mgmt->da); +if (ieee80211_is_assoc_resp (mgmt->frame_control)) +nxpwifi_dbg (priv->adapter,MSG , +"assoc: send assoc resp to %pM\n" , + mgmt->da); +if (ieee80211_is_reassoc_resp (mgmt->frame_control)) +nxpwifi_dbg (priv->adapter,MSG , +"assoc: send reassoc resp to %pM\n" , + mgmt->da); + } + + pkt_len = len +ETH_ALEN ; + skb =dev_alloc_skb (NXPWIFI_MIN_DATA_HEADER_LEN + +NXPWIFI_MGMT_FRAME_HEADER_SIZE + + pkt_len +sizeof (pkt_len)); + +if (!skb) { +nxpwifi_dbg (priv->adapter,ERROR , +"allocate skb failed for management frame\n" ); +return -ENOMEM ; + } + + tx_info =NXPWIFI_SKB_TXCB (skb); +memset (tx_info,0 ,sizeof (*tx_info)); + tx_info->bss_num = priv->bss_num; + tx_info->bss_type = priv->bss_type; + tx_info->pkt_len = pkt_len; + +nxpwifi_form_mgmt_frame (skb, buf, len); + *cookie =nxpwifi_roc_cookie (priv->adapter); + +if (ieee80211_is_action (mgmt->frame_control)) + skb =nxpwifi_clone_skb_for_tx_status (priv, + skb, +NXPWIFI_BUF_FLAG_ACTION_TX_STATUS , cookie); +else +cfg80211_mgmt_tx_status (wdev, *cookie, buf, len, true, +GFP_ATOMIC ); + +nxpwifi_queue_tx_pkt (priv, skb); + +nxpwifi_dbg (priv->adapter,INFO ,"info: management frame transmitted\n" ); +return 0 ; +} + +/* CFG802.11 operation handler to register a mgmt frame. +*/ +static void +nxpwifi_cfg80211_update_mgmt_frame_registrations (struct wiphy *wiphy, +struct wireless_dev *wdev, +struct mgmt_frame_regs *upd) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (wdev->netdev); +u32 mask = upd->interface_stypes; + +if (mask != priv->mgmt_frame_mask) { + priv->mgmt_frame_mask = mask; +if (priv->host_mlme_reg && +GET_BSS_ROLE (priv) !=NXPWIFI_BSS_ROLE_UAP ) + priv->mgmt_frame_mask |=HOST_MLME_MGMT_MASK ; +nxpwifi_send_cmd (priv,HOST_CMD_MGMT_FRAME_REG , +HOST_ACT_GEN_SET ,0 , + &priv->mgmt_frame_mask, false); +nxpwifi_dbg (priv->adapter,INFO ,"info: mgmt frame registered\n" ); + } +} + +/* CFG802.11 operation handler to remain on channel. +*/ +static int +nxpwifi_cfg80211_remain_on_channel (struct wiphy *wiphy, +struct wireless_dev *wdev, +struct ieee80211_channel *chan, +unsigned int duration,u64 *cookie) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (wdev->netdev); +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; + +if (!chan || !cookie) { +nxpwifi_dbg (adapter,ERROR ,"Invalid parameter for ROC\n" ); +return -EINVAL ; + } + +if (priv->roc_cfg.cookie) { +nxpwifi_dbg (adapter,INFO , +"info: ongoing ROC, cookie = 0x%llx\n" , + priv->roc_cfg.cookie); +return -EBUSY ; + } + + ret =nxpwifi_remain_on_chan_cfg (priv,HOST_ACT_GEN_SET , chan, + duration); + +if (!ret) { + *cookie =nxpwifi_roc_cookie (adapter); + priv->roc_cfg.cookie = *cookie; + priv->roc_cfg.chan = *chan; + +cfg80211_ready_on_channel (wdev, *cookie, chan, + duration,GFP_ATOMIC ); + +nxpwifi_dbg (adapter,INFO , +"info: ROC, cookie = 0x%llx\n" , *cookie); + } + +return ret; +} + +/* CFG802.11 operation handler to cancel remain on channel. +*/ +static int +nxpwifi_cfg80211_cancel_remain_on_channel (struct wiphy *wiphy, +struct wireless_dev *wdev,u64 cookie) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (wdev->netdev); +int ret; + +if (cookie != priv->roc_cfg.cookie) +return -ENOENT ; + + ret =nxpwifi_remain_on_chan_cfg (priv,HOST_ACT_GEN_REMOVE , + &priv->roc_cfg.chan,0 ); + +if (!ret) { +cfg80211_remain_on_channel_expired (wdev, cookie, + &priv->roc_cfg.chan, +GFP_ATOMIC ); + +memset (&priv->roc_cfg,0 ,sizeof (struct nxpwifi_roc_cfg )); + +nxpwifi_dbg (priv->adapter,INFO , +"info: cancel ROC, cookie = 0x%llx\n" , cookie); + } + +return ret; +} + +/* CFG802.11 operation handler to set Tx power. +*/ +static int +nxpwifi_cfg80211_set_tx_power (struct wiphy *wiphy, +struct wireless_dev *wdev, +enum nl80211_tx_power_setting type, +int mbm) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv; +struct nxpwifi_power_cfg power_cfg; +int dbm =MBM_TO_DBM (mbm); + +switch (type) { +case NL80211_TX_POWER_FIXED : + power_cfg.is_power_auto =0 ; + power_cfg.is_power_fixed =1 ; + power_cfg.power_level = dbm; +break ; +case NL80211_TX_POWER_LIMITED : + power_cfg.is_power_auto =0 ; + power_cfg.is_power_fixed =0 ; + power_cfg.power_level = dbm; +break ; +case NL80211_TX_POWER_AUTOMATIC : + power_cfg.is_power_auto =1 ; +break ; + } + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + +return nxpwifi_set_tx_power (priv, &power_cfg); +} + +/* CFG802.11 operation handler to get Tx power. +*/ +static int +nxpwifi_cfg80211_get_tx_power (struct wiphy *wiphy, +struct wireless_dev *wdev, +int *dbm) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter, +NXPWIFI_BSS_ROLE_ANY ); +int ret =nxpwifi_send_cmd (priv,HOST_CMD_RF_TX_PWR , +HOST_ACT_GEN_GET ,0 ,NULL , true); + +if (ret <0 ) +return ret; + +/* tx_power_level is set in HOST_CMD_RF_TX_PWR command handler */ + *dbm = priv->tx_power_level; + +return 0 ; +} + +/* CFG802.11 operation handler to set Power Save option. +* +* The timeout value, if provided, is currently ignored. +*/ +static int +nxpwifi_cfg80211_set_power_mgmt (struct wiphy *wiphy, +struct net_device *dev, +bool enabled,int timeout) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +u32 ps_mode; + +if (timeout) +nxpwifi_dbg (priv->adapter,INFO , +"info: ignore timeout value for IEEE Power Save\n" ); + + ps_mode = enabled; + +return nxpwifi_drv_set_power (priv, &ps_mode); +} + +/* CFG802.11 operation handler to set the default network key. +*/ +static int +nxpwifi_cfg80211_set_default_key (struct wiphy *wiphy,struct net_device *netdev, +int link_id,u8 key_index,bool unicast, +bool multicast) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (netdev); +int ret =0 ; + +/* Return if WEP key not configured */ +if (!priv->sec_info.wep_enabled) +return 0 ; + +if (priv->bss_type ==NXPWIFI_BSS_TYPE_UAP ) { + priv->wep_key_curr_index = key_index; + }else { + ret =nxpwifi_set_encode (priv,NULL ,NULL ,0 , key_index, +NULL ,0 ); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"failed to set default Tx key index\n" ); + } + +return ret; +} + +/* CFG802.11 operation handler to add a network key. +*/ +static int +nxpwifi_cfg80211_add_key (struct wiphy *wiphy,struct net_device *netdev, +int link_id,u8 key_index,bool pairwise, +const u8 *mac_addr,struct key_params *params) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (netdev); +struct nxpwifi_wep_key *wep_key; +static const u8 bc_mac[] = {0xff ,0xff ,0xff ,0xff ,0xff ,0xff }; +const u8 *peer_mac = pairwise ? mac_addr : bc_mac; +int ret; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP && + (params->cipher ==WLAN_CIPHER_SUITE_WEP40 || + params->cipher ==WLAN_CIPHER_SUITE_WEP104 )) { +if (params->key && params->key_len) { + wep_key = &priv->wep_key[key_index]; +memset (wep_key,0 ,sizeof (struct nxpwifi_wep_key )); +memcpy (wep_key->key_material, params->key, + params->key_len); + wep_key->key_index = key_index; + wep_key->key_length = params->key_len; + priv->sec_info.wep_enabled =1 ; + } +return 0 ; + } + + ret =nxpwifi_set_encode (priv, params, params->key, params->key_len, + key_index, peer_mac,0 ); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"failed to add crypto keys\n" ); + +return ret; +} + +/* CFG802.11 operation handler to set default mgmt key. +*/ +static int +nxpwifi_cfg80211_set_default_mgmt_key (struct wiphy *wiphy, +struct net_device *netdev, +int link_id, +u8 key_index) +{ +return 0 ; +} + +/* This function sends domain information to the firmware. +* +* The following information are passed to the firmware - +* - Country codes +* - Sub bands (first channel, number of channels, maximum Tx power) +*/ +int nxpwifi_send_domain_info_cmd_fw (struct wiphy *wiphy) +{ +u8 no_of_triplet =0 ; +struct ieee80211_country_ie_triplet *t; +u8 no_of_parsed_chan =0 ; +u8 first_chan =0 , next_chan =0 , max_pwr =0 ; +u8 i, flag =0 ; +enum nl80211_band band; +struct ieee80211_supported_band *sband; +struct ieee80211_channel *ch; +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv; +struct nxpwifi_802_11d_domain_reg *domain_info = &adapter->domain_reg; +int ret; + + domain_info->dfs_region = adapter->dfs_region; + +/* Set country code */ + domain_info->country_code[0 ] = adapter->country_code[0 ]; + domain_info->country_code[1 ] = adapter->country_code[1 ]; + domain_info->country_code[2 ] =' ' ; + + band =nxpwifi_band_to_radio_type (adapter->config_bands); +if (!wiphy->bands[band]) { +nxpwifi_dbg (adapter,ERROR , +"11D: setting domain info in FW\n" ); +return -EINVAL ; + } + + sband = wiphy->bands[band]; + +for (i =0 ; i < sband->n_channels ; i++) { + ch = &sband->channels[i]; +if (ch->flags &IEEE80211_CHAN_DISABLED ) +continue ; + +if (!flag) { + flag =1 ; + first_chan = (u32 )ch->hw_value; + next_chan = first_chan; + max_pwr = ch->max_power; + no_of_parsed_chan =1 ; +continue ; + } + +if (ch->hw_value == next_chan +1 && + ch->max_power == max_pwr) { + next_chan++; + no_of_parsed_chan++; + }else { + t = &domain_info->triplet[no_of_triplet]; + t->chans.first_channel = first_chan; + t->chans.num_channels = no_of_parsed_chan; + t->chans.max_power = max_pwr; + no_of_triplet++; + first_chan = (u32 )ch->hw_value; + next_chan = first_chan; + max_pwr = ch->max_power; + no_of_parsed_chan =1 ; + } + } + +if (flag) { + t = &domain_info->triplet[no_of_triplet]; + t->chans.first_channel = first_chan; + t->chans.num_channels = no_of_parsed_chan; + t->chans.max_power = max_pwr; + no_of_triplet++; + } + + domain_info->no_of_triplet = no_of_triplet; + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + + ret =nxpwifi_send_cmd (priv,HOST_CMD_802_11D_DOMAIN_INFO , +HOST_ACT_GEN_SET ,0 ,NULL , false); + +if (ret) +nxpwifi_dbg (adapter,INFO , +"11D: failed to set domain info in FW\n" ); + +return ret; +} + +static void nxpwifi_reg_apply_radar_flags (struct wiphy *wiphy) +{ +struct ieee80211_supported_band *sband; +struct ieee80211_channel *chan; +unsigned int i; + +if (!wiphy->bands[NL80211_BAND_5GHZ ]) +return ; + sband = wiphy->bands[NL80211_BAND_5GHZ ]; + +for (i =0 ; i < sband->n_channels; i++) { + chan = &sband->channels[i]; +if ((!(chan->flags &IEEE80211_CHAN_DISABLED )) && + (chan->flags &IEEE80211_CHAN_RADAR )) + chan->flags |=IEEE80211_CHAN_NO_IR ; + } +} + +/* CFG802.11 regulatory domain callback function. +* +* This function is called when the regulatory domain is changed due to the +* following reasons - +* - Set by driver +* - Set by system core +* - Set by user +* - Set bt Country IE +*/ +static void nxpwifi_reg_notifier (struct wiphy *wiphy, +struct regulatory_request *request) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter, +NXPWIFI_BSS_ROLE_ANY ); +nxpwifi_dbg (adapter,INFO , +"info: cfg80211 regulatory domain callback for %c%c\n" , + request->alpha2[0 ], request->alpha2[1 ]); +nxpwifi_reg_apply_radar_flags (wiphy); + +switch (request->initiator) { +case NL80211_REGDOM_SET_BY_DRIVER : +case NL80211_REGDOM_SET_BY_CORE : +case NL80211_REGDOM_SET_BY_USER : +case NL80211_REGDOM_SET_BY_COUNTRY_IE : +break ; +default : +nxpwifi_dbg (adapter,ERROR , +"unknown regdom initiator: %d\n" , + request->initiator); +return ; + } + +/* Don't send world or same regdom info to firmware */ +if (strncmp (request->alpha2,"00" ,2 ) && +strncmp (request->alpha2, adapter->country_code, +sizeof (request->alpha2))) { +memcpy (adapter->country_code, request->alpha2, +sizeof (request->alpha2)); + adapter->dfs_region = request->dfs_region; +nxpwifi_send_domain_info_cmd_fw (wiphy); +nxpwifi_dnld_txpwr_table (priv); + } +} + +/* This function sets the fragmentation threshold. +* +* The fragmentation threshold value must lie between NXPWIFI_FRAG_MIN_VALUE +* and NXPWIFI_FRAG_MAX_VALUE. +*/ +static int +nxpwifi_set_frag (struct nxpwifi_private *priv,u32 frag_thr) +{ +if (frag_thr <NXPWIFI_FRAG_MIN_VALUE || + frag_thr >NXPWIFI_FRAG_MAX_VALUE ) + frag_thr =NXPWIFI_FRAG_MAX_VALUE ; + +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_SNMP_MIB , +HOST_ACT_GEN_SET ,FRAG_THRESH_I , + &frag_thr, true); +} + +/* This function sets the RTS threshold. +* +* The rts value must lie between NXPWIFI_RTS_MIN_VALUE +* and NXPWIFI_RTS_MAX_VALUE. +*/ +static int +nxpwifi_set_rts (struct nxpwifi_private *priv,u32 rts_thr) +{ +if (rts_thr <NXPWIFI_RTS_MIN_VALUE || rts_thr >NXPWIFI_RTS_MAX_VALUE ) + rts_thr =NXPWIFI_RTS_MAX_VALUE ; + +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_SNMP_MIB , +HOST_ACT_GEN_SET ,RTS_THRESH_I , + &rts_thr, true); +} + +/* CFG802.11 operation handler to set wiphy parameters. +* +* This function can be used to set the RTS threshold and the +* Fragmentation threshold of the driver. +*/ +static int +nxpwifi_cfg80211_set_wiphy_params (struct wiphy *wiphy,u32 changed) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv; +struct nxpwifi_uap_bss_param *bss_cfg; +int ret =0 ; + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + +switch (priv->bss_role) { +case NXPWIFI_BSS_ROLE_UAP : +if (priv->bss_started) +break ; + + bss_cfg =kzalloc (sizeof (*bss_cfg),GFP_KERNEL ); +if (!bss_cfg) { + ret = -ENOMEM ; +break ; + } + +nxpwifi_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; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_UAP_SYS_CONFIG , +HOST_ACT_GEN_SET , +UAP_BSS_PARAMS_I , bss_cfg, + false); + +kfree (bss_cfg); +if (ret) +nxpwifi_dbg (adapter,ERROR , +"Failed to set wiphy phy params\n" ); +break ; + +case NXPWIFI_BSS_ROLE_STA : +if (priv->media_connected) +break ; + +if (changed &WIPHY_PARAM_RTS_THRESHOLD ) { + ret =nxpwifi_set_rts (priv, + wiphy->rts_threshold); +if (ret) +break ; + } +if (changed &WIPHY_PARAM_FRAG_THRESHOLD ) + ret =nxpwifi_set_frag (priv, + wiphy->frag_threshold); +break ; + } + +return ret; +} + +static int nxpwifi_deinit_priv_params (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +unsigned long flags; +int ret; + + priv->host_mlme_reg = false; + priv->mgmt_frame_mask =0 ; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_MGMT_FRAME_REG , +HOST_ACT_GEN_SET ,0 , + &priv->mgmt_frame_mask, false); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"could not unregister mgmt frame rx\n" ); +return ret; + } + +nxpwifi_deauthenticate (priv,NULL ); + +spin_lock_irqsave (&adapter->main_proc_lock, flags); + adapter->main_locked = true; +if (adapter->nxpwifi_processing) { +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); +flush_workqueue (adapter->workqueue); + }else { +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + } + +tasklet_disable (&adapter->rx_task); + +nxpwifi_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 ret; +} + +static int +nxpwifi_init_new_priv_params (struct nxpwifi_private *priv, +struct net_device *dev, +enum nl80211_iftype type) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +unsigned long flags; + +nxpwifi_init_priv (priv); + + priv->bss_mode = type; + priv->wdev.iftype = type; + +nxpwifi_init_priv_params (priv, priv->netdev); + priv->bss_started =0 ; + +switch (type) { +case NL80211_IFTYPE_STATION : + priv->bss_role =NXPWIFI_BSS_ROLE_STA ; + priv->bss_type =NXPWIFI_BSS_TYPE_STA ; +break ; +case NL80211_IFTYPE_AP : + priv->bss_role =NXPWIFI_BSS_ROLE_UAP ; + priv->bss_type =NXPWIFI_BSS_TYPE_UAP ; +break ; +default : +nxpwifi_dbg (adapter,ERROR , +"%s: changing to %d not supported\n" , + dev->name, type); +return -EOPNOTSUPP ; + } + +spin_lock_irqsave (&adapter->main_proc_lock, flags); + adapter->main_locked = false; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + +tasklet_enable (&adapter->rx_task); + +nxpwifi_set_mac_address (priv, dev, false,NULL ); + +return 0 ; +} + +static bool +is_vif_type_change_allowed (struct nxpwifi_adapter *adapter, +enum nl80211_iftype old_iftype, +enum nl80211_iftype new_iftype) +{ +switch (old_iftype) { +case NL80211_IFTYPE_STATION : +switch (new_iftype) { +case NL80211_IFTYPE_AP : +return adapter->curr_iface_comb.uap_intf != + adapter->iface_limit.uap_intf; +default : +return false; + } + +case NL80211_IFTYPE_AP : +switch (new_iftype) { +case NL80211_IFTYPE_STATION : +return adapter->curr_iface_comb.sta_intf != + adapter->iface_limit.sta_intf; +default : +return false; + } + +default : +break ; + } + +return false; +} + +static void +update_vif_type_counter (struct nxpwifi_adapter *adapter, +enum nl80211_iftype iftype, +int change) +{ +switch (iftype) { +case NL80211_IFTYPE_UNSPECIFIED : +case NL80211_IFTYPE_STATION : + adapter->curr_iface_comb.sta_intf += change; +break ; +case NL80211_IFTYPE_AP : + adapter->curr_iface_comb.uap_intf += change; +break ; +default : +nxpwifi_dbg (adapter,ERROR , +"%s: Unsupported iftype passed: %d\n" , + __func__, iftype); +break ; + } +} + +static int +nxpwifi_change_vif_to_sta (struct net_device *dev, +enum nl80211_iftype curr_iftype, +enum nl80211_iftype type, +struct vif_params *params) +{ +struct nxpwifi_private *priv; +struct nxpwifi_adapter *adapter; +int ret; + + priv =nxpwifi_netdev_get_priv (dev); + +if (!priv) +return -EINVAL ; + + adapter = priv->adapter; + +nxpwifi_dbg (adapter,INFO , +"%s: changing role to station\n" , dev->name); + + ret =nxpwifi_deinit_priv_params (priv); +if (ret) + goto done; + ret =nxpwifi_init_new_priv_params (priv, dev, type); +if (ret) + goto done; + +update_vif_type_counter (adapter, curr_iftype,-1 ); +update_vif_type_counter (adapter, type,1 ); + dev->ieee80211_ptr->iftype = type; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_SET_BSS_MODE , +HOST_ACT_GEN_SET ,0 ,NULL , true); +if (ret) + goto done; + + ret =nxpwifi_sta_init_cmd (priv, false, false); + +done: +return ret; +} + +static int +nxpwifi_change_vif_to_ap (struct net_device *dev, +enum nl80211_iftype curr_iftype, +enum nl80211_iftype type, +struct vif_params *params) +{ +struct nxpwifi_private *priv; +struct nxpwifi_adapter *adapter; +int ret; + + priv =nxpwifi_netdev_get_priv (dev); + +if (!priv) +return -EINVAL ; + + adapter = priv->adapter; + +nxpwifi_dbg (adapter,INFO , +"%s: changing role to AP\n" , dev->name); + + ret =nxpwifi_deinit_priv_params (priv); +if (ret) + goto done; + + ret =nxpwifi_init_new_priv_params (priv, dev, type); +if (ret) + goto done; + +update_vif_type_counter (adapter, curr_iftype,-1 ); +update_vif_type_counter (adapter, type,1 ); + dev->ieee80211_ptr->iftype = type; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_SET_BSS_MODE , +HOST_ACT_GEN_SET ,0 ,NULL , true); +if (ret) + goto done; + + ret =nxpwifi_sta_init_cmd (priv, false, false); + +done: +return ret; +} + +/* CFG802.11 operation handler to change interface type. +*/ +static int +nxpwifi_cfg80211_change_virtual_intf (struct wiphy *wiphy, +struct net_device *dev, +enum nl80211_iftype type, +struct vif_params *params) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +enum nl80211_iftype curr_iftype = dev->ieee80211_ptr->iftype; + +if (priv->scan_request) { +nxpwifi_dbg (priv->adapter,ERROR , +"change virtual interface: scan in process\n" ); +return -EBUSY ; + } + +if (type ==NL80211_IFTYPE_UNSPECIFIED ) { +nxpwifi_dbg (priv->adapter,INFO , +"%s: no new type specified, keeping old type %d\n" , + dev->name, curr_iftype); +return 0 ; + } + +if (curr_iftype == type) { +nxpwifi_dbg (priv->adapter,INFO , +"%s: interface already is of type %d\n" , + dev->name, curr_iftype); +return 0 ; + } + +if (!is_vif_type_change_allowed (priv->adapter, curr_iftype, type)) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: change from type %d to %d is not allowed\n" , + dev->name, curr_iftype, type); +return -EOPNOTSUPP ; + } + +switch (curr_iftype) { +case NL80211_IFTYPE_STATION : +switch (type) { +case NL80211_IFTYPE_AP : +return nxpwifi_change_vif_to_ap (dev, curr_iftype, type, + params); +default : + goto errnotsupp; + } + +case NL80211_IFTYPE_AP : +switch (type) { +case NL80211_IFTYPE_STATION : +return nxpwifi_change_vif_to_sta (dev, curr_iftype, + type, params); +break ; +default : + goto errnotsupp; + } + +default : + goto errnotsupp; + } + +return 0 ; + +errnotsupp: +nxpwifi_dbg (priv->adapter,ERROR , +"unsupported interface type transition: %d to %d\n" , + curr_iftype, type); +return -EOPNOTSUPP ; +} + +static void +nxpwifi_parse_htinfo (struct nxpwifi_private *priv,u8 rateinfo,u8 htinfo, +struct rate_info *rate) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + +if (adapter->is_hw_11ac_capable) { +/* bit[1-0]: 00=LG 01=HT 10=VHT */ +if (htinfo &BIT (0 )) { +/* HT */ + rate->mcs = rateinfo; + rate->flags |=RATE_INFO_FLAGS_MCS ; + } +if (htinfo &BIT (1 )) { +/* VHT */ + rate->mcs = rateinfo &0x0F ; + rate->flags |=RATE_INFO_FLAGS_VHT_MCS ; + } + +if (htinfo & (BIT (1 ) |BIT (0 ))) { +/* HT or VHT */ +switch (htinfo & (BIT (3 ) |BIT (2 ))) { +case 0 : + rate->bw =RATE_INFO_BW_20 ; +break ; +case (BIT (2 )): + rate->bw =RATE_INFO_BW_40 ; +break ; +case (BIT (3 )): + rate->bw =RATE_INFO_BW_80 ; +break ; +case (BIT (3 ) |BIT (2 )): + rate->bw =RATE_INFO_BW_160 ; +break ; + } + +if (htinfo &BIT (4 )) + rate->flags |=RATE_INFO_FLAGS_SHORT_GI ; + +if ((rateinfo >>4 ) ==1 ) + rate->nss =2 ; +else + rate->nss =1 ; + } + }else { +/* Bit 0 in htinfo indicates that current rate is 11n. Valid +* MCS index values for us are 0 to 15. +*/ +if ((htinfo &BIT (0 )) && rateinfo <16 ) { + rate->mcs = rateinfo; + rate->flags |=RATE_INFO_FLAGS_MCS ; + rate->bw =RATE_INFO_BW_20 ; +if (htinfo &BIT (1 )) + rate->bw =RATE_INFO_BW_40 ; +if (htinfo &BIT (2 )) + rate->flags |=RATE_INFO_FLAGS_SHORT_GI ; + } + } + +/* Decode legacy rates for non-HT. */ +if (!(htinfo & (BIT (0 ) |BIT (1 )))) { +/* Bitrates in multiples of 100kb/s. */ +static const int legacy_rates[] = { + [0 ] =10 , + [1 ] =20 , + [2 ] =55 , + [3 ] =110 , + [4 ] =60 ,/* NXPWIFI_RATE_INDEX_OFDM0 */ + [5 ] =60 , + [6 ] =90 , + [7 ] =120 , + [8 ] =180 , + [9 ] =240 , + [10 ] =360 , + [11 ] =480 , + [12 ] =540 , + }; +if (rateinfo <ARRAY_SIZE (legacy_rates)) + rate->legacy = legacy_rates[rateinfo]; + } +} + +/* This function dumps the station information on a buffer. +* +* The following information are shown - +* - Total bytes transmitted +* - Total bytes received +* - Total packets transmitted +* - Total packets received +* - Signal quality level +* - Transmission rate +*/ +static int +nxpwifi_dump_station_info (struct nxpwifi_private *priv, +struct nxpwifi_sta_node *node, +struct station_info *sinfo) +{ +u32 rate; +int ret; + + sinfo->filled =BIT_ULL (NL80211_STA_INFO_RX_BYTES ) | +BIT_ULL (NL80211_STA_INFO_TX_BYTES ) | +BIT_ULL (NL80211_STA_INFO_RX_PACKETS ) | +BIT_ULL (NL80211_STA_INFO_TX_PACKETS ) | +BIT_ULL (NL80211_STA_INFO_TX_BITRATE ) | +BIT_ULL (NL80211_STA_INFO_SIGNAL ) | +BIT_ULL (NL80211_STA_INFO_SIGNAL_AVG ); + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { +if (!node) +return -ENOENT ; + + sinfo->filled |=BIT_ULL (NL80211_STA_INFO_INACTIVE_TIME ) | +BIT_ULL (NL80211_STA_INFO_TX_FAILED ); + sinfo->inactive_time = +jiffies_to_msecs (jiffies - node->stats.last_rx); + + sinfo->signal = node->stats.rssi; + sinfo->signal_avg = node->stats.rssi; + sinfo->rx_bytes = node->stats.rx_bytes; + sinfo->tx_bytes = node->stats.tx_bytes; + sinfo->rx_packets = node->stats.rx_packets; + sinfo->tx_packets = node->stats.tx_packets; + sinfo->tx_failed = node->stats.tx_failed; + +nxpwifi_parse_htinfo (priv, priv->tx_rate, + node->stats.last_tx_htinfo, + &sinfo->txrate); + sinfo->txrate.legacy = node->stats.last_tx_rate *5 ; + +return 0 ; + } + +/* Get signal information from the firmware */ + ret =nxpwifi_send_cmd (priv,HOST_CMD_RSSI_INFO , +HOST_ACT_GEN_GET ,0 ,NULL , true); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"failed to get signal information\n" ); + goto done; + } + + ret =nxpwifi_drv_get_data_rate (priv, &rate); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"getting data rate error\n" ); + goto done; + } + +/* Get DTIM period information from firmware */ +nxpwifi_send_cmd (priv,HOST_CMD_802_11_SNMP_MIB , +HOST_ACT_GEN_GET ,DTIM_PERIOD_I , + &priv->dtim_period, true); + +nxpwifi_parse_htinfo (priv, priv->tx_rate, priv->tx_htinfo, + &sinfo->txrate); + + sinfo->signal_avg = priv->bcn_rssi_avg; + sinfo->rx_bytes = priv->stats.rx_bytes; + sinfo->tx_bytes = priv->stats.tx_bytes; + sinfo->rx_packets = priv->stats.rx_packets; + sinfo->tx_packets = priv->stats.tx_packets; + sinfo->signal = priv->bcn_rssi_avg; +/* bit rate is in 500 kb/s units. Convert it to 100kb/s units */ + sinfo->txrate.legacy = rate *5 ; + + sinfo->filled |=BIT (NL80211_STA_INFO_RX_BITRATE ); +nxpwifi_parse_htinfo (priv, priv->rxpd_rate, priv->rxpd_htinfo, + &sinfo->rxrate); + +if (priv->bss_mode ==NL80211_IFTYPE_STATION ) { + sinfo->filled |=BIT_ULL (NL80211_STA_INFO_BSS_PARAM ); + sinfo->bss_param.flags =0 ; +if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap & +WLAN_CAPABILITY_SHORT_PREAMBLE ) + sinfo->bss_param.flags |= +BSS_PARAM_FLAGS_SHORT_PREAMBLE ; +if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap & +WLAN_CAPABILITY_SHORT_SLOT_TIME ) + sinfo->bss_param.flags |= +BSS_PARAM_FLAGS_SHORT_SLOT_TIME ; + sinfo->bss_param.dtim_period = priv->dtim_period; + sinfo->bss_param.beacon_interval = + priv->curr_bss_params.bss_descriptor.beacon_period; + } + +done: +return ret; +} + +/* CFG802.11 operation handler to get station information. +* +* This function only works in connected mode, and dumps the +* requested station information, if available. +*/ +static int +nxpwifi_cfg80211_get_station (struct wiphy *wiphy,struct net_device *dev, +const u8 *mac,struct station_info *sinfo) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +if (!priv->media_connected) +return -ENOENT ; +if (memcmp (mac, priv->cfg_bssid,ETH_ALEN )) +return -ENOENT ; + +return nxpwifi_dump_station_info (priv,NULL , sinfo); +} + +/* CFG802.11 operation handler to dump station information. +*/ +static int +nxpwifi_cfg80211_dump_station (struct wiphy *wiphy,struct net_device *dev, +int idx,u8 *mac,struct station_info *sinfo) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_sta_node *node; +int i; + +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) && + priv->media_connected && idx ==0 ) { +ether_addr_copy (mac, priv->cfg_bssid); +return nxpwifi_dump_station_info (priv,NULL , sinfo); + }else if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { +nxpwifi_send_cmd (priv,HOST_CMD_APCMD_STA_LIST , +HOST_ACT_GEN_GET ,0 ,NULL , true); + + i =0 ; +list_for_each_entry (node, &priv->sta_list, list) { +if (i++ != idx) +continue ; +ether_addr_copy (mac, node->mac_addr); +return nxpwifi_dump_station_info (priv, node, sinfo); + } + } + +return -ENOENT ; +} + +static int +nxpwifi_cfg80211_dump_survey (struct wiphy *wiphy,struct net_device *dev, +int idx,struct survey_info *survey) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_chan_stats *pchan_stats = priv->adapter->chan_stats; +enum nl80211_band band; +u8 chan_num; + +nxpwifi_dbg (priv->adapter,DUMP ,"dump_survey idx=%d\n" , idx); + +memset (survey,0 ,sizeof (struct survey_info )); + +if ((GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) && + priv->media_connected && idx ==0 ) { +u8 curr_bss_band = priv->curr_bss_params.band; +u32 chan = priv->curr_bss_params.bss_descriptor.channel; + + band =nxpwifi_band_to_radio_type (curr_bss_band); + survey->channel =ieee80211_get_channel + (wiphy, +ieee80211_channel_to_frequency (chan, band)); + +if (priv->bcn_nf_last) { + survey->filled =SURVEY_INFO_NOISE_DBM ; + survey->noise = priv->bcn_nf_last; + } +return 0 ; + } + +if (idx >= priv->adapter->num_in_chan_stats) +return -ENOENT ; + +if (!pchan_stats[idx].cca_scan_dur) +return 0 ; + + band = pchan_stats[idx].bandcfg; + chan_num = pchan_stats[idx].chan_num; + survey->channel =ieee80211_get_channel + (wiphy, +ieee80211_channel_to_frequency (chan_num, band)); + survey->filled =SURVEY_INFO_NOISE_DBM | +SURVEY_INFO_TIME | +SURVEY_INFO_TIME_BUSY ; + survey->noise = pchan_stats[idx].noise; + survey->time = pchan_stats[idx].cca_scan_dur; + survey->time_busy = pchan_stats[idx].cca_busy_dur; + +return 0 ; +} + +/* Supported rates to be advertised to the cfg80211 */ +static struct ieee80211_rate nxpwifi_rates[] = { + {.bitrate =10 , .hw_value =2 , }, + {.bitrate =20 , .hw_value =4 , }, + {.bitrate =55 , .hw_value =11 , }, + {.bitrate =110 , .hw_value =22 , }, + {.bitrate =60 , .hw_value =12 , }, + {.bitrate =90 , .hw_value =18 , }, + {.bitrate =120 , .hw_value =24 , }, + {.bitrate =180 , .hw_value =36 , }, + {.bitrate =240 , .hw_value =48 , }, + {.bitrate =360 , .hw_value =72 , }, + {.bitrate =480 , .hw_value =96 , }, + {.bitrate =540 , .hw_value =108 , }, +}; + +/* Channel definitions to be advertised to cfg80211 */ +static struct ieee80211_channel nxpwifi_channels_2ghz[] = { + {.center_freq =2412 , .hw_value =1 , }, + {.center_freq =2417 , .hw_value =2 , }, + {.center_freq =2422 , .hw_value =3 , }, + {.center_freq =2427 , .hw_value =4 , }, + {.center_freq =2432 , .hw_value =5 , }, + {.center_freq =2437 , .hw_value =6 , }, + {.center_freq =2442 , .hw_value =7 , }, + {.center_freq =2447 , .hw_value =8 , }, + {.center_freq =2452 , .hw_value =9 , }, + {.center_freq =2457 , .hw_value =10 , }, + {.center_freq =2462 , .hw_value =11 , }, + {.center_freq =2467 , .hw_value =12 , }, + {.center_freq =2472 , .hw_value =13 , }, + {.center_freq =2484 , .hw_value =14 , }, +}; + +static struct ieee80211_supported_band nxpwifi_band_2ghz = { + .channels = nxpwifi_channels_2ghz, + .n_channels =ARRAY_SIZE (nxpwifi_channels_2ghz), + .bitrates = nxpwifi_rates, + .n_bitrates =ARRAY_SIZE (nxpwifi_rates), +}; + +static struct ieee80211_channel nxpwifi_channels_5ghz[] = { + {.center_freq =5040 , .hw_value =8 , }, + {.center_freq =5060 , .hw_value =12 , }, + {.center_freq =5080 , .hw_value =16 , }, + {.center_freq =5170 , .hw_value =34 , }, + {.center_freq =5190 , .hw_value =38 , }, + {.center_freq =5210 , .hw_value =42 , }, + {.center_freq =5230 , .hw_value =46 , }, + {.center_freq =5180 , .hw_value =36 , }, + {.center_freq =5200 , .hw_value =40 , }, + {.center_freq =5220 , .hw_value =44 , }, + {.center_freq =5240 , .hw_value =48 , }, + {.center_freq =5260 , .hw_value =52 , }, + {.center_freq =5280 , .hw_value =56 , }, + {.center_freq =5300 , .hw_value =60 , }, + {.center_freq =5320 , .hw_value =64 , }, + {.center_freq =5500 , .hw_value =100 , }, + {.center_freq =5520 , .hw_value =104 , }, + {.center_freq =5540 , .hw_value =108 , }, + {.center_freq =5560 , .hw_value =112 , }, + {.center_freq =5580 , .hw_value =116 , }, + {.center_freq =5600 , .hw_value =120 , }, + {.center_freq =5620 , .hw_value =124 , }, + {.center_freq =5640 , .hw_value =128 , }, + {.center_freq =5660 , .hw_value =132 , }, + {.center_freq =5680 , .hw_value =136 , }, + {.center_freq =5700 , .hw_value =140 , }, + {.center_freq =5745 , .hw_value =149 , }, + {.center_freq =5765 , .hw_value =153 , }, + {.center_freq =5785 , .hw_value =157 , }, + {.center_freq =5805 , .hw_value =161 , }, + {.center_freq =5825 , .hw_value =165 , }, +}; + +static struct ieee80211_supported_band nxpwifi_band_5ghz = { + .channels = nxpwifi_channels_5ghz, + .n_channels =ARRAY_SIZE (nxpwifi_channels_5ghz), + .bitrates = nxpwifi_rates +4 , + .n_bitrates =ARRAY_SIZE (nxpwifi_rates) -4 , +}; + +/* Supported crypto cipher suits to be advertised to cfg80211 */ +static const u32 nxpwifi_cipher_suites[] = { +WLAN_CIPHER_SUITE_WEP40 , +WLAN_CIPHER_SUITE_WEP104 , +WLAN_CIPHER_SUITE_TKIP , +WLAN_CIPHER_SUITE_CCMP , +WLAN_CIPHER_SUITE_SMS4 , +WLAN_CIPHER_SUITE_AES_CMAC , +}; + +/* Supported mgmt frame types to be advertised to cfg80211 */ +static const struct ieee80211_txrx_stypes +nxpwifi_mgmt_stypes[NUM_NL80211_IFTYPES ] = { + [NL80211_IFTYPE_STATION ] = { + .tx =BIT (IEEE80211_STYPE_ACTION >>4 ) | +BIT (IEEE80211_STYPE_PROBE_RESP >>4 ), + .rx =BIT (IEEE80211_STYPE_ACTION >>4 ) | +BIT (IEEE80211_STYPE_PROBE_REQ >>4 ), + }, + [NL80211_IFTYPE_AP ] = { + .tx =0xffff , + .rx =BIT (IEEE80211_STYPE_ASSOC_REQ >>4 ) | +BIT (IEEE80211_STYPE_REASSOC_REQ >>4 ) | +BIT (IEEE80211_STYPE_PROBE_REQ >>4 ) | +BIT (IEEE80211_STYPE_DISASSOC >>4 ) | +BIT (IEEE80211_STYPE_AUTH >>4 ) | +BIT (IEEE80211_STYPE_DEAUTH >>4 ) | +BIT (IEEE80211_STYPE_ACTION >>4 ), + }, +}; + +/* CFG802.11 operation handler for setting bit rates. +* +* Function configures data rates to firmware using bitrate mask +* provided by cfg80211. +*/ +static int +nxpwifi_cfg80211_set_bitrate_mask (struct wiphy *wiphy, +struct net_device *dev, +unsigned int link_id, +const u8 *peer, +const struct cfg80211_bitrate_mask *mask) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +u16 bitmap_rates[MAX_BITMAP_RATES_SIZE ]; +enum nl80211_band band; +struct nxpwifi_adapter *adapter = priv->adapter; + +if (!priv->media_connected) { +nxpwifi_dbg (adapter,ERROR , +"Can not set Tx data rate in disconnected state\n" ); +return -EINVAL ; + } + + band =nxpwifi_band_to_radio_type (priv->curr_bss_params.band); + +memset (bitmap_rates,0 ,sizeof (bitmap_rates)); + +/* Fill HR/DSSS rates. */ +if (band ==NL80211_BAND_2GHZ ) + bitmap_rates[0 ] = mask->control[band].legacy &0x000f ; + +/* Fill OFDM rates */ +if (band ==NL80211_BAND_2GHZ ) + bitmap_rates[1 ] = (mask->control[band].legacy &0x0ff0 ) >>4 ; +else + bitmap_rates[1 ] = mask->control[band].legacy; + +/* Fill HT MCS rates */ + bitmap_rates[2 ] = mask->control[band].ht_mcs[0 ]; +if (adapter->hw_dev_mcs_support ==HT_STREAM_2X2 ) + bitmap_rates[2 ] |= mask->control[band].ht_mcs[1 ] <<8 ; + +/* Fill VHT MCS rates */ +if (adapter->fw_api_ver ==NXPWIFI_FW_V15 ) { + bitmap_rates[10 ] = mask->control[band].vht_mcs[0 ]; +if (adapter->hw_dev_mcs_support ==HT_STREAM_2X2 ) + bitmap_rates[11 ] = mask->control[band].vht_mcs[1 ]; + } + +return nxpwifi_send_cmd (priv,HOST_CMD_TX_RATE_CFG , +HOST_ACT_GEN_SET ,0 , bitmap_rates, true); +} + +/* CFG802.11 operation handler for connection quality monitoring. +* +* This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI +* events to FW. +*/ +static int nxpwifi_cfg80211_set_cqm_rssi_config (struct wiphy *wiphy, +struct net_device *dev, +s32 rssi_thold,u32 rssi_hyst) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_ds_misc_subsc_evt subsc_evt; +int ret =0 ; + + priv->cqm_rssi_thold = rssi_thold; + priv->cqm_rssi_hyst = rssi_hyst; + +memset (&subsc_evt,0x00 ,sizeof (struct nxpwifi_ds_misc_subsc_evt )); + subsc_evt.events =BITMASK_BCN_RSSI_LOW |BITMASK_BCN_RSSI_HIGH ; + +/* Subscribe/unsubscribe low and high rssi events */ +if (rssi_thold && rssi_hyst) { + subsc_evt.action =HOST_ACT_BITWISE_SET ; + subsc_evt.bcn_l_rssi_cfg.abs_value =abs (rssi_thold); + subsc_evt.bcn_h_rssi_cfg.abs_value =abs (rssi_thold); + subsc_evt.bcn_l_rssi_cfg.evt_freq =1 ; + subsc_evt.bcn_h_rssi_cfg.evt_freq =1 ; + ret =nxpwifi_send_cmd (priv, +HOST_CMD_802_11_SUBSCRIBE_EVENT , +0 ,0 , &subsc_evt, true); + }else { + subsc_evt.action =HOST_ACT_BITWISE_CLR ; + ret =nxpwifi_send_cmd (priv, +HOST_CMD_802_11_SUBSCRIBE_EVENT , +0 ,0 , &subsc_evt, true); + } + +return ret; +} + +int nxpwifi_cfg80211_change_beacon_data (struct wiphy *wiphy, +struct net_device *dev, +struct cfg80211_beacon_data *data) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; + +nxpwifi_cancel_scan (adapter); + +if (GET_BSS_ROLE (priv) !=NXPWIFI_BSS_ROLE_UAP ) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: bss_type mismatched\n" , __func__); +return -EINVAL ; + } + + ret =nxpwifi_set_mgmt_ies (priv, data); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"%s: setting mgmt ies failed\n" , __func__); + +return ret; +} + +/* cfg80211 operation handler for change_beacon. +* Function retrieves and sets modified management IEs to FW. +*/ +static int nxpwifi_cfg80211_change_beacon (struct wiphy *wiphy, +struct net_device *dev, +struct cfg80211_ap_update *params) +{ +int ret; + + ret =nxpwifi_cfg80211_change_beacon_data (wiphy, dev, ¶ms->beacon); + +return ret; +} + +/* cfg80211 operation handler for del_station. +* Function deauthenticates station which value is provided in mac parameter. +* If mac is NULL/broadcast, all stations in associated station list are +* deauthenticated. If bss is not started or there are no stations in +* associated stations list, no action is taken. +*/ +static int +nxpwifi_cfg80211_del_station (struct wiphy *wiphy,struct net_device *dev, +struct station_del_parameters *params) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_sta_node *sta_node; +u8 deauth_mac[ETH_ALEN ]; +int ret =0 ; + +if (!priv->bss_started && priv->wdev.cac_started) { +nxpwifi_dbg (priv->adapter,INFO ,"%s: abort CAC!\n" , __func__); +nxpwifi_abort_cac (priv); + } + +if (list_empty (&priv->sta_list) || !priv->bss_started) +return 0 ; + +if (!params->mac ||is_broadcast_ether_addr (params->mac)) +return 0 ; + +nxpwifi_dbg (priv->adapter,INFO ,"%s: mac address %pM\n" , + __func__, params->mac); + +eth_zero_addr (deauth_mac); + +spin_lock_bh (&priv->sta_list_spinlock); + sta_node =nxpwifi_get_sta_entry (priv, params->mac); +if (sta_node) +ether_addr_copy (deauth_mac, params->mac); +spin_unlock_bh (&priv->sta_list_spinlock); + +if (is_valid_ether_addr (deauth_mac)) + ret =nxpwifi_send_cmd (priv,HOST_CMD_UAP_STA_DEAUTH , +HOST_ACT_GEN_SET ,0 , + deauth_mac, true); + +return ret; +} + +static int +nxpwifi_cfg80211_set_antenna (struct wiphy *wiphy,u32 tx_ant,u32 rx_ant) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter, +NXPWIFI_BSS_ROLE_ANY ); +struct nxpwifi_ds_ant_cfg ant_cfg; + +if (!tx_ant || !rx_ant) +return -EOPNOTSUPP ; + +if (adapter->hw_dev_mcs_support !=HT_STREAM_2X2 ) { +/* Not a MIMO chip. User should provide specific antenna number +* for Tx/Rx path or enable all antennas for diversity +*/ +if (tx_ant != rx_ant) +return -EOPNOTSUPP ; + +if ((tx_ant & (tx_ant -1 )) && + (tx_ant !=BIT (adapter->number_of_antenna) -1 )) +return -EOPNOTSUPP ; + +if ((tx_ant ==BIT (adapter->number_of_antenna) -1 ) && + priv->adapter->number_of_antenna >1 ) { + tx_ant =RF_ANTENNA_AUTO ; + rx_ant =RF_ANTENNA_AUTO ; + } + }else { +struct ieee80211_sta_ht_cap *ht_info; +int rx_mcs_supp; +enum nl80211_band band; + +if ((tx_ant ==0x1 && rx_ant ==0x1 )) { + adapter->user_dev_mcs_support =HT_STREAM_1X1 ; +if (adapter->is_hw_11ac_capable) + adapter->usr_dot_11ac_mcs_support = +NXPWIFI_11AC_MCS_MAP_1X1 ; + }else { + adapter->user_dev_mcs_support =HT_STREAM_2X2 ; +if (adapter->is_hw_11ac_capable) + adapter->usr_dot_11ac_mcs_support = +NXPWIFI_11AC_MCS_MAP_2X2 ; + } + +for (band =0 ; band <NUM_NL80211_BANDS ; band++) { +if (!adapter->wiphy->bands[band]) +continue ; + + ht_info = &adapter->wiphy->bands[band]->ht_cap; + rx_mcs_supp = +GET_RXMCSSUPP (adapter->user_dev_mcs_support); +memset (&ht_info->mcs,0 , adapter->number_of_antenna); +memset (&ht_info->mcs,0xff , rx_mcs_supp); + } + } + + ant_cfg.tx_ant = tx_ant; + ant_cfg.rx_ant = rx_ant; + +return nxpwifi_send_cmd (priv,HOST_CMD_RF_ANTENNA , +HOST_ACT_GEN_SET ,0 , &ant_cfg, true); +} + +static int +nxpwifi_cfg80211_get_antenna (struct wiphy *wiphy,u32 *tx_ant,u32 *rx_ant) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter, +NXPWIFI_BSS_ROLE_ANY ); +int ret; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_RF_ANTENNA , +HOST_ACT_GEN_GET ,0 ,NULL , true); + +if (!ret) { + *tx_ant = priv->tx_ant; + *rx_ant = priv->rx_ant; + } + +return ret; +} + +/* cfg80211 operation handler for stop ap. +* Function stops BSS running at uAP interface. +*/ +static int nxpwifi_cfg80211_stop_ap (struct wiphy *wiphy,struct net_device *dev, +unsigned int link_id) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +int ret; + +nxpwifi_abort_cac (priv); + +if (nxpwifi_del_mgmt_ies (priv)) +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to delete mgmt IEs!\n" ); + + priv->ap_11n_enabled =0 ; +memset (&priv->bss_cfg,0 ,sizeof (priv->bss_cfg)); + + ret =nxpwifi_send_cmd (priv,HOST_CMD_UAP_BSS_STOP , +HOST_ACT_GEN_SET ,0 ,NULL , true); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to stop the BSS\n" ); + goto done; + } + + ret =nxpwifi_send_cmd (priv,HOST_CMD_APCMD_SYS_RESET , +HOST_ACT_GEN_SET ,0 ,NULL , true); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to reset BSS\n" ); + goto done; + } + +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); +nxpwifi_stop_net_dev_queue (priv->netdev, priv->adapter); + +done: +return ret; +} + +/* cfg80211 operation handler for start_ap. +* Function sets beacon period, DTIM period, SSID and security into +* AP config structure. +* AP is configured with these settings and BSS is started. +*/ +static int nxpwifi_cfg80211_start_ap (struct wiphy *wiphy, +struct net_device *dev, +struct cfg80211_ap_settings *params) +{ +struct nxpwifi_uap_bss_param *bss_cfg; +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_private *tmp_priv; +int i; +struct nxpwifi_current_bss_params *bss_params; +enum nl80211_band band; +int freq; +int ret; + +if (GET_BSS_ROLE (priv) !=NXPWIFI_BSS_ROLE_UAP ) +return -EINVAL ; + +for (i =0 ; i <NXPWIFI_MAX_BSS_NUM ; i++) { + tmp_priv = adapter->priv[i]; +if (tmp_priv == priv) +continue ; +if (GET_BSS_ROLE (tmp_priv) ==NXPWIFI_BSS_ROLE_STA && + tmp_priv->media_connected) { + bss_params = &tmp_priv->curr_bss_params; + band =nxpwifi_band_to_radio_type (bss_params->band); + freq =ieee80211_channel_to_frequency + (bss_params->bss_descriptor.channel, band); +if (!ieee80211_channel_equal + (params->chandef.chan, +ieee80211_get_channel (wiphy, freq))) { +nxpwifi_dbg + (priv->adapter,MSG , +"AP and STA must operate on same channel\n" ); +return -EOPNOTSUPP ; + } + } + } + + bss_cfg =kzalloc (sizeof (*bss_cfg),GFP_KERNEL ); +if (!bss_cfg) +return -ENOMEM ; + +nxpwifi_set_sys_config_invalid_data (bss_cfg); + +memcpy (bss_cfg->mac_addr, priv->curr_addr,ETH_ALEN ); + +if (params->beacon_interval) + bss_cfg->beacon_period = params->beacon_interval; +if (params->dtim_period) + bss_cfg->dtim_period = params->dtim_period; + +if (params->ssid && params->ssid_len) { +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 : + bss_cfg->bcast_ssid_ctl =1 ; +break ; +case NL80211_HIDDEN_SSID_ZERO_LEN : + bss_cfg->bcast_ssid_ctl =0 ; +break ; +case NL80211_HIDDEN_SSID_ZERO_CONTENTS : + bss_cfg->bcast_ssid_ctl =2 ; +break ; +default : +kfree (bss_cfg); +return -EINVAL ; + } + +nxpwifi_uap_set_channel (priv, bss_cfg, params->chandef); +nxpwifi_set_uap_rates (bss_cfg, params); + + ret =nxpwifi_set_secure_params (priv, bss_cfg, params); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to parse security parameters!\n" ); + goto done; + } + +nxpwifi_set_ht_params (priv, bss_cfg, params); + +if (priv->adapter->is_hw_11ac_capable) { +nxpwifi_set_vht_params (priv, bss_cfg, params); +nxpwifi_set_vht_width (priv, params->chandef.width, + priv->ap_11ac_enabled); + } + +if (priv->ap_11ac_enabled) +nxpwifi_set_11ac_ba_params (priv); +else +nxpwifi_set_ba_params (priv); + +nxpwifi_set_wmm_params (priv, bss_cfg, params); + +if (nxpwifi_is_11h_active (priv)) +nxpwifi_set_tpc_params (priv, bss_cfg, params); + +if (nxpwifi_is_11h_active (priv) && + !cfg80211_chandef_dfs_required (wiphy, ¶ms->chandef, + priv->bss_mode)) { +nxpwifi_dbg (priv->adapter,INFO , +"Disable 11h extensions in FW\n" ); + ret =nxpwifi_11h_activate (priv, false); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to disable 11h extensions!!" ); + goto done; + } + priv->state_11h.is_11h_active = false; + } + +nxpwifi_config_uap_11d (priv, ¶ms->beacon); + + ret =nxpwifi_config_start_uap (priv, bss_cfg); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to start AP\n" ); + goto done; + } + + ret =nxpwifi_set_mgmt_ies (priv, ¶ms->beacon); +if (ret) + goto done; + +if (!netif_carrier_ok (priv->netdev)) +netif_carrier_on (priv->netdev); +nxpwifi_wake_up_net_dev_queue (priv->netdev, priv->adapter); + +memcpy (&priv->bss_cfg, bss_cfg,sizeof (priv->bss_cfg)); + +done: +kfree (bss_cfg); +return ret; +} + +/* CFG802.11 operation handler for scan request. +* +* This function issues a scan request to the firmware based upon +* the user specified scan configuration. On successful completion, +* it also informs the results. +*/ +static int +nxpwifi_cfg80211_scan (struct wiphy *wiphy, +struct cfg80211_scan_request *request) +{ +struct net_device *dev = request->wdev->netdev; +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +int i, offset, ret; +struct ieee80211_channel *chan; +struct element *ie; +struct nxpwifi_user_scan_cfg *user_scan_cfg; +u8 mac_addr[ETH_ALEN ]; + +nxpwifi_dbg (priv->adapter,CMD , +"info: received scan request on %s\n" , dev->name); + +/* Block scan request if scan operation or scan cleanup when interface +* is disabled is in process +*/ +if (priv->scan_request || priv->scan_aborting) { +nxpwifi_dbg (priv->adapter,WARN , +"cmd: Scan already in process..\n" ); +return -EBUSY ; + } + +if (!priv->wdev.connected && priv->scan_block) + priv->scan_block = false; + +if (!nxpwifi_stop_bg_scan (priv)) +cfg80211_sched_scan_stopped_locked (priv->wdev.wiphy,0 ); + + user_scan_cfg =kzalloc (sizeof (*user_scan_cfg),GFP_KERNEL ); +if (!user_scan_cfg) +return -ENOMEM ; + + priv->scan_request = request; + +if (request->flags &NL80211_SCAN_FLAG_RANDOM_ADDR ) { +get_random_mask_addr (mac_addr, request->mac_addr, + request->mac_addr_mask); +ether_addr_copy (request->mac_addr, mac_addr); +ether_addr_copy (user_scan_cfg->random_mac, mac_addr); + } + + user_scan_cfg->num_ssids = request->n_ssids; + user_scan_cfg->ssid_list = request->ssids; + +if (request->ie && request->ie_len) { + offset =0 ; +for (i =0 ; i <NXPWIFI_MAX_VSIE_NUM ; i++) { +if (priv->vs_ie[i].mask !=NXPWIFI_VSIE_MASK_CLEAR ) +continue ; + priv->vs_ie[i].mask =NXPWIFI_VSIE_MASK_SCAN ; + ie = (struct element *)(request->ie + offset); +memcpy (&priv->vs_ie[i].ie, ie, +sizeof (*ie) + ie->datalen); + offset +=sizeof (*ie) + ie->datalen; + +if (offset >= request->ie_len) +break ; + } + } + +for (i =0 ; i <min_t (u32, request->n_channels, +NXPWIFI_USER_SCAN_CHAN_MAX ); i++) { + chan = request->channels[i]; + user_scan_cfg->chan_list[i].chan_number = chan->hw_value; + user_scan_cfg->chan_list[i].radio_type = chan->band; + +if ((chan->flags &IEEE80211_CHAN_NO_IR ) || !request->n_ssids) + user_scan_cfg->chan_list[i].scan_type = +NXPWIFI_SCAN_TYPE_PASSIVE ; +else + user_scan_cfg->chan_list[i].scan_type = +NXPWIFI_SCAN_TYPE_ACTIVE ; + + user_scan_cfg->chan_list[i].scan_time =0 ; + } + +if (priv->adapter->scan_chan_gap_enabled && +nxpwifi_is_any_intf_active (priv)) + user_scan_cfg->scan_chan_gap = + priv->adapter->scan_chan_gap_time; + + ret =nxpwifi_scan_networks (priv, user_scan_cfg); +kfree (user_scan_cfg); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"scan failed: %d\n" , ret); + priv->scan_aborting = false; + priv->scan_request =NULL ; +return ret; + } + +if (request->ie && request->ie_len) { +for (i =0 ; i <NXPWIFI_MAX_VSIE_NUM ; i++) { +if (priv->vs_ie[i].mask ==NXPWIFI_VSIE_MASK_SCAN ) { + priv->vs_ie[i].mask =NXPWIFI_VSIE_MASK_CLEAR ; +memset (&priv->vs_ie[i].ie,0 , +NXPWIFI_MAX_VSIE_LEN ); + } + } + } +return 0 ; +} + +/* CFG802.11 operation handler for sched_scan_start. +* +* This function issues a bgscan config request to the firmware based upon +* the user specified sched_scan configuration. On successful completion, +* firmware will generate BGSCAN_REPORT event, driver should issue bgscan +* query command to get sched_scan results from firmware. +*/ +static int +nxpwifi_cfg80211_sched_scan_start (struct wiphy *wiphy, +struct net_device *dev, +struct cfg80211_sched_scan_request *request) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +int i, offset; +struct ieee80211_channel *chan; +struct nxpwifi_bg_scan_cfg *bgscan_cfg; +struct element *ie; +int ret; + +if (!request || (!request->n_ssids && !request->n_match_sets)) { +wiphy_err (wiphy,"%s : Invalid Sched_scan parameters" , + __func__); +return -EINVAL ; + } + +wiphy_info (wiphy,"sched_scan start : n_ssids=%d n_match_sets=%d " , + request->n_ssids, request->n_match_sets); +wiphy_info (wiphy,"n_channels=%d interval=%d ie_len=%d\n" , + request->n_channels, request->scan_plans->interval, + (int )request->ie_len); + + bgscan_cfg =kzalloc (sizeof (*bgscan_cfg),GFP_KERNEL ); +if (!bgscan_cfg) +return -ENOMEM ; + +if (priv->scan_request || priv->scan_aborting) + bgscan_cfg->start_later = true; + + bgscan_cfg->num_ssids = request->n_match_sets; + bgscan_cfg->ssid_list = request->match_sets; + +if (request->ie && request->ie_len) { + offset =0 ; +for (i =0 ; i <NXPWIFI_MAX_VSIE_NUM ; i++) { +if (priv->vs_ie[i].mask !=NXPWIFI_VSIE_MASK_CLEAR ) +continue ; + priv->vs_ie[i].mask =NXPWIFI_VSIE_MASK_BGSCAN ; + ie = (struct element *)(request->ie + offset); +memcpy (&priv->vs_ie[i].ie, ie, +sizeof (*ie) + ie->datalen); + offset +=sizeof (*ie) + ie->datalen; + +if (offset >= request->ie_len) +break ; + } + } + +for (i =0 ; i <min_t (u32, request->n_channels, +NXPWIFI_BG_SCAN_CHAN_MAX ); i++) { + chan = request->channels[i]; + bgscan_cfg->chan_list[i].chan_number = chan->hw_value; + bgscan_cfg->chan_list[i].radio_type = chan->band; + +if ((chan->flags &IEEE80211_CHAN_NO_IR ) || !request->n_ssids) + bgscan_cfg->chan_list[i].scan_type = +NXPWIFI_SCAN_TYPE_PASSIVE ; +else + bgscan_cfg->chan_list[i].scan_type = +NXPWIFI_SCAN_TYPE_ACTIVE ; + + bgscan_cfg->chan_list[i].scan_time =0 ; + } + + bgscan_cfg->chan_per_scan =min_t (u32, request->n_channels, +NXPWIFI_BG_SCAN_CHAN_MAX ); + +/* Use at least 15 second for per scan cycle */ + bgscan_cfg->scan_interval = (request->scan_plans->interval > +NXPWIFI_BGSCAN_INTERVAL ) ? + request->scan_plans->interval : +NXPWIFI_BGSCAN_INTERVAL ; + + bgscan_cfg->repeat_count =NXPWIFI_BGSCAN_REPEAT_COUNT ; + bgscan_cfg->report_condition =NXPWIFI_BGSCAN_SSID_MATCH | +NXPWIFI_BGSCAN_WAIT_ALL_CHAN_DONE ; + bgscan_cfg->bss_type =NXPWIFI_BSS_MODE_INFRA ; + bgscan_cfg->action =NXPWIFI_BGSCAN_ACT_SET ; + bgscan_cfg->enable = true; +if (request->min_rssi_thold !=NL80211_SCAN_RSSI_THOLD_OFF ) { + bgscan_cfg->report_condition |=NXPWIFI_BGSCAN_SSID_RSSI_MATCH ; + bgscan_cfg->rssi_threshold = request->min_rssi_thold; + } + + ret =nxpwifi_send_cmd (priv,HOST_CMD_802_11_BG_SCAN_CONFIG , +HOST_ACT_GEN_SET ,0 , bgscan_cfg, true); + +if (!ret) + priv->sched_scanning = true; + +kfree (bgscan_cfg); +return ret; +} + +/* CFG802.11 operation handler for sched_scan_stop. +* +* This function issues a bgscan config command to disable +* previous bgscan configuration in the firmware +*/ +static int nxpwifi_cfg80211_sched_scan_stop (struct wiphy *wiphy, +struct net_device *dev,u64 reqid) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +wiphy_info (wiphy,"sched scan stop!" ); +return nxpwifi_stop_bg_scan (priv); +} + +static void nxpwifi_setup_vht_caps (struct ieee80211_sta_vht_cap *vht_info, +struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; + + vht_info->vht_supported = true; + + vht_info->cap = adapter->hw_dot_11ac_dev_cap; +/* Update MCS support for VHT */ + vht_info->vht_mcs.rx_mcs_map = +cpu_to_le16 (adapter->hw_dot_11ac_mcs_support &0xFFFF ); + vht_info->vht_mcs.rx_highest =0 ; + vht_info->vht_mcs.tx_mcs_map = +cpu_to_le16 (adapter->hw_dot_11ac_mcs_support >>16 ); + vht_info->vht_mcs.tx_highest =0 ; +} + +/* This function sets up the CFG802.11 specific HT capability fields +* with default values. +* +* The following default values are set - +* - HT Supported = True +* - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K +* - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE +* - HT Capabilities supported by firmware +* - MCS information, Rx mask = 0xff +* - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01) +*/ +static void +nxpwifi_setup_ht_caps (struct ieee80211_sta_ht_cap *ht_info, +struct nxpwifi_private *priv) +{ +int rx_mcs_supp; +struct ieee80211_mcs_info mcs_set; +u8 *mcs = (u8 *)&mcs_set; +struct nxpwifi_adapter *adapter = priv->adapter; + + ht_info->ht_supported = true; + ht_info->ampdu_factor =IEEE80211_HT_MAX_AMPDU_64K ; + ht_info->ampdu_density =IEEE80211_HT_MPDU_DENSITY_NONE ; + +memset (&ht_info->mcs,0 ,sizeof (ht_info->mcs)); + +/* Fill HT capability information */ +if (ISSUPP_CHANWIDTH40 (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_SUP_WIDTH_20_40 ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40 ; + +if (ISSUPP_SHORTGI20 (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_SGI_20 ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20 ; + +if (ISSUPP_SHORTGI40 (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_SGI_40 ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40 ; + +if (adapter->user_dev_mcs_support ==HT_STREAM_2X2 ) + ht_info->cap |=2 <<IEEE80211_HT_CAP_RX_STBC_SHIFT ; +else + ht_info->cap |=1 <<IEEE80211_HT_CAP_RX_STBC_SHIFT ; + +if (ISSUPP_TXSTBC (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_TX_STBC ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC ; + +if (ISSUPP_GREENFIELD (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_GRN_FLD ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_GRN_FLD ; + +if (ISENABLED_40MHZ_INTOLERANT (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_40MHZ_INTOLERANT ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT ; + +if (ISSUPP_RXLDPC (adapter->hw_dot_11n_dev_cap)) + ht_info->cap |=IEEE80211_HT_CAP_LDPC_CODING ; +else + ht_info->cap &= ~IEEE80211_HT_CAP_LDPC_CODING ; + + ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU ; + ht_info->cap |=IEEE80211_HT_CAP_SM_PS ; + + rx_mcs_supp =GET_RXMCSSUPP (adapter->user_dev_mcs_support); +/* Set MCS for 1x1/2x2 */ +memset (mcs,0xff , rx_mcs_supp); +/* Clear all the other values */ +memset (&mcs[rx_mcs_supp],0 , +sizeof (struct ieee80211_mcs_info ) - rx_mcs_supp); +if (priv->bss_mode ==NL80211_IFTYPE_STATION || +ISSUPP_CHANWIDTH40 (adapter->hw_dot_11n_dev_cap)) +/* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */ +SETHT_MCS32 (mcs_set.rx_mask); + +memcpy ((u8 *)&ht_info->mcs, mcs,sizeof (struct ieee80211_mcs_info )); + + ht_info->mcs.tx_params =IEEE80211_HT_MCS_TX_DEFINED ; +} + +/* create a new virtual interface with the given name and name assign type +*/ +struct wireless_dev *nxpwifi_add_virtual_intf (struct wiphy *wiphy, +const char *name, +unsigned char name_assign_type, +enum nl80211_iftype type, +struct vif_params *params) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv; +struct net_device *dev; +void *mdev_priv; +int ret; + +if (!adapter) +return ERR_PTR (-EFAULT ); + +switch (type) { +case NL80211_IFTYPE_UNSPECIFIED : +case NL80211_IFTYPE_STATION : +if (adapter->curr_iface_comb.sta_intf == + adapter->iface_limit.sta_intf) { +nxpwifi_dbg (adapter,ERROR , +"cannot create multiple sta ifaces\n" ); +return ERR_PTR (-EINVAL ); + } + + priv =nxpwifi_get_unused_priv_by_bss_type + (adapter,NXPWIFI_BSS_TYPE_STA ); +if (!priv) { +nxpwifi_dbg (adapter,ERROR , +"could not get free private struct\n" ); +return ERR_PTR (-EFAULT ); + } + + priv->wdev.wiphy = wiphy; + priv->wdev.iftype =NL80211_IFTYPE_STATION ; + +if (type ==NL80211_IFTYPE_UNSPECIFIED ) + priv->bss_mode =NL80211_IFTYPE_STATION ; +else + priv->bss_mode = type; + + priv->bss_type =NXPWIFI_BSS_TYPE_STA ; + priv->frame_type =NXPWIFI_DATA_FRAME_TYPE_ETH_II ; + priv->bss_priority =0 ; + priv->bss_role =NXPWIFI_BSS_ROLE_STA ; + +break ; +case NL80211_IFTYPE_AP : +if (adapter->curr_iface_comb.uap_intf == + adapter->iface_limit.uap_intf) { +nxpwifi_dbg (adapter,ERROR , +"cannot create multiple AP ifaces\n" ); +return ERR_PTR (-EINVAL ); + } + + priv =nxpwifi_get_unused_priv_by_bss_type + (adapter,NXPWIFI_BSS_TYPE_UAP ); +if (!priv) { +nxpwifi_dbg (adapter,ERROR , +"could not get free private struct\n" ); +return ERR_PTR (-EFAULT ); + } + + priv->wdev.wiphy = wiphy; + priv->wdev.iftype =NL80211_IFTYPE_AP ; + + priv->bss_type =NXPWIFI_BSS_TYPE_UAP ; + priv->frame_type =NXPWIFI_DATA_FRAME_TYPE_ETH_II ; + priv->bss_priority =0 ; + priv->bss_role =NXPWIFI_BSS_ROLE_UAP ; + priv->bss_started =0 ; + priv->bss_mode = type; + +break ; +default : +nxpwifi_dbg (adapter,ERROR ,"type not supported\n" ); +return ERR_PTR (-EINVAL ); + } + + dev =alloc_netdev_mqs (sizeof (struct nxpwifi_private *), name, + name_assign_type, ether_setup, +IEEE80211_NUM_ACS ,1 ); +if (!dev) { +nxpwifi_dbg (adapter,ERROR , +"no memory available for netdevice\n" ); + ret = -ENOMEM ; + goto err_alloc_netdev; + } + +nxpwifi_init_priv_params (priv, dev); + + priv->netdev = dev; + +nxpwifi_set_mac_address (priv, dev, false,NULL ); + + ret =nxpwifi_send_cmd (priv,HOST_CMD_SET_BSS_MODE , +HOST_ACT_GEN_SET ,0 ,NULL , true); +if (ret) + goto err_set_bss_mode; + + ret =nxpwifi_sta_init_cmd (priv, false, false); +if (ret) + goto err_sta_init; + +nxpwifi_setup_ht_caps (&wiphy->bands[NL80211_BAND_2GHZ ]->ht_cap, priv); +if (adapter->is_hw_11ac_capable) +nxpwifi_setup_vht_caps + (&wiphy->bands[NL80211_BAND_2GHZ ]->vht_cap, priv); + +if (adapter->config_bands &BAND_A ) +nxpwifi_setup_ht_caps + (&wiphy->bands[NL80211_BAND_5GHZ ]->ht_cap, priv); + +if ((adapter->config_bands &BAND_A ) && adapter->is_hw_11ac_capable) +nxpwifi_setup_vht_caps + (&wiphy->bands[NL80211_BAND_5GHZ ]->vht_cap, priv); + +dev_net_set (dev,wiphy_net (wiphy)); + dev->ieee80211_ptr = &priv->wdev; + dev->ieee80211_ptr->iftype = priv->bss_mode; +SET_NETDEV_DEV (dev,wiphy_dev (wiphy)); + + dev->flags |=IFF_BROADCAST |IFF_MULTICAST ; + dev->watchdog_timeo =NXPWIFI_DEFAULT_WATCHDOG_TIMEOUT ; + dev->needed_headroom =NXPWIFI_MIN_DATA_HEADER_LEN ; + dev->ethtool_ops = &nxpwifi_ethtool_ops; + + mdev_priv =netdev_priv (dev); + *((unsigned long *)mdev_priv) = (unsigned long )priv; + +SET_NETDEV_DEV (dev, adapter->dev); + +INIT_DELAYED_WORK (&priv->dfs_cac_work, nxpwifi_dfs_cac_work); + +INIT_DELAYED_WORK (&priv->dfs_chan_sw_work, nxpwifi_dfs_chan_sw_work); + +/* Register network device */ +if (cfg80211_register_netdevice (dev)) { +nxpwifi_dbg (adapter,ERROR ,"cannot register network device\n" ); + ret = -EFAULT ; + goto err_reg_netdev; + } + +nxpwifi_dbg (adapter,INFO , +"info: %s: NXP 802.11 Adapter\n" , dev->name); + +#ifdef CONFIG_DEBUG_FS +nxpwifi_dev_debugfs_init (priv); +#endif + +update_vif_type_counter (adapter, type,1 ); + +return &priv->wdev; + +err_reg_netdev: +free_netdev (dev); + priv->netdev =NULL ; +err_sta_init: +err_set_bss_mode: +err_alloc_netdev: +memset (&priv->wdev,0 ,sizeof (priv->wdev)); + priv->wdev.iftype =NL80211_IFTYPE_UNSPECIFIED ; + priv->bss_mode =NL80211_IFTYPE_UNSPECIFIED ; +return ERR_PTR (ret); +} +EXPORT_SYMBOL_GPL (nxpwifi_add_virtual_intf); + +/* del_virtual_intf: remove the virtual interface determined by dev +*/ +int nxpwifi_del_virtual_intf (struct wiphy *wiphy,struct wireless_dev *wdev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (wdev->netdev); +struct nxpwifi_adapter *adapter = priv->adapter; +struct sk_buff *skb, *tmp; + +#ifdef CONFIG_DEBUG_FS +nxpwifi_dev_debugfs_remove (priv); +#endif + +if (priv->sched_scanning) + priv->sched_scanning = false; + +nxpwifi_stop_net_dev_queue (priv->netdev, adapter); + + skb_queue_walk_safe(&priv->bypass_txq, skb, tmp) { +skb_unlink (skb, &priv->bypass_txq); +nxpwifi_write_data_complete (priv->adapter, skb,0 ,-1 ); + } + +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); + +if (wdev->netdev->reg_state ==NETREG_REGISTERED ) +cfg80211_unregister_netdevice (wdev->netdev); + +/* Clear the priv in adapter */ + priv->netdev =NULL ; + +update_vif_type_counter (adapter, priv->bss_mode,-1 ); + + priv->bss_mode =NL80211_IFTYPE_UNSPECIFIED ; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA || +GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) +kfree (priv->hist_data); + +return 0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_del_virtual_intf); + +static bool +nxpwifi_is_pattern_supported (struct cfg80211_pkt_pattern *pat,s8 *byte_seq, +u8 max_byte_seq) +{ +int j, k, valid_byte_cnt =0 ; +bool dont_care_byte = false; + +for (j =0 ; j <DIV_ROUND_UP (pat->pattern_len,8 ); j++) { +for (k =0 ; k <8 ; k++) { +if (pat->mask[j] &1 << k) { +memcpy (byte_seq + valid_byte_cnt, + &pat->pattern[j *8 + k],1 ); + valid_byte_cnt++; +if (dont_care_byte) +return false; + }else { +if (valid_byte_cnt) + dont_care_byte = true; + } + +/* wildcard bytes record as the offset +* before the valid byte +*/ +if (!valid_byte_cnt && !dont_care_byte) + pat->pkt_offset++; + +if (valid_byte_cnt > max_byte_seq) +return false; + } + } + + byte_seq[max_byte_seq] = valid_byte_cnt; + +return true; +} + +#ifdef CONFIG_PM +static void nxpwifi_set_auto_arp_mef_entry (struct nxpwifi_private *priv, +struct nxpwifi_mef_entry *mef_entry) +{ +int i, filt_num =0 , num_ipv4 =0 ; +struct in_device *in_dev; +struct in_ifaddr *ifa; +__be32 ips[NXPWIFI_MAX_SUPPORTED_IPADDR ]; +struct nxpwifi_adapter *adapter = priv->adapter; + + mef_entry->mode =MEF_MODE_HOST_SLEEP ; + mef_entry->action =MEF_ACTION_AUTO_ARP ; + +/* Enable ARP offload feature */ +memset (ips,0 ,sizeof (ips)); +for (i =0 ; i <NXPWIFI_MAX_BSS_NUM ; i++) { +if (adapter->priv[i]->netdev) { + in_dev =__in_dev_get_rtnl (adapter->priv[i]->netdev); +if (!in_dev) +continue ; + ifa =rtnl_dereference (in_dev->ifa_list); +if (!ifa || !ifa->ifa_local) +continue ; + ips[i] = ifa->ifa_local; + num_ipv4++; + } + } + +for (i =0 ; i < num_ipv4; i++) { +if (!ips[i]) +continue ; + mef_entry->filter[filt_num].repeat =1 ; +memcpy (mef_entry->filter[filt_num].byte_seq, + (u8 *)&ips[i],sizeof (ips[i])); + mef_entry->filter[filt_num].byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] = +sizeof (ips[i]); + mef_entry->filter[filt_num].offset =46 ; + mef_entry->filter[filt_num].filt_type =TYPE_EQ ; +if (filt_num) { + mef_entry->filter[filt_num].filt_action = +TYPE_OR ; + } + filt_num++; + } + + mef_entry->filter[filt_num].repeat =1 ; + mef_entry->filter[filt_num].byte_seq[0 ] =0x08 ; + mef_entry->filter[filt_num].byte_seq[1 ] =0x06 ; + mef_entry->filter[filt_num].byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] =2 ; + mef_entry->filter[filt_num].offset =20 ; + mef_entry->filter[filt_num].filt_type =TYPE_EQ ; + mef_entry->filter[filt_num].filt_action =TYPE_AND ; +} + +static int nxpwifi_set_wowlan_mef_entry (struct nxpwifi_private *priv, +struct nxpwifi_ds_mef_cfg *mef_cfg, +struct nxpwifi_mef_entry *mef_entry, +struct cfg80211_wowlan *wowlan) +{ +int i, filt_num =0 , ret =0 ; +bool first_pat = true; +u8 byte_seq[NXPWIFI_MEF_MAX_BYTESEQ +1 ]; +static const u8 ipv4_mc_mac[] = {0x33 ,0x33 }; +static const u8 ipv6_mc_mac[] = {0x01 ,0x00 ,0x5e }; + + mef_entry->mode =MEF_MODE_HOST_SLEEP ; + mef_entry->action =MEF_ACTION_ALLOW_AND_WAKEUP_HOST ; + +for (i =0 ; i < wowlan->n_patterns; i++) { +memset (byte_seq,0 ,sizeof (byte_seq)); +if (!nxpwifi_is_pattern_supported + (&wowlan->patterns[i], byte_seq, +NXPWIFI_MEF_MAX_BYTESEQ )) { +nxpwifi_dbg (priv->adapter,ERROR , +"Pattern not supported\n" ); +return -EOPNOTSUPP ; + } + +if (!wowlan->patterns[i].pkt_offset) { +if (is_unicast_ether_addr (byte_seq) && + byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] ==1 ) { + mef_cfg->criteria |=NXPWIFI_CRITERIA_UNICAST ; +continue ; + }else if (is_broadcast_ether_addr (byte_seq)) { + mef_cfg->criteria |=NXPWIFI_CRITERIA_BROADCAST ; +continue ; + }else if ((!memcmp (byte_seq, ipv4_mc_mac,2 ) && + (byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] ==2 )) || + (!memcmp (byte_seq, ipv6_mc_mac,3 ) && + (byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] ==3 ))) { + mef_cfg->criteria |=NXPWIFI_CRITERIA_MULTICAST ; +continue ; + } + } + mef_entry->filter[filt_num].repeat =1 ; + mef_entry->filter[filt_num].offset = + wowlan->patterns[i].pkt_offset; +memcpy (mef_entry->filter[filt_num].byte_seq, byte_seq, +sizeof (byte_seq)); + mef_entry->filter[filt_num].filt_type =TYPE_EQ ; + +if (first_pat) { + first_pat = false; +nxpwifi_dbg (priv->adapter,INFO ,"Wake on patterns\n" ); + }else { + mef_entry->filter[filt_num].filt_action =TYPE_AND ; + } + + filt_num++; + } + +if (wowlan->magic_pkt) { + mef_cfg->criteria |=NXPWIFI_CRITERIA_UNICAST ; + mef_entry->filter[filt_num].repeat =16 ; +memcpy (mef_entry->filter[filt_num].byte_seq, priv->curr_addr, +ETH_ALEN ); + mef_entry->filter[filt_num].byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] = +ETH_ALEN ; + mef_entry->filter[filt_num].offset =28 ; + mef_entry->filter[filt_num].filt_type =TYPE_EQ ; +if (filt_num) + mef_entry->filter[filt_num].filt_action =TYPE_OR ; + + filt_num++; + mef_entry->filter[filt_num].repeat =16 ; +memcpy (mef_entry->filter[filt_num].byte_seq, priv->curr_addr, +ETH_ALEN ); + mef_entry->filter[filt_num].byte_seq[NXPWIFI_MEF_MAX_BYTESEQ ] = +ETH_ALEN ; + mef_entry->filter[filt_num].offset =56 ; + mef_entry->filter[filt_num].filt_type =TYPE_EQ ; + mef_entry->filter[filt_num].filt_action =TYPE_OR ; +nxpwifi_dbg (priv->adapter,INFO ,"Wake on magic packet\n" ); + } +return ret; +} + +static int nxpwifi_set_mef_filter (struct nxpwifi_private *priv, +struct cfg80211_wowlan *wowlan) +{ +int ret =0 , num_entries =1 ; +struct nxpwifi_ds_mef_cfg mef_cfg; +struct nxpwifi_mef_entry *mef_entry; + +if (wowlan->n_patterns || wowlan->magic_pkt) + num_entries++; + + mef_entry =kcalloc (num_entries,sizeof (*mef_entry),GFP_KERNEL ); +if (!mef_entry) +return -ENOMEM ; + +memset (&mef_cfg,0 ,sizeof (mef_cfg)); + mef_cfg.criteria |=NXPWIFI_CRITERIA_BROADCAST | +NXPWIFI_CRITERIA_UNICAST ; + mef_cfg.num_entries = num_entries; + mef_cfg.mef_entry = mef_entry; + +nxpwifi_set_auto_arp_mef_entry (priv, &mef_entry[0 ]); + +if (wowlan->n_patterns || wowlan->magic_pkt) { + ret =nxpwifi_set_wowlan_mef_entry (priv, &mef_cfg, + &mef_entry[1 ], wowlan); +if (ret) + goto done; + } + +if (!mef_cfg.criteria) + mef_cfg.criteria =NXPWIFI_CRITERIA_BROADCAST | +NXPWIFI_CRITERIA_UNICAST | +NXPWIFI_CRITERIA_MULTICAST ; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_MEF_CFG ,HOST_ACT_GEN_SET ,0 , + &mef_cfg, true); + +done: +kfree (mef_entry); +return ret; +} + +static int nxpwifi_cfg80211_suspend (struct wiphy *wiphy, +struct cfg80211_wowlan *wowlan) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_ds_hs_cfg hs_cfg; +int i, ret =0 , retry_num =10 ; +struct nxpwifi_private *priv; +struct nxpwifi_private *sta_priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); + + sta_priv->scan_aborting = true; +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +nxpwifi_abort_cac (priv); + } + +nxpwifi_cancel_all_pending_cmd (adapter); + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv && priv->netdev) +netif_device_detach (priv->netdev); + } + +for (i =0 ; i < retry_num; i++) { +if (!nxpwifi_wmm_lists_empty (adapter) || + !nxpwifi_bypass_txlist_empty (adapter) || + !skb_queue_empty (&adapter->tx_data_q)) +usleep_range (10000 ,15000 ); +else +break ; + } + +if (!wowlan) { +nxpwifi_dbg (adapter,INFO , +"None of the WOWLAN triggers enabled\n" ); + ret =0 ; + goto done; + } + +if (!sta_priv->media_connected && !wowlan->nd_config) { +nxpwifi_dbg (adapter,ERROR , +"Can not configure WOWLAN in disconnected state\n" ); + ret =0 ; + goto done; + } + + ret =nxpwifi_set_mef_filter (sta_priv, wowlan); +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"Failed to set MEF filter\n" ); + goto done; + } + +memset (&hs_cfg,0 ,sizeof (hs_cfg)); + hs_cfg.conditions =le32_to_cpu (adapter->hs_cfg.conditions); + +if (wowlan->nd_config) { +nxpwifi_dbg (adapter,INFO ,"Wake on net detect\n" ); + hs_cfg.conditions |=HS_CFG_COND_MAC_EVENT ; +nxpwifi_cfg80211_sched_scan_start (wiphy, sta_priv->netdev, + wowlan->nd_config); + } + +if (wowlan->disconnect) { + hs_cfg.conditions |=HS_CFG_COND_MAC_EVENT ; +nxpwifi_dbg (sta_priv->adapter,INFO ,"Wake on device disconnect\n" ); + } + + hs_cfg.is_invoke_hostcmd = false; + hs_cfg.gpio = adapter->hs_cfg.gpio; + hs_cfg.gap = adapter->hs_cfg.gap; + ret =nxpwifi_set_hs_params (sta_priv,HOST_ACT_GEN_SET , +NXPWIFI_SYNC_CMD , &hs_cfg); +if (ret) +nxpwifi_dbg (adapter,ERROR ,"Failed to set HS params\n" ); + +done: + sta_priv->scan_aborting = false; +return ret; +} + +static int nxpwifi_cfg80211_resume (struct wiphy *wiphy) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +struct nxpwifi_private *priv; +struct nxpwifi_ds_wakeup_reason wakeup_reason; +struct cfg80211_wowlan_wakeup wakeup_report; +int i; +bool report_wakeup_reason = true; + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv && priv->netdev) +netif_device_attach (priv->netdev); + } + +if (!wiphy->wowlan_config) + goto done; + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); +nxpwifi_get_wakeup_reason (priv,HOST_ACT_GEN_GET ,NXPWIFI_SYNC_CMD , + &wakeup_reason); +memset (&wakeup_report,0 ,sizeof (struct cfg80211_wowlan_wakeup )); + + wakeup_report.pattern_idx =-1 ; + +switch (wakeup_reason.hs_wakeup_reason) { +case NO_HSWAKEUP_REASON : +break ; +case BCAST_DATA_MATCHED : +break ; +case MCAST_DATA_MATCHED : +break ; +case UCAST_DATA_MATCHED : +break ; +case MASKTABLE_EVENT_MATCHED : +break ; +case NON_MASKABLE_EVENT_MATCHED : +if (wiphy->wowlan_config->disconnect) + wakeup_report.disconnect = true; +if (wiphy->wowlan_config->nd_config) + wakeup_report.net_detect = adapter->nd_info; +break ; +case NON_MASKABLE_CONDITION_MATCHED : +break ; +case MAGIC_PATTERN_MATCHED : +if (wiphy->wowlan_config->magic_pkt) + wakeup_report.magic_pkt = true; +if (wiphy->wowlan_config->n_patterns) + wakeup_report.pattern_idx =1 ; +break ; +case GTK_REKEY_FAILURE : +if (wiphy->wowlan_config->gtk_rekey_failure) + wakeup_report.gtk_rekey_failure = true; +break ; +default : + report_wakeup_reason = false; +break ; + } + +if (report_wakeup_reason) +cfg80211_report_wowlan_wakeup (&priv->wdev, &wakeup_report, +GFP_KERNEL ); + +done: +if (adapter->nd_info) { +for (i =0 ; i < adapter->nd_info->n_matches ; i++) +kfree (adapter->nd_info->matches[i]); +kfree (adapter->nd_info); + adapter->nd_info =NULL ; + } + +return 0 ; +} + +static void nxpwifi_cfg80211_set_wakeup (struct wiphy *wiphy, +bool enabled) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); + +device_set_wakeup_enable (adapter->dev, enabled); +} +#endif + +static int nxpwifi_get_coalesce_pkt_type (u8 *byte_seq) +{ +static const u8 ipv4_mc_mac[] = {0x33 ,0x33 }; +static const u8 ipv6_mc_mac[] = {0x01 ,0x00 ,0x5e }; +static const u8 bc_mac[] = {0xff ,0xff ,0xff ,0xff }; + +if ((byte_seq[0 ] &0x01 ) && + byte_seq[NXPWIFI_COALESCE_MAX_BYTESEQ ] ==1 ) +return PACKET_TYPE_UNICAST ; +else if (!memcmp (byte_seq, bc_mac,4 )) +return PACKET_TYPE_BROADCAST ; +else if ((!memcmp (byte_seq, ipv4_mc_mac,2 ) && + byte_seq[NXPWIFI_COALESCE_MAX_BYTESEQ ] ==2 ) || + (!memcmp (byte_seq, ipv6_mc_mac,3 ) && + byte_seq[NXPWIFI_COALESCE_MAX_BYTESEQ ] ==3 )) +return PACKET_TYPE_MULTICAST ; + +return 0 ; +} + +static int +nxpwifi_fill_coalesce_rule_info (struct nxpwifi_private *priv, +struct cfg80211_coalesce_rules *crule, +struct nxpwifi_coalesce_rule *mrule) +{ +u8 byte_seq[NXPWIFI_COALESCE_MAX_BYTESEQ +1 ]; +struct filt_field_param *param; +int i; + + mrule->max_coalescing_delay = crule->delay; + + param = mrule->params; + +for (i =0 ; i < crule->n_patterns; i++) { +memset (byte_seq,0 ,sizeof (byte_seq)); +if (!nxpwifi_is_pattern_supported (&crule->patterns[i], + byte_seq, +NXPWIFI_COALESCE_MAX_BYTESEQ )) { +nxpwifi_dbg (priv->adapter,ERROR , +"Pattern not supported\n" ); +return -EOPNOTSUPP ; + } + +if (!crule->patterns[i].pkt_offset) { +u8 pkt_type; + + pkt_type =nxpwifi_get_coalesce_pkt_type (byte_seq); +if (pkt_type && mrule->pkt_type) { +nxpwifi_dbg (priv->adapter,ERROR , +"Multiple packet types not allowed\n" ); +return -EOPNOTSUPP ; + }else if (pkt_type) { + mrule->pkt_type = pkt_type; +continue ; + } + } + +if (crule->condition ==NL80211_COALESCE_CONDITION_MATCH ) + param->operation =RECV_FILTER_MATCH_TYPE_EQ ; +else + param->operation =RECV_FILTER_MATCH_TYPE_NE ; + + param->operand_len = byte_seq[NXPWIFI_COALESCE_MAX_BYTESEQ ]; +memcpy (param->operand_byte_stream, byte_seq, + param->operand_len); + param->offset = crule->patterns[i].pkt_offset; + param++; + + mrule->num_of_fields++; + } + +if (!mrule->pkt_type) { +nxpwifi_dbg (priv->adapter,ERROR , +"Packet type can not be determined\n" ); +return -EOPNOTSUPP ; + } + +return 0 ; +} + +static int nxpwifi_cfg80211_set_coalesce (struct wiphy *wiphy, +struct cfg80211_coalesce *coalesce) +{ +struct nxpwifi_adapter *adapter =nxpwifi_cfg80211_get_adapter (wiphy); +int i, ret; +struct nxpwifi_ds_coalesce_cfg coalesce_cfg; +struct nxpwifi_private *priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); + +memset (&coalesce_cfg,0 ,sizeof (coalesce_cfg)); +if (!coalesce) { +nxpwifi_dbg (adapter,WARN , +"Disable coalesce and reset all previous rules\n" ); +return nxpwifi_send_cmd (priv,HOST_CMD_COALESCE_CFG , +HOST_ACT_GEN_SET ,0 , + &coalesce_cfg, true); + } + + coalesce_cfg.num_of_rules = coalesce->n_rules; +for (i =0 ; i < coalesce->n_rules; i++) { + ret =nxpwifi_fill_coalesce_rule_info (priv, &coalesce->rules[i], + &coalesce_cfg.rule[i]); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"Recheck the patterns provided for rule %d\n" , + i +1 ); +return ret; + } + } + +return nxpwifi_send_cmd (priv,HOST_CMD_COALESCE_CFG , +HOST_ACT_GEN_SET ,0 , &coalesce_cfg, true); +} + +static int +nxpwifi_cfg80211_uap_add_station (struct nxpwifi_private *priv,const u8 *mac, +struct station_parameters *params) +{ +struct nxpwifi_sta_info add_sta; +int ret; + +memcpy (add_sta.peer_mac, mac,ETH_ALEN ); + add_sta.params = params; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_ADD_NEW_STATION , +HOST_ACT_ADD_STA ,0 , (void *)&add_sta, true); + +if (!ret) { +struct station_info *sinfo =NULL ; + + sinfo =kzalloc (sizeof (*sinfo),GFP_KERNEL ); + +if (sinfo) { +cfg80211_new_sta (priv->netdev, mac, sinfo,GFP_KERNEL ); +kfree (sinfo); + } + } + +return ret; +} + +static int +nxpwifi_cfg80211_add_station (struct wiphy *wiphy,struct net_device *dev, +const u8 *mac,struct station_parameters *params) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +int ret = -EOPNOTSUPP ; + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) + ret =nxpwifi_cfg80211_uap_add_station (priv, mac, params); + +return ret; +} + +static int +nxpwifi_cfg80211_channel_switch (struct wiphy *wiphy,struct net_device *dev, +struct cfg80211_csa_settings *params) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +int chsw_msec; +int ret; + +if (priv->adapter->scan_processing) { +nxpwifi_dbg (priv->adapter,ERROR , +"radar detection: scan in process...\n" ); +return -EBUSY ; + } + +if (priv->wdev.cac_started) +return -EBUSY ; + +if (cfg80211_chandef_identical (¶ms->chandef, + &priv->dfs_chandef)) +return -EINVAL ; + +if (params->block_tx) { +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); +nxpwifi_stop_net_dev_queue (priv->netdev, priv->adapter); + priv->uap_stop_tx = true; + } + + ret =nxpwifi_del_mgmt_ies (priv); +if (ret) +nxpwifi_dbg (priv->adapter,ERROR , +"Failed to delete mgmt IEs!\n" ); + + ret =nxpwifi_set_mgmt_ies (priv, ¶ms->beacon_csa); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: setting mgmt ies failed\n" , __func__); + goto done; + } + +memcpy (&priv->dfs_chandef, ¶ms->chandef,sizeof (priv->dfs_chandef)); +memcpy (&priv->beacon_after, ¶ms->beacon_after, +sizeof (priv->beacon_after)); + + chsw_msec =max (params->count * priv->bss_cfg.beacon_period,100 ); + nxpwifi_queue_delayed_work(priv->adapter, &priv->dfs_chan_sw_work,
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.34.1
Part of the diff is not shown here. View the raw message.
PATCH v2 11/43 wifi: nxpwifi: add cfg80211.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cfg80211.h | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.h
drivers/net/wireless/nxp/nxpwifi/cfg80211.h new file +19 -0
@@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: CFG80211 +* +* Copyright 2011-2024 NXP +*/ + +#ifndef __NXPWIFI_CFG80211__ +#define __NXPWIFI_CFG80211__ + +#include "main.h" + +int nxpwifi_register_cfg80211 (struct nxpwifi_adapter *adapter); + +int nxpwifi_cfg80211_change_beacon_data (struct wiphy *wiphy, +struct net_device *dev, +struct cfg80211_beacon_data *data); + +#endif
Signature · 1 line
2.34.1
PATCH v2 12/43 wifi: nxpwifi: add cfg.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cfg.h | 445 +++++++++++++++++++++++++ 1 file changed, 445 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg.h
drivers/net/wireless/nxp/nxpwifi/cfg.h new file +445 -0
@@ -0,0 +1,445 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: ioctl data structures & APIs +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_IOCTL_H_ +#define _NXPWIFI_IOCTL_H_ + +#include <net/lib80211.h> + +enum { +NXPWIFI_SCAN_TYPE_UNCHANGED =0 , +NXPWIFI_SCAN_TYPE_ACTIVE , +NXPWIFI_SCAN_TYPE_PASSIVE +}; + +#define NXPWIFI_PROMISC_MODE 1 +#define NXPWIFI_MULTICAST_MODE 2 +#define NXPWIFI_ALL_MULTI_MODE 4 +#define NXPWIFI_MAX_MULTICAST_LIST_SIZE 32 + +struct nxpwifi_multicast_list { +u32 mode; +u32 num_multicast_addr; +u8 mac_list[NXPWIFI_MAX_MULTICAST_LIST_SIZE ][ETH_ALEN ]; +}; + +struct nxpwifi_chan_freq { +u32 channel; +u32 freq; +}; + +struct nxpwifi_ssid_bssid { +struct cfg80211_ssid ssid; +u8 bssid[ETH_ALEN ]; +}; + +enum { +BAND_B =1 , +BAND_G =2 , +BAND_A =4 , +BAND_GN =8 , +BAND_AN =16 , +BAND_AAC =32 , +}; + +#define NXPWIFI_WPA_PASSHPHRASE_LEN 64 +struct wpa_param { +u8 pairwise_cipher_wpa; +u8 pairwise_cipher_wpa2; +u8 group_cipher; +u32 length; +u8 passphrase[NXPWIFI_WPA_PASSHPHRASE_LEN ]; +}; + +struct wep_key { +u8 key_index; +u8 is_default; +u16 length; +u8 key[WLAN_KEY_LEN_WEP104 ]; +}; + +#define KEY_MGMT_ON_HOST 0x03 +#define NXPWIFI_AUTH_MODE_AUTO 0xFF +#define BAND_CONFIG_BG 0x00 +#define BAND_CONFIG_A 0x01 +#define NXPWIFI_SEC_CHAN_BELOW 0x30 +#define NXPWIFI_SEC_CHAN_ABOVE 0x10 +#define NXPWIFI_SUPPORTED_RATES 14 +#define NXPWIFI_SUPPORTED_RATES_EXT 32 +#define NXPWIFI_PRIO_BK 2 +#define NXPWIFI_PRIO_VI 5 +#define NXPWIFI_SUPPORTED_CHANNELS 2 +#define NXPWIFI_OPERATING_CLASSES 16 + +struct nxpwifi_uap_bss_param { +u8 mac_addr[ETH_ALEN ]; +u8 channel; +u8 band_cfg; +u16 rts_threshold; +u16 frag_threshold; +u8 retry_limit; +struct nxpwifi_802_11_ssid ssid; +u8 bcast_ssid_ctl; +u8 radio_ctl; +u8 dtim_period; +u16 beacon_period; +u16 auth_mode; +u16 protocol; +u16 key_mgmt; +u16 key_mgmt_operation; +struct wpa_param wpa_cfg; +struct wep_key wep_cfg[NUM_WEP_KEYS ]; +struct ieee80211_ht_cap ht_cap; +struct ieee80211_vht_cap vht_cap; +u8 rates[NXPWIFI_SUPPORTED_RATES ]; +u32 sta_ao_timer; +u32 ps_sta_ao_timer; +u8 qos_info; +u8 power_constraint; +struct nxpwifi_types_wmm_info wmm_info; +}; + +struct nxpwifi_ds_get_stats { +u32 mcast_tx_frame; +u32 failed; +u32 retry; +u32 multi_retry; +u32 frame_dup; +u32 rts_success; +u32 rts_failure; +u32 ack_failure; +u32 rx_frag; +u32 mcast_rx_frame; +u32 fcs_error; +u32 tx_frame; +u32 wep_icv_error[4 ]; +u32 bcn_rcv_cnt; +u32 bcn_miss_cnt; +}; + +#define NXPWIFI_MAX_VER_STR_LEN 128 + +struct nxpwifi_ver_ext { +u32 version_str_sel; +char version_str[NXPWIFI_MAX_VER_STR_LEN ]; +}; + +struct nxpwifi_bss_info { +u32 bss_mode; +struct cfg80211_ssid ssid; +u32 bss_chan; +u8 country_code[3 ]; +u32 media_connected; +u32 max_power_level; +u32 min_power_level; +signed int bcn_nf_last; +u32 wep_status; +u32 is_hs_configured; +u32 is_deep_sleep; +u8 bssid[ETH_ALEN ]; +}; + +struct nxpwifi_sta_info { +u8 peer_mac[ETH_ALEN ]; +struct station_parameters *params; +}; + +#define MAX_NUM_TID 8 + +#define MAX_RX_WINSIZE 64 + +struct nxpwifi_ds_rx_reorder_tbl { +u16 tid; +u8 ta[ETH_ALEN ]; +u32 start_win; +u32 win_size; +u32 buffer[MAX_RX_WINSIZE ]; +}; + +struct nxpwifi_ds_tx_ba_stream_tbl { +u16 tid; +u8 ra[ETH_ALEN ]; +u8 amsdu; +}; + +#define DBG_CMD_NUM 5 +#define NXPWIFI_DBG_SDIO_MP_NUM 10 + +struct nxpwifi_debug_info { +unsigned int debug_mask; +u32 int_counter; +u32 packets_out[MAX_NUM_TID ]; +u32 tx_buf_size; +u32 curr_tx_buf_size; +u32 tx_tbl_num; +struct nxpwifi_ds_tx_ba_stream_tbl + tx_tbl[NXPWIFI_MAX_TX_BASTREAM_SUPPORTED ]; +u32 rx_tbl_num; +struct nxpwifi_ds_rx_reorder_tbl rx_tbl + [NXPWIFI_MAX_RX_BASTREAM_SUPPORTED ]; +u16 ps_mode; +u32 ps_state; +u8 is_deep_sleep; +u8 pm_wakeup_card_req; +u32 pm_wakeup_fw_try; +u8 is_hs_configured; +u8 hs_activated; +u32 num_cmd_host_to_card_failure; +u32 num_cmd_sleep_cfm_host_to_card_failure; +u32 num_tx_host_to_card_failure; +u32 num_event_deauth; +u32 num_event_disassoc; +u32 num_event_link_lost; +u32 num_cmd_deauth; +u32 num_cmd_assoc_success; +u32 num_cmd_assoc_failure; +u32 num_tx_timeout; +u8 is_cmd_timedout; +u16 timeout_cmd_id; +u16 timeout_cmd_act; +u16 last_cmd_id[DBG_CMD_NUM ]; +u16 last_cmd_act[DBG_CMD_NUM ]; +u16 last_cmd_index; +u16 last_cmd_resp_id[DBG_CMD_NUM ]; +u16 last_cmd_resp_index; +u16 last_event[DBG_CMD_NUM ]; +u16 last_event_index; +u8 data_sent; +u8 cmd_sent; +u8 cmd_resp_received; +u8 event_received; +u32 last_mp_wr_bitmap[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_wr_ports[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_wr_len[NXPWIFI_DBG_SDIO_MP_NUM ]; +u32 last_mp_curr_wr_port[NXPWIFI_DBG_SDIO_MP_NUM ]; +u8 last_sdio_mp_index; +}; + +#define NXPWIFI_KEY_INDEX_UNICAST 0x40000000 +#define PN_LEN 16 + +struct nxpwifi_ds_encrypt_key { +u32 key_disable; +u32 key_index; +u32 key_len; +u8 key_material[WLAN_MAX_KEY_LEN ]; +u8 mac_addr[ETH_ALEN ]; +u8 pn[PN_LEN ];/* packet number */ +u8 pn_len; +u8 is_igtk_key; +u8 is_current_wep_key; +u8 is_rx_seq_valid; +u8 is_igtk_def_key; +}; + +struct nxpwifi_power_cfg { +u32 is_power_auto; +u32 is_power_fixed; +u32 power_level; +}; + +struct nxpwifi_ds_hs_cfg { +u32 is_invoke_hostcmd; +/* Bit0: non-unicast data +* Bit1: unicast data +* Bit2: mac events +* Bit3: magic packet +*/ +u32 conditions; +u32 gpio; +u32 gap; +}; + +struct nxpwifi_ds_wakeup_reason { +u16 hs_wakeup_reason; +}; + +#define DEEP_SLEEP_ON 1 +#define DEEP_SLEEP_OFF 0 +#define DEEP_SLEEP_IDLE_TIME 100 +#define PS_MODE_AUTO 1 + +struct nxpwifi_ds_auto_ds { +u16 auto_ds; +u16 idle_time; +}; + +struct nxpwifi_ds_pm_cfg { +union { +u32 ps_mode; +struct nxpwifi_ds_hs_cfg hs_cfg; +struct nxpwifi_ds_auto_ds auto_deep_sleep; +u32 sleep_period; + } param; +}; + +struct nxpwifi_11ac_vht_cfg { +u8 band_config; +u8 misc_config; +u32 cap_info; +u32 mcs_tx_set; +u32 mcs_rx_set; +}; + +struct nxpwifi_ds_11n_tx_cfg { +u16 tx_htcap; +u16 tx_htinfo; +u16 misc_config;/* Needed for 802.11AC cards only */ +}; + +struct nxpwifi_ds_11n_amsdu_aggr_ctrl { +u16 enable; +u16 curr_buf_size; +}; + +struct nxpwifi_ds_ant_cfg { +u32 tx_ant; +u32 rx_ant; +}; + +#define NXPWIFI_NUM_OF_CMD_BUFFER 50 +#define NXPWIFI_SIZE_OF_CMD_BUFFER 2048 + +enum { +NXPWIFI_IE_TYPE_GEN_IE =0 , +NXPWIFI_IE_TYPE_ARP_FILTER , +}; + +enum { +NXPWIFI_REG_MAC =1 , +NXPWIFI_REG_BBP , +NXPWIFI_REG_RF , +NXPWIFI_REG_PMIC , +NXPWIFI_REG_CAU , +}; + +struct nxpwifi_ds_reg_rw { +u32 type; +u32 offset; +u32 value; +}; + +#define MAX_EEPROM_DATA 256 + +struct nxpwifi_ds_read_eeprom { +u16 offset; +u16 byte_count; +u8 value[MAX_EEPROM_DATA ]; +}; + +struct nxpwifi_ds_mem_rw { +u32 addr; +u32 value; +}; + +#define IEEE_MAX_IE_SIZE 256 + +#define NXPWIFI_IE_HDR_SIZE (sizeof(struct nxpwifi_ie) - IEEE_MAX_IE_SIZE) + +struct nxpwifi_ds_misc_gen_ie { +u32 type; +u32 len; +u8 ie_data[IEEE_MAX_IE_SIZE ]; +}; + +struct nxpwifi_ds_misc_cmd { +u32 len; +u8 cmd[NXPWIFI_SIZE_OF_CMD_BUFFER ]; +}; + +#define BITMASK_BCN_RSSI_LOW BIT(0) +#define BITMASK_BCN_RSSI_HIGH BIT(4) + +enum subsc_evt_rssi_state { +EVENT_HANDLED , +RSSI_LOW_RECVD , +RSSI_HIGH_RECVD +}; + +struct subsc_evt_cfg { +u8 abs_value; +u8 evt_freq; +}; + +struct nxpwifi_ds_misc_subsc_evt { +u16 action; +u16 events; +struct subsc_evt_cfg bcn_l_rssi_cfg; +struct subsc_evt_cfg bcn_h_rssi_cfg; +}; + +#define NXPWIFI_MEF_MAX_BYTESEQ 6/* non-adjustable */ +#define NXPWIFI_MEF_MAX_FILTERS 10 + +struct nxpwifi_mef_filter { +u16 repeat; +u16 offset; +s8 byte_seq[NXPWIFI_MEF_MAX_BYTESEQ +1 ]; +u8 filt_type; +u8 filt_action; +}; + +struct nxpwifi_mef_entry { +u8 mode; +u8 action; +struct nxpwifi_mef_filter filter[NXPWIFI_MEF_MAX_FILTERS ]; +}; + +struct nxpwifi_ds_mef_cfg { +u32 criteria; +u16 num_entries; +struct nxpwifi_mef_entry *mef_entry; +}; + +#define NXPWIFI_MAX_VSIE_LEN (256) +#define NXPWIFI_MAX_VSIE_NUM (8) +#define NXPWIFI_VSIE_MASK_CLEAR 0x00 +#define NXPWIFI_VSIE_MASK_SCAN 0x01 +#define NXPWIFI_VSIE_MASK_ASSOC 0x02 +#define NXPWIFI_VSIE_MASK_BGSCAN 0x08 + +enum { +NXPWIFI_FUNC_INIT =1 , +NXPWIFI_FUNC_SHUTDOWN , +}; + +enum COALESCE_OPERATION { +RECV_FILTER_MATCH_TYPE_EQ =0x80 , +RECV_FILTER_MATCH_TYPE_NE , +}; + +enum COALESCE_PACKET_TYPE { +PACKET_TYPE_UNICAST =1 , +PACKET_TYPE_MULTICAST =2 , +PACKET_TYPE_BROADCAST =3 +}; + +#define NXPWIFI_COALESCE_MAX_RULES 8 +#define NXPWIFI_COALESCE_MAX_BYTESEQ 4/* non-adjustable */ +#define NXPWIFI_COALESCE_MAX_FILTERS 4 +#define NXPWIFI_MAX_COALESCING_DELAY 100/* in msecs */ + +struct filt_field_param { +u8 operation; +u8 operand_len; +u16 offset; +u8 operand_byte_stream[NXPWIFI_COALESCE_MAX_BYTESEQ ]; +}; + +struct nxpwifi_coalesce_rule { +u16 max_coalescing_delay; +u8 num_of_fields; +u8 pkt_type; +struct filt_field_param params[NXPWIFI_COALESCE_MAX_FILTERS ]; +}; + +struct nxpwifi_ds_coalesce_cfg { +u16 num_of_rules; +struct nxpwifi_coalesce_rule rule[NXPWIFI_COALESCE_MAX_RULES ]; +}; + +#endif /* !_NXPWIFI_IOCTL_H_ */
Signature · 1 line
2.34.1
PATCH v2 13/43 wifi: nxpwifi: add cfp.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cfp.c | 484 +++++++++++++++++++++++++ 1 file changed, 484 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfp.c
drivers/net/wireless/nxp/nxpwifi/cfp.c new file +484 -0
@@ -0,0 +1,484 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: Channel, Frequency and Power +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cfg80211.h" + +/* 100mW */ +#define NXPWIFI_TX_PWR_DEFAULT 20 +/* 100mW */ +#define NXPWIFI_TX_PWR_US_DEFAULT 20 +/* 50mW */ +#define NXPWIFI_TX_PWR_JP_DEFAULT 16 +/* 100mW */ +#define NXPWIFI_TX_PWR_FR_100MW 20 +/* 10mW */ +#define NXPWIFI_TX_PWR_FR_10MW 10 +/* 100mW */ +#define NXPWIFI_TX_PWR_EMEA_DEFAULT 20 + +static u8 supported_rates_a[A_SUPPORTED_RATES ] = {0x0c ,0x12 ,0x18 ,0x24 , +0xb0 ,0x48 ,0x60 ,0x6c ,0 }; +static u16 nxpwifi_data_rates[NXPWIFI_SUPPORTED_RATES_EXT ] = {0x02 ,0x04 , +0x0B ,0x16 ,0x00 ,0x0C ,0x12 ,0x18 , +0x24 ,0x30 ,0x48 ,0x60 ,0x6C ,0x90 , +0x0D ,0x1A ,0x27 ,0x34 ,0x4E ,0x68 , +0x75 ,0x82 ,0x0C ,0x1B ,0x36 ,0x51 , +0x6C ,0xA2 ,0xD8 ,0xF3 ,0x10E ,0x00 }; + +static u8 supported_rates_b[B_SUPPORTED_RATES ] = {0x02 ,0x04 ,0x0b ,0x16 ,0 }; + +static u8 supported_rates_g[G_SUPPORTED_RATES ] = {0x0c ,0x12 ,0x18 ,0x24 , +0x30 ,0x48 ,0x60 ,0x6c ,0 }; + +static u8 supported_rates_bg[BG_SUPPORTED_RATES ] = {0x02 ,0x04 ,0x0b ,0x0c , +0x12 ,0x16 ,0x18 ,0x24 ,0x30 ,0x48 , +0x60 ,0x6c ,0 }; + +u16 region_code_index[NXPWIFI_MAX_REGION_CODE ] = {0x00 ,0x10 ,0x20 ,0x30 , +0x31 ,0x32 ,0x40 ,0x41 ,0x50 }; + +static u8 supported_rates_n[N_SUPPORTED_RATES ] = {0x02 ,0x04 ,0 }; + +/* For every mcs_rate line, the first 8 bytes are for stream 1x1, +* and all 16 bytes are for stream 2x2. +*/ +static const u16 mcs_rate[4 ][16 ] = { +/* LGI 40M */ + {0x1b ,0x36 ,0x51 ,0x6c ,0xa2 ,0xd8 ,0xf3 ,0x10e , +0x36 ,0x6c ,0xa2 ,0xd8 ,0x144 ,0x1b0 ,0x1e6 ,0x21c }, + +/* SGI 40M */ + {0x1e ,0x3c ,0x5a ,0x78 ,0xb4 ,0xf0 ,0x10e ,0x12c , +0x3c ,0x78 ,0xb4 ,0xf0 ,0x168 ,0x1e0 ,0x21c ,0x258 }, + +/* LGI 20M */ + {0x0d ,0x1a ,0x27 ,0x34 ,0x4e ,0x68 ,0x75 ,0x82 , +0x1a ,0x34 ,0x4e ,0x68 ,0x9c ,0xd0 ,0xea ,0x104 }, + +/* SGI 20M */ + {0x0e ,0x1c ,0x2b ,0x39 ,0x56 ,0x73 ,0x82 ,0x90 , +0x1c ,0x39 ,0x56 ,0x73 ,0xad ,0xe7 ,0x104 ,0x120 } +}; + +/* AC rates */ +static const u16 ac_mcs_rate_nss1[8 ][10 ] = { +/* LG 160M */ + {0x75 ,0xEA ,0x15F ,0x1D4 ,0x2BE ,0x3A8 ,0x41D , +0x492 ,0x57C ,0x618 }, + +/* SG 160M */ + {0x82 ,0x104 ,0x186 ,0x208 ,0x30C ,0x410 ,0x492 , +0x514 ,0x618 ,0x6C6 }, + +/* LG 80M */ + {0x3B ,0x75 ,0xB0 ,0xEA ,0x15F ,0x1D4 ,0x20F , +0x249 ,0x2BE ,0x30C }, + +/* SG 80M */ + {0x41 ,0x82 ,0xC3 ,0x104 ,0x186 ,0x208 ,0x249 , +0x28A ,0x30C ,0x363 }, + +/* LG 40M */ + {0x1B ,0x36 ,0x51 ,0x6C ,0xA2 ,0xD8 ,0xF3 , +0x10E ,0x144 ,0x168 }, + +/* SG 40M */ + {0x1E ,0x3C ,0x5A ,0x78 ,0xB4 ,0xF0 ,0x10E , +0x12C ,0x168 ,0x190 }, + +/* LG 20M */ + {0xD ,0x1A ,0x27 ,0x34 ,0x4E ,0x68 ,0x75 ,0x82 ,0x9C ,0x00 }, + +/* SG 20M */ + {0xF ,0x1D ,0x2C ,0x3A ,0x57 ,0x74 ,0x82 ,0x91 ,0xAE ,0x00 }, +}; + +/* NSS2 note: the value in the table is 2 multiplier of the actual rate */ +static const u16 ac_mcs_rate_nss2[8 ][10 ] = { +/* LG 160M */ + {0xEA ,0x1D4 ,0x2BE ,0x3A8 ,0x57C ,0x750 ,0x83A , +0x924 ,0xAF8 ,0xC30 }, + +/* SG 160M */ + {0x104 ,0x208 ,0x30C ,0x410 ,0x618 ,0x820 ,0x924 , +0xA28 ,0xC30 ,0xD8B }, + +/* LG 80M */ + {0x75 ,0xEA ,0x15F ,0x1D4 ,0x2BE ,0x3A8 ,0x41D , +0x492 ,0x57C ,0x618 }, + +/* SG 80M */ + {0x82 ,0x104 ,0x186 ,0x208 ,0x30C ,0x410 ,0x492 , +0x514 ,0x618 ,0x6C6 }, + +/* LG 40M */ + {0x36 ,0x6C ,0xA2 ,0xD8 ,0x144 ,0x1B0 ,0x1E6 , +0x21C ,0x288 ,0x2D0 }, + +/* SG 40M */ + {0x3C ,0x78 ,0xB4 ,0xF0 ,0x168 ,0x1E0 ,0x21C , +0x258 ,0x2D0 ,0x320 }, + +/* LG 20M */ + {0x1A ,0x34 ,0x4A ,0x68 ,0x9C ,0xD0 ,0xEA ,0x104 , +0x138 ,0x00 }, + +/* SG 20M */ + {0x1D ,0x3A ,0x57 ,0x74 ,0xAE ,0xE6 ,0x104 ,0x121 , +0x15B ,0x00 }, +}; + +struct region_code_mapping { +u8 code; +u8 region[IEEE80211_COUNTRY_STRING_LEN ]; +}; + +static struct region_code_mapping region_code_mapping_t[] = { + {0x10 ,"US " },/* US FCC */ + {0x20 ,"CA " },/* IC Canada */ + {0x30 ,"FR " },/* France */ + {0x31 ,"ES " },/* Spain */ + {0x32 ,"FR " },/* France */ + {0x40 ,"JP " },/* Japan */ + {0x41 ,"JP " },/* Japan */ + {0x50 ,"CN " },/* China */ +}; + +/* This function converts integer code to region string */ +u8 *nxpwifi_11d_code_2_region (u8 code) +{ +u8 i; + +/* Look for code in mapping table */ +for (i =0 ; i <ARRAY_SIZE (region_code_mapping_t); i++) +if (region_code_mapping_t[i].code == code) +return region_code_mapping_t[i].region; + +return NULL ; +} + +/* This function maps an index in supported rates table into +* the corresponding data rate. +*/ +u32 nxpwifi_index_to_acs_data_rate (struct nxpwifi_private *priv, +u8 index,u8 ht_info) +{ +u32 rate =0 ; +u8 mcs_index =0 ; +u8 bw =0 ; +u8 gi =0 ; + +if ((ht_info &0x3 ) ==NXPWIFI_RATE_FORMAT_VHT ) { + mcs_index =min (index &0xF ,9 ); + +/* 20M: bw=0, 40M: bw=1, 80M: bw=2, 160M: bw=3 */ + bw = (ht_info &0xC ) >>2 ; + +/* LGI: gi =0, SGI: gi = 1 */ + gi = (ht_info &0x10 ) >>4 ; + +if ((index >>4 ) ==1 )/* NSS = 2 */ + rate = ac_mcs_rate_nss2[2 * (3 - bw) + gi][mcs_index]; +else /* NSS = 1 */ + rate = ac_mcs_rate_nss1[2 * (3 - bw) + gi][mcs_index]; + }else if ((ht_info &0x3 ) ==NXPWIFI_RATE_FORMAT_HT ) { +/* 20M: bw=0, 40M: bw=1 */ + bw = (ht_info &0xC ) >>2 ; + +/* LGI: gi =0, SGI: gi = 1 */ + gi = (ht_info &0x10 ) >>4 ; + +if (index ==NXPWIFI_RATE_BITMAP_MCS0 ) { +if (gi ==1 ) + rate =0x0D ;/* MCS 32 SGI rate */ +else + rate =0x0C ;/* MCS 32 LGI rate */ + }else if (index <16 ) { +if (bw ==1 || bw ==0 ) + rate = mcs_rate[2 * (1 - bw) + gi][index]; +else + rate = nxpwifi_data_rates[0 ]; + }else { + rate = nxpwifi_data_rates[0 ]; + } + }else { +/* 11n non-HT rates */ +if (index >=NXPWIFI_SUPPORTED_RATES_EXT ) + index =0 ; + rate = nxpwifi_data_rates[index]; + } + +return rate; +} + +/* This function maps an index in supported rates table into +* the corresponding data rate. +*/ +u32 nxpwifi_index_to_data_rate (struct nxpwifi_private *priv, +u8 index,u8 ht_info) +{ +u32 mcs_num_supp = + (priv->adapter->user_dev_mcs_support ==HT_STREAM_2X2 ) ?16 :8 ; +u32 rate; + +if (priv->adapter->is_hw_11ac_capable) +return nxpwifi_index_to_acs_data_rate (priv, index, ht_info); + +if (ht_info &BIT (0 )) { +if (index ==NXPWIFI_RATE_BITMAP_MCS0 ) { +if (ht_info &BIT (2 )) + rate =0x0D ;/* MCS 32 SGI rate */ +else + rate =0x0C ;/* MCS 32 LGI rate */ + }else if (index < mcs_num_supp) { +if (ht_info &BIT (1 )) { +if (ht_info &BIT (2 )) +/* SGI, 40M */ + rate = mcs_rate[1 ][index]; +else +/* LGI, 40M */ + rate = mcs_rate[0 ][index]; + }else { +if (ht_info &BIT (2 )) +/* SGI, 20M */ + rate = mcs_rate[3 ][index]; +else +/* LGI, 20M */ + rate = mcs_rate[2 ][index]; + } + }else { + rate = nxpwifi_data_rates[0 ]; + } + }else { +if (index >=NXPWIFI_SUPPORTED_RATES_EXT ) + index =0 ; + rate = nxpwifi_data_rates[index]; + } +return rate; +} + +/* This function returns the current active data rates. +* +* The result may vary depending upon connection status. +*/ +u32 nxpwifi_get_active_data_rates (struct nxpwifi_private *priv,u8 *rates) +{ +if (!priv->media_connected) +return nxpwifi_get_supported_rates (priv, rates); +else +return nxpwifi_copy_rates (rates,0 , + priv->curr_bss_params.data_rates, + priv->curr_bss_params.num_of_rates); +} + +/* This function locates the Channel-Frequency-Power triplet based upon +* band and channel/frequency parameters. +*/ +struct nxpwifi_chan_freq_power * +nxpwifi_get_cfp (struct nxpwifi_private *priv,u8 band,u16 channel,u32 freq) +{ +struct nxpwifi_chan_freq_power *cfp =NULL ; +struct ieee80211_supported_band *sband; +struct ieee80211_channel *ch =NULL ; +int i; + +if (!channel && !freq) +return cfp; + +if (nxpwifi_band_to_radio_type (band) ==HOST_SCAN_RADIO_TYPE_BG ) + sband = priv->wdev.wiphy->bands[NL80211_BAND_2GHZ ]; +else + sband = priv->wdev.wiphy->bands[NL80211_BAND_5GHZ ]; + +if (!sband) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: cannot find cfp by band %d\n" , + __func__, band); +return cfp; + } + +for (i =0 ; i < sband->n_channels; i++) { + ch = &sband->channels[i]; + +if (ch->flags &IEEE80211_CHAN_DISABLED ) +continue ; + +if (freq) { +if (ch->center_freq == freq) +break ; + }else { +/* find by valid channel*/ +if (ch->hw_value == channel || + channel ==FIRST_VALID_CHANNEL ) +break ; + } + } +if (i == sband->n_channels) { +nxpwifi_dbg (priv->adapter,WARN , +"%s: cannot find cfp by band %d\t" +"& channel=%d freq=%d\n" , + __func__, band, channel, freq); + }else { +if (!ch) +return cfp; + + priv->cfp.channel = ch->hw_value; + priv->cfp.freq = ch->center_freq; + priv->cfp.max_tx_power = ch->max_power; + cfp = &priv->cfp; + } + +return cfp; +} + +/* This function checks if the data rate is set to auto. +*/ +u8 +nxpwifi_is_rate_auto (struct nxpwifi_private *priv) +{ +u32 i; +int rate_num =0 ; + +for (i =0 ; i <ARRAY_SIZE (priv->bitmap_rates); i++) +if (priv->bitmap_rates[i]) + rate_num++; + +if (rate_num >1 ) +return true; +else +return false; +} + +/* This function gets the supported data rates from bitmask inside +* cfg80211_scan_request. +*/ +u32 nxpwifi_get_rates_from_cfg80211 (struct nxpwifi_private *priv, +u8 *rates,u8 radio_type) +{ +struct wiphy *wiphy = priv->adapter->wiphy; +struct cfg80211_scan_request *request = priv->scan_request; +u32 num_rates, rate_mask; +struct ieee80211_supported_band *sband; +int i; + +if (radio_type) { + sband = wiphy->bands[NL80211_BAND_5GHZ ]; +if (WARN_ON_ONCE (!sband)) +return 0 ; + rate_mask = request->rates[NL80211_BAND_5GHZ ]; + }else { + sband = wiphy->bands[NL80211_BAND_2GHZ ]; +if (WARN_ON_ONCE (!sband)) +return 0 ; + rate_mask = request->rates[NL80211_BAND_2GHZ ]; + } + + num_rates =0 ; +for (i =0 ; i < sband->n_bitrates; i++) { +if ((BIT (i) & rate_mask) ==0 ) +continue ;/* skip rate */ + rates[num_rates++] = (u8)(sband->bitrates[i].bitrate /5 ); + } + +return num_rates; +} + +/* This function gets the supported data rates. The function works in +* both Ad-Hoc and infra mode by printing the band and returning the +* data rates. +*/ +u32 nxpwifi_get_supported_rates (struct nxpwifi_private *priv,u8 *rates) +{ +u32 k =0 ; +struct nxpwifi_adapter *adapter = priv->adapter; + +if (priv->bss_mode ==NL80211_IFTYPE_STATION ) { +switch (adapter->config_bands) { +case BAND_B : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_b\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_b, +sizeof (supported_rates_b)); +break ; +case BAND_G : +case BAND_G |BAND_GN : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_g\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_g, +sizeof (supported_rates_g)); +break ; +case BAND_B |BAND_G : +case BAND_A |BAND_B |BAND_G : +case BAND_A |BAND_B : +case BAND_A |BAND_B |BAND_G |BAND_GN |BAND_AN : +case BAND_A |BAND_B |BAND_G |BAND_GN |BAND_AN |BAND_AAC : +case BAND_B |BAND_G |BAND_GN : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_bg\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_bg, +sizeof (supported_rates_bg)); +break ; +case BAND_A : +case BAND_A |BAND_G : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_a\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_a, +sizeof (supported_rates_a)); +break ; +case BAND_AN : +case BAND_A |BAND_AN : +case BAND_A |BAND_AN |BAND_AAC : +case BAND_A |BAND_G |BAND_AN |BAND_GN : +case BAND_A |BAND_G |BAND_AN |BAND_GN |BAND_AAC : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_a\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_a, +sizeof (supported_rates_a)); +break ; +case BAND_GN : +nxpwifi_dbg (adapter,INFO ,"info: infra band=%d\t" +"supported_rates_n\n" , + adapter->config_bands); + k =nxpwifi_copy_rates (rates, k, supported_rates_n, +sizeof (supported_rates_n)); +break ; + } + } + +return k; +} + +u8 nxpwifi_adjust_data_rate (struct nxpwifi_private *priv, +u8 rx_rate,u8 rate_info) +{ +u8 rate_index =0 ; + +/* HT40 */ +if ((rate_info &BIT (0 )) && (rate_info &BIT (1 ))) + rate_index =NXPWIFI_RATE_INDEX_MCS0 + +NXPWIFI_BW20_MCS_NUM + rx_rate; +else if (rate_info &BIT (0 ))/* HT20 */ + rate_index =NXPWIFI_RATE_INDEX_MCS0 + rx_rate; +else + rate_index = (rx_rate >NXPWIFI_RATE_INDEX_OFDM0 ) ? + rx_rate -1 : rx_rate; + +if (rate_index >=NXPWIFI_MAX_AC_RX_RATES ) + rate_index =NXPWIFI_MAX_AC_RX_RATES -1 ; + +return rate_index; +}
Signature · 1 line
2.34.1
PATCH v2 14/43 wifi: nxpwifi: add cmdevt.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cmdevt.c | 1285 +++++++++++++++++++++ 1 file changed, 1285 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.c
drivers/net/wireless/nxp/nxpwifi/cmdevt.c new file +1285 -0
@@ -0,0 +1,1285 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: commands and events +* +* Copyright 2011-2024 NXP +*/ + +#include <asm/unaligned.h> +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" + +static void nxpwifi_cancel_pending_ioctl (struct nxpwifi_adapter *adapter); + +/* This function initializes a command node. +* +* The actual allocation of the node is not done by this function. It only +* initiates a node by filling it with default parameters. Similarly, +* allocation of the different buffers used (IOCTL buffer, data buffer) are +* not done by this function either. +*/ +static void +nxpwifi_init_cmd_node (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node, +u32 cmd_no,void *data_buf,bool sync) +{ + cmd_node->priv = priv; + cmd_node->cmd_no = cmd_no; + +if (sync) { + cmd_node->wait_q_enabled = true; + cmd_node->cmd_wait_q_woken = false; + cmd_node->condition = &cmd_node->cmd_wait_q_woken; + } + cmd_node->data_buf = data_buf; + cmd_node->cmd_skb = cmd_node->skb; + cmd_node->cmd_resp =NULL ; +} + +/* This function returns a command node from the free queue depending upon +* availability. +*/ +static struct cmd_ctrl_node * +nxpwifi_get_cmd_node (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_node; + +spin_lock_bh (&adapter->cmd_free_q_lock); +if (list_empty (&adapter->cmd_free_q)) { +nxpwifi_dbg (adapter,ERROR , +"GET_CMD_NODE: cmd node not available\n" ); +spin_unlock_bh (&adapter->cmd_free_q_lock); +return NULL ; + } + cmd_node =list_first_entry (&adapter->cmd_free_q, + struct cmd_ctrl_node, list); +list_del (&cmd_node->list); +spin_unlock_bh (&adapter->cmd_free_q_lock); + +return cmd_node; +} + +/* This function cleans up a command node. +* +* The function resets the fields including the buffer pointers. +* This function does not try to free the buffers. They must be +* freed before calling this function. +* +* This function will however call the receive completion callback +* in case a response buffer is still available before resetting +* the pointer. +*/ +static void +nxpwifi_clean_cmd_node (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node) +{ + cmd_node->cmd_no =0 ; + cmd_node->cmd_flag =0 ; + cmd_node->data_buf =NULL ; + cmd_node->wait_q_enabled = false; + +if (cmd_node->cmd_skb) +skb_trim (cmd_node->cmd_skb,0 ); + +if (cmd_node->resp_skb) { + adapter->if_ops.cmdrsp_complete (adapter, cmd_node->resp_skb); + cmd_node->resp_skb =NULL ; + } +} + +/* This function returns a command to the command free queue. +* +* The function also calls the completion callback if required, before +* cleaning the command node and re-inserting it into the free queue. +*/ +static void +nxpwifi_insert_cmd_to_free_q (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node) +{ +if (!cmd_node) +return ; + +if (cmd_node->wait_q_enabled) +nxpwifi_complete_cmd (adapter, cmd_node); +/* Clean the node */ +nxpwifi_clean_cmd_node (adapter, cmd_node); + +/* Insert node into cmd_free_q */ +spin_lock_bh (&adapter->cmd_free_q_lock); +list_add_tail (&cmd_node->list, &adapter->cmd_free_q); +spin_unlock_bh (&adapter->cmd_free_q_lock); +} + +/* This function reuses a command node. */ +void nxpwifi_recycle_cmd_node (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node) +{ +struct host_cmd_ds_command *host_cmd = (void *)cmd_node->cmd_skb->data; + +nxpwifi_insert_cmd_to_free_q (adapter, cmd_node); + +atomic_dec (&adapter->cmd_pending); +nxpwifi_dbg (adapter,CMD , +"cmd: FREE_CMD: cmd=%#x, cmd_pending=%d\n" , +le16_to_cpu (host_cmd->command), +atomic_read (&adapter->cmd_pending)); +} + +/* This function sends a host command to the firmware. +* +* The function copies the host command into the driver command +* buffer, which will be transferred to the firmware later by the +* main thread. +*/ +static int nxpwifi_cmd_host_cmd (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node) +{ +struct host_cmd_ds_command *cmd; +struct nxpwifi_ds_misc_cmd *pcmd_ptr; + + cmd = (struct host_cmd_ds_command *)cmd_node->skb->data; + pcmd_ptr = (struct nxpwifi_ds_misc_cmd *)cmd_node->data_buf; + +/* Copy the HOST command to command buffer */ +memcpy (cmd, pcmd_ptr->cmd, pcmd_ptr->len); +nxpwifi_dbg (priv->adapter,CMD , +"cmd: host cmd size = %d\n" , pcmd_ptr->len); +return 0 ; +} + +/* This function downloads a command to the firmware. +* +* The function performs sanity tests, sets the command sequence +* number and size, converts the header fields to CPU format before +* sending. Afterwards, it logs the command ID and action for debugging +* and sets up the command timeout timer. +*/ +static int nxpwifi_dnld_cmd_to_fw (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret; +struct host_cmd_ds_command *host_cmd; +u16 cmd_code; +u16 cmd_size; + +if (!adapter || !cmd_node) +return -EINVAL ; + + host_cmd = (struct host_cmd_ds_command *)(cmd_node->cmd_skb->data); + +/* Sanity test */ +if (host_cmd->size ==0 ) { +nxpwifi_dbg (adapter,ERROR , +"DNLD_CMD: host_cmd is null\t" +"or cmd size is 0, not sending\n" ); +if (cmd_node->wait_q_enabled) + adapter->cmd_wait_q.status =-1 ; +nxpwifi_recycle_cmd_node (adapter, cmd_node); +return -EINVAL ; + } + + cmd_code =le16_to_cpu (host_cmd->command); + cmd_node->cmd_no = cmd_code; + cmd_size =le16_to_cpu (host_cmd->size); + +if (adapter->hw_status ==NXPWIFI_HW_STATUS_RESET && + cmd_code !=HOST_CMD_FUNC_SHUTDOWN && + cmd_code !=HOST_CMD_FUNC_INIT ) { +nxpwifi_dbg (adapter,ERROR , +"DNLD_CMD: FW in reset state, ignore cmd %#x\n" , + cmd_code); +nxpwifi_recycle_cmd_node (adapter, cmd_node); +nxpwifi_queue_work (adapter, &adapter->main_work); +return -EPERM ; + } + +/* Set command sequence number */ + adapter->seq_num++; + host_cmd->seq_num =cpu_to_le16 (HOST_SET_SEQ_NO_BSS_INFO + (adapter->seq_num, + cmd_node->priv->bss_num, + cmd_node->priv->bss_type)); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->curr_cmd = cmd_node; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + +/* Adjust skb length */ +if (cmd_node->cmd_skb->len > cmd_size) +/* cmd_size is less than sizeof(struct host_cmd_ds_command). +* Trim off the unused portion. +*/ +skb_trim (cmd_node->cmd_skb, cmd_size); +else if (cmd_node->cmd_skb->len < cmd_size) +/* cmd_size is larger than sizeof(struct host_cmd_ds_command) +* because we have appended custom IE TLV. Increase skb length +* accordingly. +*/ +skb_put (cmd_node->cmd_skb, cmd_size - cmd_node->cmd_skb->len); + +nxpwifi_dbg (adapter,CMD , +"cmd: DNLD_CMD: %#x, act %#x, len %d, seqno %#x\n" , + cmd_code, +get_unaligned_le16 ((u8 *)host_cmd +S_DS_GEN ), + cmd_size,le16_to_cpu (host_cmd->seq_num)); +nxpwifi_dbg_dump (adapter,CMD_D ,"cmd buffer:" , host_cmd, cmd_size); + +skb_push (cmd_node->cmd_skb, adapter->intf_hdr_len); + ret = adapter->if_ops.host_to_card (adapter,NXPWIFI_TYPE_CMD , + cmd_node->cmd_skb,NULL ); +skb_pull (cmd_node->cmd_skb, adapter->intf_hdr_len); + +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"DNLD_CMD: host to card failed\n" ); +if (cmd_node->wait_q_enabled) + adapter->cmd_wait_q.status =-1 ; +nxpwifi_recycle_cmd_node (adapter, adapter->curr_cmd); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->curr_cmd =NULL ; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + + adapter->dbg.num_cmd_host_to_card_failure++; +return ret; + } + +/* Save the last command id and action to debug log */ + adapter->dbg.last_cmd_index = + (adapter->dbg.last_cmd_index +1 ) %DBG_CMD_NUM ; + adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index] = cmd_code; + adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index] = +get_unaligned_le16 ((u8 *)host_cmd +S_DS_GEN ); + +/* Setup the timer after transmit command, except that specific +* command might not have command response. +*/ +if (cmd_code !=HOST_CMD_FW_DUMP_EVENT ) +mod_timer (&adapter->cmd_timer, + jiffies +msecs_to_jiffies (NXPWIFI_TIMER_10S )); + +/* Clear BSS_NO_BITS from HOST */ + cmd_code &=HOST_CMD_ID_MASK ; + +return 0 ; +} + +/* This function downloads a sleep confirm command to the firmware. +* +* The function performs sanity tests, sets the command sequence +* number and size, converts the header fields to CPU format before +* sending. +* +* No responses are needed for sleep confirm command. +*/ +static int nxpwifi_dnld_sleep_confirm_cmd (struct nxpwifi_adapter *adapter) +{ +int ret; +struct nxpwifi_private *priv; +struct nxpwifi_opt_sleep_confirm *sleep_cfm_buf = + (struct nxpwifi_opt_sleep_confirm *) + adapter->sleep_cfm->data; + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + + adapter->seq_num++; + sleep_cfm_buf->seq_num = +cpu_to_le16 (HOST_SET_SEQ_NO_BSS_INFO + (adapter->seq_num, priv->bss_num, + priv->bss_type)); + +nxpwifi_dbg (adapter,CMD , +"cmd: DNLD_CMD: %#x, act %#x, len %d, seqno %#x\n" , +le16_to_cpu (sleep_cfm_buf->command), +le16_to_cpu (sleep_cfm_buf->action), +le16_to_cpu (sleep_cfm_buf->size), +le16_to_cpu (sleep_cfm_buf->seq_num)); +nxpwifi_dbg_dump (adapter,CMD_D ,"SLEEP_CFM buffer: " , sleep_cfm_buf, +le16_to_cpu (sleep_cfm_buf->size)); + +skb_push (adapter->sleep_cfm, adapter->intf_hdr_len); + ret = adapter->if_ops.host_to_card (adapter,NXPWIFI_TYPE_CMD , + adapter->sleep_cfm,NULL ); +skb_pull (adapter->sleep_cfm, adapter->intf_hdr_len); + +if (ret) { +nxpwifi_dbg (adapter,ERROR ,"SLEEP_CFM: failed\n" ); + adapter->dbg.num_cmd_sleep_cfm_host_to_card_failure++; +return ret; + } + +if (!le16_to_cpu (sleep_cfm_buf->resp_ctrl)) +/* Response is not needed for sleep confirm command */ + adapter->ps_state =PS_STATE_SLEEP ; +else + adapter->ps_state =PS_STATE_SLEEP_CFM ; + +if (!le16_to_cpu (sleep_cfm_buf->resp_ctrl) && + (test_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags) && + !adapter->sleep_period.period)) { + adapter->pm_wakeup_card_req = true; +nxpwifi_hs_activated_event (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), true); + } + +return ret; +} + +/* This function allocates the command buffers and links them to +* the command free queue. +* +* The driver uses a pre allocated number of command buffers, which +* are created at driver initializations and freed at driver cleanup. +* Every command needs to obtain a command buffer from this pool before +* it can be issued. The command free queue lists the command buffers +* currently free to use, while the command pending queue lists the +* command buffers already in use and awaiting handling. Command buffers +* are returned to the free queue after use. +*/ +int nxpwifi_alloc_cmd_buffer (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_array; +u32 i; + +/* Allocate and initialize struct cmd_ctrl_node */ + cmd_array =kcalloc (NXPWIFI_NUM_OF_CMD_BUFFER , +sizeof (struct cmd_ctrl_node ),GFP_KERNEL ); +if (!cmd_array) +return -ENOMEM ; + + adapter->cmd_pool = cmd_array; + +/* Allocate and initialize command buffers */ +for (i =0 ; i <NXPWIFI_NUM_OF_CMD_BUFFER ; i++) { + cmd_array[i].skb =dev_alloc_skb (NXPWIFI_SIZE_OF_CMD_BUFFER ); +if (!cmd_array[i].skb) +return -ENOMEM ; + } + +for (i =0 ; i <NXPWIFI_NUM_OF_CMD_BUFFER ; i++) +nxpwifi_insert_cmd_to_free_q (adapter, &cmd_array[i]); + +return 0 ; +} + +/* This function frees the command buffers. +* +* The function calls the completion callback for all the command +* buffers that still have response buffers associated with them. +*/ +void nxpwifi_free_cmd_buffer (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_array; +u32 i; + +/* Need to check if cmd pool is allocated or not */ +if (!adapter->cmd_pool) { +nxpwifi_dbg (adapter,FATAL , +"info: FREE_CMD_BUF: cmd_pool is null\n" ); +return ; + } + + cmd_array = adapter->cmd_pool; + +/* Release shared memory buffers */ +for (i =0 ; i <NXPWIFI_NUM_OF_CMD_BUFFER ; i++) { +if (cmd_array[i].skb) { +nxpwifi_dbg (adapter,CMD , +"cmd: free cmd buffer %d\n" , i); +dev_kfree_skb_any (cmd_array[i].skb); + } +if (!cmd_array[i].resp_skb) +continue ; + +dev_kfree_skb_any (cmd_array[i].resp_skb); + } +/* Release struct cmd_ctrl_node */ +if (adapter->cmd_pool) { +nxpwifi_dbg (adapter,CMD , +"cmd: free cmd pool\n" ); +kfree (adapter->cmd_pool); + adapter->cmd_pool =NULL ; + } +} + +/* This function handles events generated by firmware. +* +* Event body of events received from firmware are not used (though they are +* saved), only the event ID is used. Some events are re-invoked by +* the driver, with a new event body. +* +* After processing, the function calls the completion callback +* for cleanup. +*/ +int nxpwifi_process_event (struct nxpwifi_adapter *adapter) +{ +int ret, i; +struct nxpwifi_private *priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +struct sk_buff *skb = adapter->event_skb; +u32 eventcause; +struct nxpwifi_rxinfo *rx_info; + +if ((adapter->event_cause &EVENT_ID_MASK ) ==EVENT_RADAR_DETECTED ) { +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv &&nxpwifi_is_11h_active (priv)) { + adapter->event_cause |= + ((priv->bss_num &0xff ) <<16 ) | + ((priv->bss_type &0xff ) <<24 ); +break ; + } + } + } + + eventcause = adapter->event_cause; + +/* Save the last event to debug log */ + adapter->dbg.last_event_index = + (adapter->dbg.last_event_index +1 ) %DBG_CMD_NUM ; + adapter->dbg.last_event[adapter->dbg.last_event_index] = + (u16 )eventcause; + +/* Get BSS number and corresponding priv */ + priv =nxpwifi_get_priv_by_id (adapter,EVENT_GET_BSS_NUM (eventcause), +EVENT_GET_BSS_TYPE (eventcause)); +if (!priv) + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); + +/* Clear BSS_NO_BITS from event */ + eventcause &=EVENT_ID_MASK ; + adapter->event_cause = eventcause; + +if (skb) { + rx_info =NXPWIFI_SKB_RXCB (skb); +memset (rx_info,0 ,sizeof (*rx_info)); + rx_info->bss_num = priv->bss_num; + rx_info->bss_type = priv->bss_type; +nxpwifi_dbg_dump (adapter,EVT_D ,"Event Buf:" , + skb->data, skb->len); + } + +nxpwifi_dbg (adapter,EVENT ,"EVENT: cause: %#x\n" , eventcause); + +if (priv->bss_role ==NXPWIFI_BSS_ROLE_UAP ) + ret =nxpwifi_process_uap_event (priv); +else + ret =nxpwifi_process_sta_event (priv); + + adapter->event_cause =0 ; + adapter->event_skb =NULL ; + adapter->if_ops.event_complete (adapter, skb); + +return ret; +} + +/* This function prepares a command and send it to the firmware. +* +* Preparation includes - +* - Sanity tests to make sure the card is still present or the FW +* is not reset +* - Getting a new command node from the command free queue +* - Initializing the command node for default parameters +* - Fill up the non-default parameters and buffer pointers +* - Add the command to pending queue +*/ +int nxpwifi_send_cmd (struct nxpwifi_private *priv,u16 cmd_no, +u16 cmd_action,u32 cmd_oid,void *data_buf,bool sync) +{ +int ret; +struct nxpwifi_adapter *adapter = priv->adapter; +struct cmd_ctrl_node *cmd_node; + +if (!adapter) { +pr_err ("PREP_CMD: adapter is NULL\n" ); +return -EINVAL ; + } + +if (test_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags)) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: device in suspended state\n" ); +return -EPERM ; + } + +if (test_bit (NXPWIFI_IS_HS_ENABLING , &adapter->work_flags) && + cmd_no !=HOST_CMD_802_11_HS_CFG_ENH ) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: host entering sleep state\n" ); +return -EPERM ; + } + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: card is removed\n" ); +return -EPERM ; + } + +if (test_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags)) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: FW is in bad state\n" ); +return -EPERM ; + } + +if (adapter->hw_status ==NXPWIFI_HW_STATUS_RESET ) { +if (cmd_no !=HOST_CMD_FUNC_INIT ) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: FW in reset state\n" ); +return -EPERM ; + } + } + +if (priv->adapter->hs_activated_manually && + cmd_no !=HOST_CMD_802_11_HS_CFG_ENH ) { +nxpwifi_cancel_hs (priv,NXPWIFI_ASYNC_CMD ); + priv->adapter->hs_activated_manually = false; + } + +/* Get a new command node */ + cmd_node =nxpwifi_get_cmd_node (adapter); + +if (!cmd_node) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: no free cmd node\n" ); +return -ENOMEM ; + } + +/* Initialize the command node */ +nxpwifi_init_cmd_node (priv, cmd_node, cmd_no, data_buf, sync); + +if (!cmd_node->cmd_skb) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: no free cmd buf\n" ); +return -ENOMEM ; + } + +skb_put_zero (cmd_node->cmd_skb,sizeof (struct host_cmd_ds_command )); + +/* Prepare command */ +if (cmd_no) { +switch (cmd_no) { +case HOST_CMD_UAP_SYS_CONFIG : +case HOST_CMD_UAP_BSS_START : +case HOST_CMD_UAP_BSS_STOP : +case HOST_CMD_UAP_STA_DEAUTH : +case HOST_CMD_APCMD_SYS_RESET : +case HOST_CMD_APCMD_STA_LIST : +case HOST_CMD_CHAN_REPORT_REQUEST : +case HOST_CMD_ADD_NEW_STATION : + ret =nxpwifi_uap_prepare_cmd (priv, cmd_node, + cmd_action, cmd_oid); +break ; +default : + ret =nxpwifi_sta_prepare_cmd (priv, cmd_node, + cmd_action, cmd_oid); +break ; + } + }else { + ret =nxpwifi_cmd_host_cmd (priv, cmd_node); + cmd_node->cmd_flag |=CMD_F_HOSTCMD ; + } + +/* Return error, since the command preparation failed */ +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"PREP_CMD: cmd %#x preparation failed\n" , + cmd_no); +nxpwifi_insert_cmd_to_free_q (adapter, cmd_node); +return ret; + } + +/* Send command */ +if (cmd_no ==HOST_CMD_802_11_SCAN || + cmd_no ==HOST_CMD_802_11_SCAN_EXT ) { +nxpwifi_queue_scan_cmd (priv, cmd_node); + }else { +nxpwifi_insert_cmd_to_pending_q (adapter, cmd_node); +nxpwifi_queue_work (adapter, &adapter->main_work); +if (cmd_node->wait_q_enabled) + ret =nxpwifi_wait_queue_complete (adapter, cmd_node); + } + +return ret; +} + +/* This function queues a command to the command pending queue. +* +* This in effect adds the command to the command list to be executed. +* Exit PS command is handled specially, by placing it always to the +* front of the command queue. +*/ +void +nxpwifi_insert_cmd_to_pending_q (struct nxpwifi_adapter *adapter, +struct cmd_ctrl_node *cmd_node) +{ +struct host_cmd_ds_command *host_cmd =NULL ; +u16 command; +bool add_tail = true; + + host_cmd = (struct host_cmd_ds_command *)(cmd_node->cmd_skb->data); +if (!host_cmd) { +nxpwifi_dbg (adapter,ERROR ,"QUEUE_CMD: host_cmd is NULL\n" ); +return ; + } + + command =le16_to_cpu (host_cmd->command); + +/* Exit_PS command needs to be queued in the header always. */ +if (command ==HOST_CMD_802_11_PS_MODE_ENH ) { +struct host_cmd_ds_802_11_ps_mode_enh *pm = + &host_cmd->params.psmode_enh; +if ((le16_to_cpu (pm->action) ==DIS_PS ) || + (le16_to_cpu (pm->action) ==DIS_AUTO_PS )) { +if (adapter->ps_state !=PS_STATE_AWAKE ) + add_tail = false; + } + } + +/* Same with exit host sleep cmd, luckily that can't happen at the same time as EXIT_PS */ +if (command ==HOST_CMD_802_11_HS_CFG_ENH ) { +struct host_cmd_ds_802_11_hs_cfg_enh *hs_cfg = + &host_cmd->params.opt_hs_cfg; + +if (le16_to_cpu (hs_cfg->action) ==HS_ACTIVATE ) + add_tail = false; + } + +spin_lock_bh (&adapter->cmd_pending_q_lock); +if (add_tail) +list_add_tail (&cmd_node->list, &adapter->cmd_pending_q); +else +list_add (&cmd_node->list, &adapter->cmd_pending_q); +spin_unlock_bh (&adapter->cmd_pending_q_lock); + +atomic_inc (&adapter->cmd_pending); +nxpwifi_dbg (adapter,CMD , +"cmd: QUEUE_CMD: cmd=%#x, cmd_pending=%d\n" , + command,atomic_read (&adapter->cmd_pending)); +} + +/* This function executes the next command in command pending queue. +* +* This function will fail if a command is already in processing stage, +* otherwise it will dequeue the first command from the command pending +* queue and send to the firmware. +* +* If the device is currently in host sleep mode, any commands, except the +* host sleep configuration command will de-activate the host sleep. For PS +* mode, the function will put the firmware back to sleep if applicable. +*/ +int nxpwifi_exec_next_cmd (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +struct cmd_ctrl_node *cmd_node; +int ret =0 ; +struct host_cmd_ds_command *host_cmd; + +/* Check if already in processing */ +if (adapter->curr_cmd) { +nxpwifi_dbg (adapter,FATAL , +"EXEC_NEXT_CMD: cmd in processing\n" ); +return -EBUSY ; + } + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); +/* Check if any command is pending */ +spin_lock_bh (&adapter->cmd_pending_q_lock); +if (list_empty (&adapter->cmd_pending_q)) { +spin_unlock_bh (&adapter->cmd_pending_q_lock); +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); +return 0 ; + } + cmd_node =list_first_entry (&adapter->cmd_pending_q, + struct cmd_ctrl_node, list); + + host_cmd = (struct host_cmd_ds_command *)(cmd_node->cmd_skb->data); + priv = cmd_node->priv; + +if (adapter->ps_state !=PS_STATE_AWAKE ) { +nxpwifi_dbg (adapter,ERROR , +"%s: cannot send cmd in sleep state,\t" +"this should not happen\n" , __func__); +spin_unlock_bh (&adapter->cmd_pending_q_lock); +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); +return ret; + } + +list_del (&cmd_node->list); +spin_unlock_bh (&adapter->cmd_pending_q_lock); + +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + ret =nxpwifi_dnld_cmd_to_fw (priv, cmd_node); + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +/* Any command sent to the firmware when host is in sleep +* mode should de-configure host sleep. We should skip the +* host sleep configuration command itself though +*/ +if (priv && host_cmd->command != +cpu_to_le16 (HOST_CMD_802_11_HS_CFG_ENH )) { +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event (priv, false); + } + } + +return ret; +} + +static void +nxpwifi_process_cmdresp_error (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_ps_mode_enh *pm; + +nxpwifi_dbg (adapter,ERROR , +"CMD_RESP: cmd %#x error, result=%#x\n" , + resp->command, resp->result); + +if (adapter->curr_cmd->wait_q_enabled) + adapter->cmd_wait_q.status =-1 ; + +switch (le16_to_cpu (resp->command)) { +case HOST_CMD_802_11_PS_MODE_ENH : + pm = &resp->params.psmode_enh; +nxpwifi_dbg (adapter,ERROR , +"PS_MODE_ENH cmd failed: result=0x%x action=0x%X\n" , + resp->result,le16_to_cpu (pm->action)); +break ; +case HOST_CMD_802_11_SCAN : +case HOST_CMD_802_11_SCAN_EXT : +nxpwifi_cancel_scan (adapter); +break ; + +case HOST_CMD_MAC_CONTROL : +break ; + +case HOST_CMD_SDIO_SP_RX_AGGR_CFG : +nxpwifi_dbg (adapter,MSG , +"SDIO RX single-port aggregation Not support\n" ); +break ; + +default : +break ; + } +/* Handling errors here */ +nxpwifi_recycle_cmd_node (adapter, adapter->curr_cmd); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->curr_cmd =NULL ; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); +} + +/* This function handles the command response. +* +* After processing, the function cleans the command node and puts +* it back to the command free queue. +*/ +int nxpwifi_process_cmdresp (struct nxpwifi_adapter *adapter) +{ +struct host_cmd_ds_command *resp; +struct nxpwifi_private *priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +int ret =0 ; +u16 orig_cmdresp_no; +u16 cmdresp_no; +u16 cmdresp_result; + +if (!adapter->curr_cmd || !adapter->curr_cmd->resp_skb) { + resp = (struct host_cmd_ds_command *)adapter->upld_buf; +nxpwifi_dbg (adapter,ERROR , +"CMD_RESP: NULL curr_cmd, %#x\n" , +le16_to_cpu (resp->command)); +return -EINVAL ; + } + + resp = (struct host_cmd_ds_command *)adapter->curr_cmd->resp_skb->data; + orig_cmdresp_no =le16_to_cpu (resp->command); + cmdresp_no = (orig_cmdresp_no &HOST_CMD_ID_MASK ); + +if (adapter->curr_cmd->cmd_no != cmdresp_no) { +nxpwifi_dbg (adapter,ERROR , +"cmdresp error: cmd=0x%x cmd_resp=0x%x\n" , + adapter->curr_cmd->cmd_no, cmdresp_no); +return -EINVAL ; + } +/* Now we got response from FW, cancel the command timer */ +del_timer_sync (&adapter->cmd_timer); +clear_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags); + +if (adapter->curr_cmd->cmd_flag &CMD_F_HOSTCMD ) { +/* Copy original response back to response buffer */ +struct nxpwifi_ds_misc_cmd *hostcmd; +u16 size =le16_to_cpu (resp->size); + +nxpwifi_dbg (adapter,INFO , +"info: host cmd resp size = %d\n" , size); + size =min_t (u16, size,NXPWIFI_SIZE_OF_CMD_BUFFER ); +if (adapter->curr_cmd->data_buf) { + hostcmd = adapter->curr_cmd->data_buf; + hostcmd->len = size; +memcpy (hostcmd->cmd, resp, size); + } + } + +/* Get BSS number and corresponding priv */ + priv =nxpwifi_get_priv_by_id + (adapter,HOST_GET_BSS_NO (le16_to_cpu (resp->seq_num)), +HOST_GET_BSS_TYPE (le16_to_cpu (resp->seq_num))); +if (!priv) + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +/* Clear RET_BIT from HOST */ + resp->command =cpu_to_le16 (orig_cmdresp_no &HOST_CMD_ID_MASK ); + + cmdresp_no =le16_to_cpu (resp->command); + cmdresp_result =le16_to_cpu (resp->result); + +/* Save the last command response to debug log */ + adapter->dbg.last_cmd_resp_index = + (adapter->dbg.last_cmd_resp_index +1 ) %DBG_CMD_NUM ; + adapter->dbg.last_cmd_resp_id[adapter->dbg.last_cmd_resp_index] = + orig_cmdresp_no; + +nxpwifi_dbg (adapter,CMD , +"cmd: CMD_RESP: 0x%x, result %d, len %d, seqno 0x%x\n" , + orig_cmdresp_no, cmdresp_result, +le16_to_cpu (resp->size),le16_to_cpu (resp->seq_num)); +nxpwifi_dbg_dump (adapter,CMD_D ,"CMD_RESP buffer:" , resp, +le16_to_cpu (resp->size)); + +if (!(orig_cmdresp_no &HOST_RET_BIT )) { +nxpwifi_dbg (adapter,ERROR ,"CMD_RESP: invalid cmd resp\n" ); +if (adapter->curr_cmd->wait_q_enabled) + adapter->cmd_wait_q.status =-1 ; + +nxpwifi_recycle_cmd_node (adapter, adapter->curr_cmd); +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->curr_cmd =NULL ; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); +return -EINVAL ; + } + +if (adapter->curr_cmd->cmd_flag &CMD_F_HOSTCMD ) { + adapter->curr_cmd->cmd_flag &= ~CMD_F_HOSTCMD ; +if (cmdresp_result ==HOST_RESULT_OK && + cmdresp_no ==HOST_CMD_802_11_HS_CFG_ENH ) + ret =nxpwifi_ret_802_11_hs_cfg (priv, resp); + }else { +if (resp->result !=HOST_RESULT_OK ) { +nxpwifi_process_cmdresp_error (priv, resp); +return -EFAULT ; + } +if (adapter->curr_cmd->cmd_resp) { +void *data_buf = adapter->curr_cmd->data_buf; + + ret = adapter->curr_cmd->cmd_resp (priv, resp, + cmdresp_no, + data_buf); + } + } + +/* Check init command response */ +if (adapter->hw_status ==NXPWIFI_HW_STATUS_INITIALIZING ) { +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"%s: cmd %#x failed during\t" +"initialization\n" , __func__, cmdresp_no); +nxpwifi_init_fw_complete (adapter); +return ret; + }else if (adapter->last_init_cmd == cmdresp_no) { + adapter->hw_status =NXPWIFI_HW_STATUS_INIT_DONE ; + } + } + +if (adapter->curr_cmd) { +if (adapter->curr_cmd->wait_q_enabled) + adapter->cmd_wait_q.status = ret; + +nxpwifi_recycle_cmd_node (adapter, adapter->curr_cmd); + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + adapter->curr_cmd =NULL ; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + } + +return ret; +} + +void nxpwifi_process_assoc_resp (struct nxpwifi_adapter *adapter) +{ +struct cfg80211_rx_assoc_resp_data assoc_resp = { + .uapsd_queues =-1 , + }; +struct nxpwifi_private *priv = +nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); + +if (priv->assoc_rsp_size) { + assoc_resp.links[0 ].bss = priv->req_bss; + assoc_resp.buf = priv->assoc_rsp_buf; + assoc_resp.len = priv->assoc_rsp_size; +cfg80211_rx_assoc_resp (priv->netdev, + &assoc_resp); + priv->assoc_rsp_size =0 ; + } +} + +/* This function handles the timeout of command sending. +* +* It will re-send the same command again. +*/ +void +nxpwifi_cmd_timeout_func (struct timer_list *t) +{ +struct nxpwifi_adapter *adapter =from_timer (adapter, t, cmd_timer); +struct cmd_ctrl_node *cmd_node; + +set_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags); +if (!adapter->curr_cmd) { +nxpwifi_dbg (adapter,ERROR , +"cmd: empty curr_cmd\n" ); +return ; + } + cmd_node = adapter->curr_cmd; +if (cmd_node) { + adapter->dbg.timeout_cmd_id = + adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index]; + adapter->dbg.timeout_cmd_act = + adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index]; +nxpwifi_dbg (adapter,MSG , +"%s: Timeout cmd id = %#x, act = %#x\n" , __func__, + adapter->dbg.timeout_cmd_id, + adapter->dbg.timeout_cmd_act); + +nxpwifi_dbg (adapter,MSG , +"num_data_h2c_failure = %d\n" , + adapter->dbg.num_tx_host_to_card_failure); +nxpwifi_dbg (adapter,MSG , +"num_cmd_h2c_failure = %d\n" , + adapter->dbg.num_cmd_host_to_card_failure); + +nxpwifi_dbg (adapter,MSG , +"is_cmd_timedout = %d\n" , +test_bit (NXPWIFI_IS_CMD_TIMEDOUT , + &adapter->work_flags)); +nxpwifi_dbg (adapter,MSG , +"num_tx_timeout = %d\n" , + adapter->dbg.num_tx_timeout); + +nxpwifi_dbg (adapter,MSG , +"last_cmd_index = %d\n" , + adapter->dbg.last_cmd_index); +nxpwifi_dbg (adapter,MSG , +"last_cmd_id: %*ph\n" , + (int )sizeof (adapter->dbg.last_cmd_id), + adapter->dbg.last_cmd_id); +nxpwifi_dbg (adapter,MSG , +"last_cmd_act: %*ph\n" , + (int )sizeof (adapter->dbg.last_cmd_act), + adapter->dbg.last_cmd_act); + +nxpwifi_dbg (adapter,MSG , +"last_cmd_resp_index = %d\n" , + adapter->dbg.last_cmd_resp_index); +nxpwifi_dbg (adapter,MSG , +"last_cmd_resp_id: %*ph\n" , + (int )sizeof (adapter->dbg.last_cmd_resp_id), + adapter->dbg.last_cmd_resp_id); + +nxpwifi_dbg (adapter,MSG , +"last_event_index = %d\n" , + adapter->dbg.last_event_index); +nxpwifi_dbg (adapter,MSG , +"last_event: %*ph\n" , + (int )sizeof (adapter->dbg.last_event), + adapter->dbg.last_event); + +nxpwifi_dbg (adapter,MSG , +"data_sent=%d cmd_sent=%d\n" , + adapter->data_sent, adapter->cmd_sent); + +nxpwifi_dbg (adapter,MSG , +"ps_mode=%d ps_state=%d\n" , + adapter->ps_mode, adapter->ps_state); + +if (cmd_node->wait_q_enabled) { + adapter->cmd_wait_q.status = -ETIMEDOUT ; +nxpwifi_cancel_pending_ioctl (adapter); + } + } +if (adapter->hw_status ==NXPWIFI_HW_STATUS_INITIALIZING ) { +nxpwifi_init_fw_complete (adapter); +return ; + } + +if (adapter->if_ops.device_dump) + adapter->if_ops.device_dump (adapter); + +if (adapter->if_ops.card_reset) + adapter->if_ops.card_reset (adapter); +} + +void +nxpwifi_cancel_pending_scan_cmd (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_node =NULL , *tmp_node; + +/* Cancel all pending scan command */ +spin_lock_bh (&adapter->scan_pending_q_lock); +list_for_each_entry_safe (cmd_node, tmp_node, + &adapter->scan_pending_q, list) { +list_del (&cmd_node->list); + cmd_node->wait_q_enabled = false; +nxpwifi_insert_cmd_to_free_q (adapter, cmd_node); + } +spin_unlock_bh (&adapter->scan_pending_q_lock); +} + +/* This function cancels all the pending commands. +* +* The current command, all commands in command pending queue and all scan +* commands in scan pending queue are cancelled. All the completion callbacks +* are called with failure status to ensure cleanup. +*/ +void +nxpwifi_cancel_all_pending_cmd (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_node =NULL , *tmp_node; + +spin_lock_bh (&adapter->nxpwifi_cmd_lock); +/* Cancel current cmd */ +if (adapter->curr_cmd && adapter->curr_cmd->wait_q_enabled) { + adapter->cmd_wait_q.status =-1 ; +nxpwifi_complete_cmd (adapter, adapter->curr_cmd); + adapter->curr_cmd->wait_q_enabled = false; +/* no recycle probably wait for response */ + } +/* Cancel all pending command */ +spin_lock_bh (&adapter->cmd_pending_q_lock); +list_for_each_entry_safe (cmd_node, tmp_node, + &adapter->cmd_pending_q, list) { +list_del (&cmd_node->list); + +if (cmd_node->wait_q_enabled) + adapter->cmd_wait_q.status =-1 ; +nxpwifi_recycle_cmd_node (adapter, cmd_node); + } +spin_unlock_bh (&adapter->cmd_pending_q_lock); +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + +nxpwifi_cancel_scan (adapter); +} + +/* This function cancels all pending commands that matches with +* the given IOCTL request. +* +* Both the current command buffer and the pending command queue are +* searched for matching IOCTL request. The completion callback of +* the matched command is called with failure status to ensure cleanup. +* In case of scan commands, all pending commands in scan pending queue +* are cancelled. +*/ +static void +nxpwifi_cancel_pending_ioctl (struct nxpwifi_adapter *adapter) +{ +struct cmd_ctrl_node *cmd_node =NULL ; + +if (adapter->curr_cmd && + adapter->curr_cmd->wait_q_enabled) { +spin_lock_bh (&adapter->nxpwifi_cmd_lock); + cmd_node = adapter->curr_cmd; +/* setting curr_cmd to NULL is quite dangerous, because +* nxpwifi_process_cmdresp checks curr_cmd to be != NULL +* at the beginning then relies on it and dereferences +* it at will +* this probably works since nxpwifi_cmd_timeout_func +* is the only caller of this function and responses +* at that point +*/ + adapter->curr_cmd =NULL ; +spin_unlock_bh (&adapter->nxpwifi_cmd_lock); + +nxpwifi_recycle_cmd_node (adapter, cmd_node); + } + +nxpwifi_cancel_scan (adapter); +} + +/* This function sends the sleep confirm command to firmware, if +* possible. +* +* The sleep confirm command cannot be issued if command response, +* data response or event response is awaiting handling, or if we +* are in the middle of sending a command, or expecting a command +* response. +*/ +void +nxpwifi_check_ps_cond (struct nxpwifi_adapter *adapter) +{ +if (!adapter->cmd_sent && !atomic_read (&adapter->tx_hw_pending) && + !adapter->curr_cmd && !IS_CARD_RX_RCVD (adapter)) +nxpwifi_dnld_sleep_confirm_cmd (adapter); +else +nxpwifi_dbg (adapter,CMD , +"cmd: Delay Sleep Confirm (%s%s%s%s)\n" , + (adapter->cmd_sent) ?"D" :"" , +atomic_read (&adapter->tx_hw_pending) ?"T" :"" , + (adapter->curr_cmd) ?"C" :"" , + (IS_CARD_RX_RCVD (adapter)) ?"R" :"" ); +} + +/* This function sends a Host Sleep activated event to applications. +* +* This event is generated by the driver, with a blank event body. +*/ +void +nxpwifi_hs_activated_event (struct nxpwifi_private *priv,u8 activated) +{ +if (activated) { +if (test_bit (NXPWIFI_IS_HS_CONFIGURED , + &priv->adapter->work_flags)) { + priv->adapter->hs_activated = true; +nxpwifi_update_rxreor_flags (priv->adapter, +RXREOR_FORCE_NO_DROP ); +nxpwifi_dbg (priv->adapter,EVENT , +"event: hs_activated\n" ); + priv->adapter->hs_activate_wait_q_woken = true; +wake_up_interruptible (&priv->adapter->hs_activate_wait_q); + }else { +nxpwifi_dbg (priv->adapter,EVENT , +"event: HS not configured\n" ); + } + }else { +nxpwifi_dbg (priv->adapter,EVENT , +"event: hs_deactivated\n" ); + priv->adapter->hs_activated = false; + } +} + +/* This function handles the command response of a Host Sleep configuration +* command. +* +* Handling includes changing the header fields into CPU format +* and setting the current host sleep activation status in driver. +* +* In case host sleep status change, the function generates an event to +* notify the applications. +*/ +int nxpwifi_ret_802_11_hs_cfg (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct host_cmd_ds_802_11_hs_cfg_enh *phs_cfg = + &resp->params.opt_hs_cfg; +u32 conditions =le32_to_cpu (phs_cfg->params.hs_config.conditions); + +if (phs_cfg->action ==cpu_to_le16 (HS_ACTIVATE )) { +nxpwifi_hs_activated_event (priv, true); + goto done; + }else { +nxpwifi_dbg (adapter,CMD , +"cmd: CMD_RESP: HS_CFG cmd reply\t" +" result=%#x, conditions=0x%x gpio=0x%x gap=0x%x\n" , + resp->result, conditions, + phs_cfg->params.hs_config.gpio, + phs_cfg->params.hs_config.gap); + } +if (conditions !=HS_CFG_CANCEL ) { +set_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags); + }else { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags); +if (adapter->hs_activated) +nxpwifi_hs_activated_event (priv, false); + } + +done: +return 0 ; +} + +/* This function wakes up the adapter and generates a Host Sleep +* cancel event on receiving the power up interrupt. +*/ +void +nxpwifi_process_hs_config (struct nxpwifi_adapter *adapter) +{ +nxpwifi_dbg (adapter,INFO , +"info: %s: auto cancelling host sleep\t" +"since there is interrupt from the firmware\n" , + __func__); + + adapter->if_ops.wakeup (adapter); + +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + + adapter->hs_activated = false; +clear_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags); +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); +nxpwifi_hs_activated_event (nxpwifi_get_priv (adapter, +NXPWIFI_BSS_ROLE_ANY ), + false); +} +EXPORT_SYMBOL_GPL (nxpwifi_process_hs_config); + +/* This function handles the command response of a sleep confirm command. +* +* The function sets the card state to SLEEP if the response indicates success. +*/ +void +nxpwifi_process_sleep_confirm_resp (struct nxpwifi_adapter *adapter, +u8 *pbuf,u32 upld_len) +{ +struct host_cmd_ds_command *cmd = (struct host_cmd_ds_command *)pbuf; +u16 result =le16_to_cpu (cmd->result); +u16 command =le16_to_cpu (cmd->command); +u16 seq_num =le16_to_cpu (cmd->seq_num); + +if (!upld_len) { +nxpwifi_dbg (adapter,ERROR , +"%s: cmd size is 0\n" , __func__); +return ; + } + +nxpwifi_dbg (adapter,CMD , +"cmd: CMD_RESP: 0x%x, result %d, len %d, seqno 0x%x\n" , + command, result,le16_to_cpu (cmd->size), seq_num); + +/* Update sequence number */ + seq_num =HOST_GET_SEQ_NO (seq_num); +/* Clear RET_BIT from HOST */ + command &=HOST_CMD_ID_MASK ; + +if (command !=HOST_CMD_802_11_PS_MODE_ENH ) { +nxpwifi_dbg (adapter,ERROR , +"%s: rcvd unexpected resp for cmd %#x, result = %x\n" , + __func__, command, result); +return ; + } + +if (result) { +nxpwifi_dbg (adapter,ERROR , +"%s: sleep confirm cmd failed\n" , + __func__); + adapter->pm_wakeup_card_req = false; + adapter->ps_state =PS_STATE_AWAKE ; +return ; + } + adapter->pm_wakeup_card_req = true; +if (test_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags)) +nxpwifi_hs_activated_event (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + true); + adapter->ps_state =PS_STATE_SLEEP ; + cmd->command =cpu_to_le16 (command); + cmd->seq_num =cpu_to_le16 (seq_num); +} +EXPORT_SYMBOL_GPL (nxpwifi_process_sleep_confirm_resp);
Signature · 1 line
2.34.1
PATCH v2 15/43 wifi: nxpwifi: add cmdevt.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/cmdevt.h | 92 +++++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.h
drivers/net/wireless/nxp/nxpwifi/cmdevt.h new file +92 -0
@@ -0,0 +1,92 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: commands and events +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_CMD_EVT_H_ +#define _NXPWIFI_CMD_EVT_H_ + +struct nxpwifi_cmd_entry { +u16 cmd_no; +int (*prepare_cmd)(struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type); +int (*cmd_resp)(struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp, +u16 cmdresp_no, +void *data_buf); +}; + +struct nxpwifi_evt_entry { +u32 event_cause; +int (*event_handler)(struct nxpwifi_private *priv); +}; + +static inline int +nxpwifi_cmd_fill_head_only (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +u16 cmd_no,void *data_buf, +u16 cmd_action,u32 cmd_type) +{ + cmd->command =cpu_to_le16 (cmd_no); + cmd->size =cpu_to_le16 (S_DS_GEN ); + +return 0 ; +} + +int nxpwifi_send_cmd (struct nxpwifi_private *priv,u16 cmd_no, +u16 cmd_action,u32 cmd_oid,void *data_buf,bool sync); +int nxpwifi_sta_prepare_cmd (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node, +u16 cmd_action,u32 cmd_oid); +int nxpwifi_dnld_dt_cfgdata (struct nxpwifi_private *priv, +struct device_node *node,const char *prefix); +int nxpwifi_sta_init_cmd (struct nxpwifi_private *priv,u8 first_sta,bool init); +int nxpwifi_uap_prepare_cmd (struct nxpwifi_private *priv, +struct cmd_ctrl_node *cmd_node, +u16 cmd_action,u32 type); +int nxpwifi_set_secure_params (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_config, +struct cfg80211_ap_settings *params); +void nxpwifi_set_ht_params (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_ap_settings *params); +void nxpwifi_set_vht_params (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_ap_settings *params); +void nxpwifi_set_tpc_params (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_ap_settings *params); +void nxpwifi_set_uap_rates (struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_ap_settings *params); +void nxpwifi_set_vht_width (struct nxpwifi_private *priv, +enum nl80211_chan_width width, +bool ap_11ac_disable); +void nxpwifi_set_sys_config_invalid_data (struct nxpwifi_uap_bss_param *config); +void nxpwifi_set_wmm_params (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_ap_settings *params); +void nxpwifi_config_uap_11d (struct nxpwifi_private *priv, +struct cfg80211_beacon_data *beacon_data); +void nxpwifi_uap_set_channel (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg, +struct cfg80211_chan_def chandef); +int nxpwifi_config_start_uap (struct nxpwifi_private *priv, +struct nxpwifi_uap_bss_param *bss_cfg); + +int nxpwifi_process_event (struct nxpwifi_adapter *adapter); +int nxpwifi_process_sta_event (struct nxpwifi_private *priv); +int nxpwifi_process_uap_event (struct nxpwifi_private *priv); +void nxpwifi_reset_connect_state (struct nxpwifi_private *priv,u16 reason, +bool from_ap); +void nxpwifi_process_multi_chan_event (struct nxpwifi_private *priv, +struct sk_buff *event_skb); +void nxpwifi_process_tx_pause_event (struct nxpwifi_private *priv, +struct sk_buff *event); +void nxpwifi_bt_coex_wlan_param_update_event (struct nxpwifi_private *priv, +struct sk_buff *event_skb); + +#endif /* !_NXPWIFI_CMD_EVT_H_ */
Signature · 1 line
2.34.1
PATCH v2 16/43 wifi: nxpwifi: add debugfs.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/debugfs.c | 1041 ++++++++++++++++++++ 1 file changed, 1041 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/debugfs.c
drivers/net/wireless/nxp/nxpwifi/debugfs.c new file +1041 -0
@@ -0,0 +1,1041 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: debugfs +* +* Copyright 2011-2024 NXP +*/ + +#include <linux/debugfs.h> + +#include "main.h" +#include "cmdevt.h" +#include "11n.h" + +static struct dentry *nxpwifi_dfs_dir; + +static char *bss_modes[] = { +"UNSPECIFIED" , +"ADHOC" , +"STATION" , +"AP" , +"AP_VLAN" , +"WDS" , +"MONITOR" , +"MESH_POINT" , +"P2P_CLIENT" , +"P2P_GO" , +"P2P_DEVICE" , +}; + +/* Proc info file read handler. +* +* This function is called when the 'info' file is opened for reading. +* It prints the following driver related information - +* - Driver name +* - Driver version +* - Driver extended version +* - Interface name +* - BSS mode +* - Media state (connected or disconnected) +* - MAC address +* - Total number of Tx bytes +* - Total number of Rx bytes +* - Total number of Tx packets +* - Total number of Rx packets +* - Total number of dropped Tx packets +* - Total number of dropped Rx packets +* - Total number of corrupted Tx packets +* - Total number of corrupted Rx packets +* - Carrier status (on or off) +* - Tx queue status (started or stopped) +* +* For STA mode drivers, it also prints the following extra - +* - ESSID +* - BSSID +* - Channel +* - Region code +* - Multicast count +* - Multicast addresses +*/ +static ssize_t +nxpwifi_info_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +struct net_device *netdev = priv->netdev; +struct netdev_hw_addr *ha; +struct netdev_queue *txq; +unsigned long page =get_zeroed_page (GFP_KERNEL ); +char *p = (char *)page, fmt[64 ]; +struct nxpwifi_bss_info info; +ssize_t ret; +int i =0 ; + +if (!p) +return -ENOMEM ; + +memset (&info,0 ,sizeof (info)); + ret =nxpwifi_get_bss_info (priv, &info); +if (ret) + goto free_and_exit; + +nxpwifi_drv_get_driver_version (priv->adapter, fmt,sizeof (fmt) -1 ); + +nxpwifi_get_ver_ext (priv,0 ); + + p +=sprintf (p,"driver_name = " ); + p +=sprintf (p,"\"nxpwifi\"\n" ); + p +=sprintf (p,"driver_version = %s" , fmt); + p +=sprintf (p,"\nverext = %s" , priv->version_str); + p +=sprintf (p,"\ninterface_name=\"%s\"\n" , netdev->name); + +if (info.bss_mode >=ARRAY_SIZE (bss_modes)) + p +=sprintf (p,"bss_mode=\"%d\"\n" , info.bss_mode); +else + p +=sprintf (p,"bss_mode=\"%s\"\n" , bss_modes[info.bss_mode]); + + p +=sprintf (p,"media_state=\"%s\"\n" , + (!priv->media_connected ?"Disconnected" :"Connected" )); + p +=sprintf (p,"mac_address=\"%pM\"\n" , netdev->dev_addr); + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA ) { + p +=sprintf (p,"multicast_count=\"%d\"\n" , +netdev_mc_count (netdev)); + p +=sprintf (p,"essid=\"%.*s\"\n" , info.ssid.ssid_len, + info.ssid.ssid); + p +=sprintf (p,"bssid=\"%pM\"\n" , info.bssid); + p +=sprintf (p,"channel=\"%d\"\n" , (int )info.bss_chan); + p +=sprintf (p,"country_code = \"%s\"\n" , info.country_code); + p +=sprintf (p,"region_code=\"0x%x\"\n" , + priv->adapter->region_code); + +netdev_for_each_mc_addr (ha, netdev) + p +=sprintf (p,"multicast_address[%d]=\"%pM\"\n" , + i++, ha->addr); + } + + p +=sprintf (p,"num_tx_bytes = %lu\n" , priv->stats.tx_bytes); + p +=sprintf (p,"num_rx_bytes = %lu\n" , priv->stats.rx_bytes); + p +=sprintf (p,"num_tx_pkts = %lu\n" , priv->stats.tx_packets); + p +=sprintf (p,"num_rx_pkts = %lu\n" , priv->stats.rx_packets); + p +=sprintf (p,"num_tx_pkts_dropped = %lu\n" , priv->stats.tx_dropped); + p +=sprintf (p,"num_rx_pkts_dropped = %lu\n" , priv->stats.rx_dropped); + p +=sprintf (p,"num_tx_pkts_err = %lu\n" , priv->stats.tx_errors); + p +=sprintf (p,"num_rx_pkts_err = %lu\n" , priv->stats.rx_errors); + p +=sprintf (p,"carrier %s\n" , ((netif_carrier_ok (priv->netdev)) + ?"on" :"off" )); + p +=sprintf (p,"tx queue" ); +for (i =0 ; i < netdev->num_tx_queues; i++) { + txq =netdev_get_tx_queue (netdev, i); + p +=sprintf (p," %d:%s" , i,netif_tx_queue_stopped (txq) ? +"stopped" :"started" ); + } + p +=sprintf (p,"\n" ); + + ret =simple_read_from_buffer (ubuf, count, ppos, (char *)page, + (unsigned long )p - page); + +free_and_exit: +free_page (page); +return ret; +} + +/* Proc getlog file read handler. +* +* This function is called when the 'getlog' file is opened for reading +* It prints the following log information - +* - Number of multicast Tx frames +* - Number of failed packets +* - Number of Tx retries +* - Number of multicast Tx retries +* - Number of duplicate frames +* - Number of RTS successes +* - Number of RTS failures +* - Number of ACK failures +* - Number of fragmented Rx frames +* - Number of multicast Rx frames +* - Number of FCS errors +* - Number of Tx frames +* - WEP ICV error counts +* - Number of received beacons +* - Number of missed beacons +*/ +static ssize_t +nxpwifi_getlog_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +unsigned long page =get_zeroed_page (GFP_KERNEL ); +char *p = (char *)page; +ssize_t ret; +struct nxpwifi_ds_get_stats stats; + +if (!p) +return -ENOMEM ; + +memset (&stats,0 ,sizeof (stats)); + ret =nxpwifi_get_stats_info (priv, &stats); +if (ret) + goto free_and_exit; + + p +=sprintf (p,"\n" +"mcasttxframe %u\n" +"failed %u\n" +"retry %u\n" +"multiretry %u\n" +"framedup %u\n" +"rtssuccess %u\n" +"rtsfailure %u\n" +"ackfailure %u\n" +"rxfrag %u\n" +"mcastrxframe %u\n" +"fcserror %u\n" +"txframe %u\n" +"wepicverrcnt-1 %u\n" +"wepicverrcnt-2 %u\n" +"wepicverrcnt-3 %u\n" +"wepicverrcnt-4 %u\n" +"bcn_rcv_cnt %u\n" +"bcn_miss_cnt %u\n" , + stats.mcast_tx_frame, + stats.failed, + stats.retry, + stats.multi_retry, + stats.frame_dup, + stats.rts_success, + stats.rts_failure, + stats.ack_failure, + stats.rx_frag, + stats.mcast_rx_frame, + stats.fcs_error, + stats.tx_frame, + stats.wep_icv_error[0 ], + stats.wep_icv_error[1 ], + stats.wep_icv_error[2 ], + stats.wep_icv_error[3 ], + stats.bcn_rcv_cnt, + stats.bcn_miss_cnt); + + ret =simple_read_from_buffer (ubuf, count, ppos, (char *)page, + (unsigned long )p - page); + +free_and_exit: +free_page (page); +return ret; +} + +/* Sysfs histogram file read handler. +* +* This function is called when the 'histogram' file is opened for reading +* It prints the following histogram information - +* - Number of histogram samples +* - Receive packet number of each rx_rate +* - Receive packet number of each snr +* - Receive packet number of each nosie_flr +* - Receive packet number of each signal streath +*/ +static ssize_t +nxpwifi_histogram_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +ssize_t ret; +struct nxpwifi_histogram_data *phist_data; +int i, value; +unsigned long page =get_zeroed_page (GFP_KERNEL ); +char *p = (char *)page; + +if (!p) +return -ENOMEM ; + +if (!priv || !priv->hist_data) { + ret = -EFAULT ; + goto free_and_exit; + } + + phist_data = priv->hist_data; + + p +=sprintf (p,"\n" +"total samples = %d\n" , +atomic_read (&phist_data->num_samples)); + + p +=sprintf (p, +"rx rates (in Mbps): 0=1M 1=2M 2=5.5M 3=11M 4=6M 5=9M 6=12M\n" +"7=18M 8=24M 9=36M 10=48M 11=54M 12-27=MCS0-15(BW20) 28-43=MCS0-15(BW40)\n" ); + +if (ISSUPP_11ACENABLED (priv->adapter->fw_cap_info)) { + p +=sprintf (p, +"44-53=MCS0-9(VHT:BW20) 54-63=MCS0-9(VHT:BW40) 64-73=MCS0-9(VHT:BW80)\n\n" ); + }else { + p +=sprintf (p,"\n" ); + } + +for (i =0 ; i <NXPWIFI_MAX_RX_RATES ; i++) { + value =atomic_read (&phist_data->rx_rate[i]); +if (value) + p +=sprintf (p,"rx_rate[%02d] = %d\n" , i, value); + } + +if (ISSUPP_11ACENABLED (priv->adapter->fw_cap_info)) { +for (i =NXPWIFI_MAX_RX_RATES ; i <NXPWIFI_MAX_AC_RX_RATES ; + i++) { + value =atomic_read (&phist_data->rx_rate[i]); +if (value) + p +=sprintf (p,"rx_rate[%02d] = %d\n" , + i, value); + } + } + +for (i =0 ; i <NXPWIFI_MAX_SNR ; i++) { + value =atomic_read (&phist_data->snr[i]); +if (value) + p +=sprintf (p,"snr[%02ddB] = %d\n" , i, value); + } +for (i =0 ; i <NXPWIFI_MAX_NOISE_FLR ; i++) { + value =atomic_read (&phist_data->noise_flr[i]); +if (value) + p +=sprintf (p,"noise_flr[%02ddBm] = %d\n" , + (int )(i -128 ), value); + } +for (i =0 ; i <NXPWIFI_MAX_SIG_STRENGTH ; i++) { + value =atomic_read (&phist_data->sig_str[i]); +if (value) + p +=sprintf (p,"sig_strength[-%02ddBm] = %d\n" , + i, value); + } + + ret =simple_read_from_buffer (ubuf, count, ppos, (char *)page, + (unsigned long )p - page); + +free_and_exit: +free_page (page); +return ret; +} + +static ssize_t +nxpwifi_histogram_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = (void *)file->private_data; + +if (priv && priv->hist_data) +nxpwifi_hist_data_reset (priv); +return 0 ; +} + +static struct nxpwifi_debug_info info; + +/* Proc debug file read handler. +* +* This function is called when the 'debug' file is opened for reading +* It prints the following log information - +* - Interrupt count +* - WMM AC VO packets count +* - WMM AC VI packets count +* - WMM AC BE packets count +* - WMM AC BK packets count +* - Maximum Tx buffer size +* - Tx buffer size +* - Current Tx buffer size +* - Power Save mode +* - Power Save state +* - Deep Sleep status +* - Device wakeup required status +* - Number of wakeup tries +* - Host Sleep configured status +* - Host Sleep activated status +* - Number of Tx timeouts +* - Number of command timeouts +* - Last timed out command ID +* - Last timed out command action +* - Last command ID +* - Last command action +* - Last command index +* - Last command response ID +* - Last command response index +* - Last event +* - Last event index +* - Number of host to card command failures +* - Number of sleep confirm command failures +* - Number of host to card data failure +* - Number of deauthentication events +* - Number of disassociation events +* - Number of link lost events +* - Number of deauthentication commands +* - Number of association success commands +* - Number of association failure commands +* - Number of commands sent +* - Number of data packets sent +* - Number of command responses received +* - Number of events received +* - Tx BA stream table (TID, RA) +* - Rx reorder table (TID, TA, Start window, Window size, Buffer) +*/ +static ssize_t +nxpwifi_debug_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +unsigned long page =get_zeroed_page (GFP_KERNEL ); +char *p = (char *)page; +ssize_t ret; + +if (!p) +return -ENOMEM ; + + ret =nxpwifi_get_debug_info (priv, &info); +if (ret) + goto free_and_exit; + + p +=nxpwifi_debug_info_to_buffer (priv, p, &info); + + ret =simple_read_from_buffer (ubuf, count, ppos, (char *)page, + (unsigned long )p - page); + +free_and_exit: +free_page (page); +return ret; +} + +static u32 saved_reg_type, saved_reg_offset, saved_reg_value; + +/* Proc regrdwr file write handler. +* +* This function is called when the 'regrdwr' file is opened for writing +* +* This function can be used to write to a register. +*/ +static ssize_t +nxpwifi_regrdwr_write (struct file *file, +const char __user *ubuf,size_t count,loff_t *ppos) +{ +char *buf; +int ret; +u32 reg_type =0 , reg_offset =0 , reg_value =UINT_MAX ; +int rv; + + buf =memdup_user_nul (ubuf,min (count, (size_t )(PAGE_SIZE -1 ))); +if (IS_ERR (buf)) +return PTR_ERR (buf); + + rv =sscanf (buf,"%u %x %x" , ®_type, ®_offset, ®_value); + +if (rv !=3 ) { + ret = -EINVAL ; + goto done; + } + +if (reg_type ==0 || reg_offset ==0 ) { + ret = -EINVAL ; + goto done; + }else { + saved_reg_type = reg_type; + saved_reg_offset = reg_offset; + saved_reg_value = reg_value; + ret = count; + } +done: +kfree (buf); +return ret; +} + +/* Proc regrdwr file read handler. +* +* This function is called when the 'regrdwr' file is opened for reading +* +* This function can be used to read from a register. +*/ +static ssize_t +nxpwifi_regrdwr_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +unsigned long addr =get_zeroed_page (GFP_KERNEL ); +char *buf = (char *)addr; +int pos =0 , ret =0 ; +u32 reg_value; + +if (!buf) +return -ENOMEM ; + +if (!saved_reg_type) { +/* No command has been given */ + pos +=snprintf (buf,PAGE_SIZE ,"0" ); + goto done; + } +/* Set command has been given */ +if (saved_reg_value !=UINT_MAX ) { + ret =nxpwifi_reg_write (priv, saved_reg_type, saved_reg_offset, + saved_reg_value); + + pos +=snprintf (buf,PAGE_SIZE ,"%u 0x%x 0x%x\n" , + saved_reg_type, saved_reg_offset, + saved_reg_value); + + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); + + goto done; + } +/* Get command has been given */ + ret =nxpwifi_reg_read (priv, saved_reg_type, + saved_reg_offset, ®_value); +if (ret) { + ret = -EINVAL ; + goto done; + } + + pos +=snprintf (buf,PAGE_SIZE ,"%u 0x%x 0x%x\n" , saved_reg_type, + saved_reg_offset, reg_value); + + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); + +done: +free_page (addr); +return ret; +} + +/* Proc debug_mask file read handler. +* This function is called when the 'debug_mask' file is opened for reading +* This function can be used read driver debugging mask value. +*/ +static ssize_t +nxpwifi_debug_mask_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +unsigned long page =get_zeroed_page (GFP_KERNEL ); +char *buf = (char *)page; +size_t ret =0 ; +int pos =0 ; + +if (!buf) +return -ENOMEM ; + + pos +=snprintf (buf,PAGE_SIZE ,"debug mask=0x%08x\n" , + priv->adapter->debug_mask); + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); + +free_page (page); +return ret; +} + +/* Proc debug_mask file read handler. +* This function is called when the 'debug_mask' file is opened for reading +* This function can be used read driver debugging mask value. +*/ +static ssize_t +nxpwifi_debug_mask_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +int ret; +unsigned long debug_mask; +struct nxpwifi_private *priv = (void *)file->private_data; +char *buf; + + buf =memdup_user_nul (ubuf,min (count, (size_t )(PAGE_SIZE -1 ))); +if (IS_ERR (buf)) +return PTR_ERR (buf); + +if (kstrtoul (buf,0 , &debug_mask)) { + ret = -EINVAL ; + goto done; + } + + priv->adapter->debug_mask = debug_mask; + ret = count; +done: +kfree (buf); +return ret; +} + +/* debugfs verext file write handler. +* This function is called when the 'verext' file is opened for write +*/ +static ssize_t +nxpwifi_verext_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +int ret; +u32 versionstrsel; +struct nxpwifi_private *priv = (void *)file->private_data; + + ret =kstrtou32_from_user (ubuf, count,10 , &versionstrsel); +if (ret) +return ret; + + priv->versionstrsel = versionstrsel; + +return count; +} + +/* Proc verext file read handler. +* This function is called when the 'verext' file is opened for reading +* This function can be used read driver exteneed verion string. +*/ +static ssize_t +nxpwifi_verext_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +char buf[256 ]; +int ret; + +nxpwifi_get_ver_ext (priv, priv->versionstrsel); + ret =snprintf (buf,sizeof (buf),"version string: %s\n" , + priv->version_str); + +return simple_read_from_buffer (ubuf, count, ppos, buf, ret); +} + +/* Proc memrw file write handler. +* This function is called when the 'memrw' file is opened for writing +* This function can be used to write to a memory location. +*/ +static ssize_t +nxpwifi_memrw_write (struct file *file,const char __user *ubuf,size_t count, +loff_t *ppos) +{ +int ret; +char cmd; +struct nxpwifi_ds_mem_rw mem_rw; +u16 cmd_action; +struct nxpwifi_private *priv = (void *)file->private_data; +char *buf; + + buf =memdup_user_nul (ubuf,min (count, (size_t )(PAGE_SIZE -1 ))); +if (IS_ERR (buf)) +return PTR_ERR (buf); + + ret =sscanf (buf,"%c %x %x" , &cmd, &mem_rw.addr, &mem_rw.value); +if (ret !=3 ) { + ret = -EINVAL ; + goto done; + } + +if ((cmd =='r' ) || (cmd =='R' )) { + cmd_action =HOST_ACT_GEN_GET ; + mem_rw.value =0 ; + }else if ((cmd =='w' ) || (cmd =='W' )) { + cmd_action =HOST_ACT_GEN_SET ; + }else { + ret = -EINVAL ; + goto done; + } + +memcpy (&priv->mem_rw, &mem_rw,sizeof (mem_rw)); + ret =nxpwifi_send_cmd (priv,HOST_CMD_MEM_ACCESS , cmd_action,0 , + &mem_rw, true); +if (!ret) + ret = count; + +done: +kfree (buf); +return ret; +} + +/* Proc memrw file read handler. +* This function is called when the 'memrw' file is opened for reading +* This function can be used to read from a memory location. +*/ +static ssize_t +nxpwifi_memrw_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = (void *)file->private_data; +unsigned long addr =get_zeroed_page (GFP_KERNEL ); +char *buf = (char *)addr; +int ret, pos =0 ; + +if (!buf) +return -ENOMEM ; + + pos +=snprintf (buf,PAGE_SIZE ,"0x%x 0x%x\n" , priv->mem_rw.addr, + priv->mem_rw.value); + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); + +free_page (addr); +return ret; +} + +static u32 saved_offset =-1 , saved_bytes =-1 ; + +/* Proc rdeeprom file write handler. +* +* This function is called when the 'rdeeprom' file is opened for writing +* +* This function can be used to write to a RDEEPROM location. +*/ +static ssize_t +nxpwifi_rdeeprom_write (struct file *file, +const char __user *ubuf,size_t count,loff_t *ppos) +{ +char *buf; +int ret =0 ; +int offset =-1 , bytes =-1 ; +int rv; + + buf =memdup_user_nul (ubuf,min (count, (size_t )(PAGE_SIZE -1 ))); +if (IS_ERR (buf)) +return PTR_ERR (buf); + + rv =sscanf (buf,"%d %d" , &offset, &bytes); + +if (rv !=2 ) { + ret = -EINVAL ; + goto done; + } + +if (offset ==-1 || bytes ==-1 ) { + ret = -EINVAL ; + goto done; + }else { + saved_offset = offset; + saved_bytes = bytes; + ret = count; + } +done: +kfree (buf); +return ret; +} + +/* Proc rdeeprom read write handler. +* +* This function is called when the 'rdeeprom' file is opened for reading +* +* This function can be used to read from a RDEEPROM location. +*/ +static ssize_t +nxpwifi_rdeeprom_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = + (struct nxpwifi_private *)file->private_data; +unsigned long addr =get_zeroed_page (GFP_KERNEL ); +char *buf = (char *)addr; +int pos, ret, i; +u8 value[MAX_EEPROM_DATA ]; + +if (!buf) +return -ENOMEM ; + +if (saved_offset ==-1 ) { +/* No command has been given */ + pos =snprintf (buf,PAGE_SIZE ,"0" ); + goto done; + } + +/* Get command has been given */ + ret =nxpwifi_eeprom_read (priv, (u16 )saved_offset, + (u16 )saved_bytes, value); +if (ret) { + ret = -EINVAL ; + goto out_free; + } + + pos =snprintf (buf,PAGE_SIZE ,"%d %d " , saved_offset, saved_bytes); + +for (i =0 ; i < saved_bytes; i++) + pos +=scnprintf (buf + pos,PAGE_SIZE - pos,"%d " , value[i]); + +done: + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); +out_free: +free_page (addr); +return ret; +} + +/* Proc hscfg file write handler +* This function can be used to configure the host sleep parameters. +*/ +static ssize_t +nxpwifi_hscfg_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = (void *)file->private_data; +char *buf; +int ret, arg_num; +struct nxpwifi_ds_hs_cfg hscfg; +int conditions =HS_CFG_COND_DEF ; +u32 gpio =HS_CFG_GPIO_DEF , gap =HS_CFG_GAP_DEF ; + + buf =memdup_user_nul (ubuf,min (count, (size_t )(PAGE_SIZE -1 ))); +if (IS_ERR (buf)) +return PTR_ERR (buf); + + arg_num =sscanf (buf,"%d %x %x" , &conditions, &gpio, &gap); + +memset (&hscfg,0 ,sizeof (struct nxpwifi_ds_hs_cfg )); + +if (arg_num >3 ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Too many arguments\n" ); + ret = -EINVAL ; + goto done; + } + +if (arg_num >=1 && arg_num <3 ) +nxpwifi_set_hs_params (priv,HOST_ACT_GEN_GET , +NXPWIFI_SYNC_CMD , &hscfg); + +if (arg_num) { +if (conditions ==HS_CFG_CANCEL ) { +nxpwifi_cancel_hs (priv,NXPWIFI_ASYNC_CMD ); + ret = count; + goto done; + } + hscfg.conditions = conditions; + } +if (arg_num >=2 ) + hscfg.gpio = gpio; +if (arg_num ==3 ) + hscfg.gap = gap; + + hscfg.is_invoke_hostcmd = false; +nxpwifi_set_hs_params (priv,HOST_ACT_GEN_SET , +NXPWIFI_SYNC_CMD , &hscfg); + +nxpwifi_enable_hs (priv->adapter); +clear_bit (NXPWIFI_IS_HS_ENABLING , &priv->adapter->work_flags); + ret = count; +done: +kfree (buf); +return ret; +} + +/* Proc hscfg file read handler +* This function can be used to read host sleep configuration +* parameters from driver. +*/ +static ssize_t +nxpwifi_hscfg_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = (void *)file->private_data; +unsigned long addr =get_zeroed_page (GFP_KERNEL ); +char *buf = (char *)addr; +int pos, ret; +struct nxpwifi_ds_hs_cfg hscfg; + +if (!buf) +return -ENOMEM ; + +nxpwifi_set_hs_params (priv,HOST_ACT_GEN_GET , +NXPWIFI_SYNC_CMD , &hscfg); + + pos =snprintf (buf,PAGE_SIZE ,"%u 0x%x 0x%x\n" , hscfg.conditions, + hscfg.gpio, hscfg.gap); + + ret =simple_read_from_buffer (ubuf, count, ppos, buf, pos); + +free_page (addr); +return ret; +} + +static ssize_t +nxpwifi_timeshare_coex_read (struct file *file,char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = file->private_data; +char buf[3 ]; +bool timeshare_coex; +int ret; +unsigned int len; + +if (priv->adapter->fw_api_ver !=NXPWIFI_FW_V15 ) +return -EOPNOTSUPP ; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_ROBUST_COEX , +HOST_ACT_GEN_GET ,0 , ×hare_coex, true); +if (ret) +return ret; + + len =sprintf (buf,"%d\n" , timeshare_coex); +return simple_read_from_buffer (ubuf, count, ppos, buf, len); +} + +static ssize_t +nxpwifi_timeshare_coex_write (struct file *file,const char __user *ubuf, +size_t count,loff_t *ppos) +{ +bool timeshare_coex; +struct nxpwifi_private *priv = file->private_data; +int ret; + +if (priv->adapter->fw_api_ver !=NXPWIFI_FW_V15 ) +return -EOPNOTSUPP ; + + ret =kstrtobool_from_user (ubuf, count, ×hare_coex); +if (ret) +return ret; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_ROBUST_COEX , +HOST_ACT_GEN_SET ,0 , ×hare_coex, true); +if (ret) +return ret; +else +return count; +} + +static ssize_t +nxpwifi_reset_write (struct file *file, +const char __user *ubuf,size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = file->private_data; +struct nxpwifi_adapter *adapter = priv->adapter; +bool result; +int rc; + + rc =kstrtobool_from_user (ubuf, count, &result); +if (rc) +return rc; + +if (!result) +return -EINVAL ; + +if (adapter->if_ops.card_reset) { +dev_info (adapter->dev,"Resetting per request\n" ); + adapter->if_ops.card_reset (adapter); + } + +return count; +} + +static ssize_t +nxpwifi_fake_radar_detect_write (struct file *file, +const char __user *ubuf, +size_t count,loff_t *ppos) +{ +struct nxpwifi_private *priv = file->private_data; +struct nxpwifi_adapter *adapter = priv->adapter; +bool result; +int rc; + + rc =kstrtobool_from_user (ubuf, count, &result); +if (rc) +return rc; + +if (!result) +return -EINVAL ; + +if (priv->wdev.cac_started) { +nxpwifi_dbg (adapter,MSG , +"Generate fake radar detected during CAC\n" ); +if (nxpwifi_stop_radar_detection (priv, &priv->dfs_chandef)) +nxpwifi_dbg (adapter,ERROR , +"Failed to stop CAC in FW\n" ); +cancel_delayed_work_sync (&priv->dfs_cac_work); +cfg80211_cac_event (priv->netdev, &priv->dfs_chandef, +NL80211_RADAR_CAC_ABORTED ,GFP_KERNEL ); +cfg80211_radar_event (adapter->wiphy, &priv->dfs_chandef, +GFP_KERNEL ); + }else { +if (priv->bss_chandef.chan->dfs_cac_ms) { +nxpwifi_dbg (adapter,MSG , +"Generate fake radar detected\n" ); +cfg80211_radar_event (adapter->wiphy, + &priv->dfs_chandef, +GFP_KERNEL ); + } + } + +return count; +} + +#define NXPWIFI_DFS_ADD_FILE (name) debugfs_create_file(#name, 0644, \ + priv->dfs_dev_dir, priv, \ + &nxpwifi_dfs_##name##_fops) + +#define NXPWIFI_DFS_FILE_OPS (name) \ +static const struct file_operations nxpwifi_dfs_##name##_fops = { \ + .read = nxpwifi_##name##_read, \ + .write = nxpwifi_##name##_write, \ + .open = simple_open, \ +} + +#define NXPWIFI_DFS_FILE_READ_OPS (name) \ +static const struct file_operations nxpwifi_dfs_##name##_fops = { \ + .read = nxpwifi_##name##_read, \ + .open = simple_open, \ +} + +#define NXPWIFI_DFS_FILE_WRITE_OPS (name) \ +static const struct file_operations nxpwifi_dfs_##name##_fops = { \ + .write = nxpwifi_##name##_write, \ + .open = simple_open, \ +} + +NXPWIFI_DFS_FILE_READ_OPS (info); +NXPWIFI_DFS_FILE_READ_OPS (debug); +NXPWIFI_DFS_FILE_READ_OPS (getlog); +NXPWIFI_DFS_FILE_OPS (regrdwr); +NXPWIFI_DFS_FILE_OPS (rdeeprom); +NXPWIFI_DFS_FILE_OPS (memrw); +NXPWIFI_DFS_FILE_OPS (hscfg); +NXPWIFI_DFS_FILE_OPS (histogram); +NXPWIFI_DFS_FILE_OPS (debug_mask); +NXPWIFI_DFS_FILE_OPS (timeshare_coex); +NXPWIFI_DFS_FILE_WRITE_OPS (reset); +NXPWIFI_DFS_FILE_WRITE_OPS (fake_radar_detect); +NXPWIFI_DFS_FILE_OPS (verext); + +/* This function creates the debug FS directory structure and the files. +*/ +void +nxpwifi_dev_debugfs_init (struct nxpwifi_private *priv) +{ +if (!nxpwifi_dfs_dir || !priv) +return ; + + priv->dfs_dev_dir =debugfs_create_dir (priv->netdev->name, + nxpwifi_dfs_dir); + +NXPWIFI_DFS_ADD_FILE (info); +NXPWIFI_DFS_ADD_FILE (debug); +NXPWIFI_DFS_ADD_FILE (getlog); +NXPWIFI_DFS_ADD_FILE (regrdwr); +NXPWIFI_DFS_ADD_FILE (rdeeprom); + +NXPWIFI_DFS_ADD_FILE (memrw); +NXPWIFI_DFS_ADD_FILE (hscfg); +NXPWIFI_DFS_ADD_FILE (histogram); +NXPWIFI_DFS_ADD_FILE (debug_mask); +NXPWIFI_DFS_ADD_FILE (timeshare_coex); +NXPWIFI_DFS_ADD_FILE (reset); +NXPWIFI_DFS_ADD_FILE (fake_radar_detect); +NXPWIFI_DFS_ADD_FILE (verext); +} + +/* This function removes the debug FS directory structure and the files. +*/ +void +nxpwifi_dev_debugfs_remove (struct nxpwifi_private *priv) +{ +if (!priv) +return ; + +debugfs_remove_recursive (priv->dfs_dev_dir); +} + +/* This function creates the top level proc directory. +*/ +void +nxpwifi_debugfs_init (void ) +{ +if (!nxpwifi_dfs_dir) + nxpwifi_dfs_dir =debugfs_create_dir ("nxpwifi" ,NULL ); +} + +/* This function removes the top level proc directory. +*/ +void +nxpwifi_debugfs_remove (void ) +{ +debugfs_remove (nxpwifi_dfs_dir); +}
Signature · 1 line
2.34.1
PATCH v2 17/43 wifi: nxpwifi: add decl.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/decl.h | 294 ++++++++++++++++++++++++ 1 file changed, 294 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/decl.h
drivers/net/wireless/nxp/nxpwifi/decl.h new file +294 -0
@@ -0,0 +1,294 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: generic data structures and APIs +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_DECL_H_ +#define _NXPWIFI_DECL_H_ + +#undef pr_fmt +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include <linux/wait.h> +#include <linux/timer.h> +#include <linux/ieee80211.h> +#include <uapi/linux/if_arp.h> +#include <net/cfg80211.h> + +#define NXPWIFI_BSS_COEX_COUNT 2 +#define NXPWIFI_MAX_BSS_NUM (2) + +#define NXPWIFI_MAX_CSA_COUNTERS 5 + +#define NXPWIFI_DMA_ALIGN_SZ 64 +#define NXPWIFI_RX_HEADROOM 64 +#define MAX_TXPD_SZ 32 +#define INTF_HDR_ALIGN 4 +/* special FW 4 address management header */ +#define NXPWIFI_MIN_DATA_HEADER_LEN (NXPWIFI_DMA_ALIGN_SZ + INTF_HDR_ALIGN + \ + MAX_TXPD_SZ) + +#define NXPWIFI_MGMT_FRAME_HEADER_SIZE 8/* sizeof(pkt_type) +* + sizeof(tx_control) +*/ + +#define FRMCTL_LEN 2 +#define DURATION_LEN 2 +#define SEQCTL_LEN 2 +#define NXPWIFI_MGMT_HEADER_LEN (FRMCTL_LEN + FRMCTL_LEN + ETH_ALEN + \ + ETH_ALEN + ETH_ALEN + SEQCTL_LEN + ETH_ALEN) + +#define AUTH_ALG_LEN 2 +#define AUTH_TRANSACTION_LEN 2 +#define AUTH_STATUS_LEN 2 +#define NXPWIFI_AUTH_BODY_LEN (AUTH_ALG_LEN + AUTH_TRANSACTION_LEN + \ + AUTH_STATUS_LEN) + +#define HOST_MLME_AUTH_PENDING BIT(0) +#define HOST_MLME_AUTH_DONE BIT(1) + +#define HOST_MLME_MGMT_MASK (BIT(IEEE80211_STYPE_AUTH >> 4) | \ + BIT(IEEE80211_STYPE_DEAUTH >> 4) | \ + BIT(IEEE80211_STYPE_DISASSOC >> 4)) + +#define AUTH_TX_DEFAULT_WAIT_TIME 2400 + +#define WLAN_AUTH_NONE 0xFFFF + +#define NXPWIFI_MAX_TX_BASTREAM_SUPPORTED 2 +#define NXPWIFI_MAX_RX_BASTREAM_SUPPORTED 16 + +#define NXPWIFI_STA_AMPDU_DEF_TXWINSIZE 64 +#define NXPWIFI_STA_AMPDU_DEF_RXWINSIZE 64 +#define NXPWIFI_STA_COEX_AMPDU_DEF_RXWINSIZE 16 + +#define NXPWIFI_UAP_AMPDU_DEF_TXWINSIZE 32 + +#define NXPWIFI_UAP_COEX_AMPDU_DEF_RXWINSIZE 16 + +#define NXPWIFI_UAP_AMPDU_DEF_RXWINSIZE 16 +#define NXPWIFI_11AC_STA_AMPDU_DEF_TXWINSIZE 64 +#define NXPWIFI_11AC_STA_AMPDU_DEF_RXWINSIZE 64 +#define NXPWIFI_11AC_UAP_AMPDU_DEF_TXWINSIZE 64 +#define NXPWIFI_11AC_UAP_AMPDU_DEF_RXWINSIZE 64 + +#define NXPWIFI_DEFAULT_BLOCK_ACK_TIMEOUT 0xffff + +#define NXPWIFI_RATE_BITMAP_MCS0 32 + +#define NXPWIFI_RX_DATA_BUF_SIZE (4 * 1024) +#define NXPWIFI_RX_CMD_BUF_SIZE (2 * 1024) + +#define MAX_BEACON_PERIOD (4000) +#define MIN_BEACON_PERIOD (50) +#define MAX_DTIM_PERIOD (100) +#define MIN_DTIM_PERIOD (1) + +#define NXPWIFI_RTS_MIN_VALUE (0) +#define NXPWIFI_RTS_MAX_VALUE (2347) +#define NXPWIFI_FRAG_MIN_VALUE (256) +#define NXPWIFI_FRAG_MAX_VALUE (2346) +#define NXPWIFI_WMM_VERSION 0x01 +#define NXPWIFI_WMM_SUBTYPE 0x01 + +#define NXPWIFI_RETRY_LIMIT 14 +#define NXPWIFI_SDIO_BLOCK_SIZE 256 + +#define NXPWIFI_BUF_FLAG_REQUEUED_PKT BIT(0) +#define NXPWIFI_BUF_FLAG_BRIDGED_PKT BIT(1) +#define NXPWIFI_BUF_FLAG_EAPOL_TX_STATUS BIT(3) +#define NXPWIFI_BUF_FLAG_ACTION_TX_STATUS BIT(4) +#define NXPWIFI_BUF_FLAG_AGGR_PKT BIT(5) + +#define NXPWIFI_BRIDGED_PKTS_THR_HIGH 1024 +#define NXPWIFI_BRIDGED_PKTS_THR_LOW 128 + +/* 54M rates, index from 0 to 11 */ +#define NXPWIFI_RATE_INDEX_MCS0 12 +/* 12-27=MCS0-15(BW20) */ +#define NXPWIFI_BW20_MCS_NUM 15 + +/* Rate index for OFDM 0 */ +#define NXPWIFI_RATE_INDEX_OFDM0 4 + +#define NXPWIFI_MAX_STA_NUM 3 +#define NXPWIFI_MAX_UAP_NUM 3 + +#define NXPWIFI_A_BAND_START_FREQ 5000 + +/* SDIO Aggr data packet special info */ +#define SDIO_MAX_AGGR_BUF_SIZE (256 * 255) +#define BLOCK_NUMBER_OFFSET 15 +#define SDIO_HEADER_OFFSET 28 + +#define NXPWIFI_SIZE_4K 0x4000 + +enum nxpwifi_bss_type { +NXPWIFI_BSS_TYPE_STA =0 , +NXPWIFI_BSS_TYPE_UAP =1 , +NXPWIFI_BSS_TYPE_ANY =0xff , +}; + +enum nxpwifi_bss_role { +NXPWIFI_BSS_ROLE_STA =0 , +NXPWIFI_BSS_ROLE_UAP =1 , +NXPWIFI_BSS_ROLE_ANY =0xff , +}; + +#define BSS_ROLE_BIT_MASK BIT(0) + +#define GET_BSS_ROLE (priv) ((priv)->bss_role & BSS_ROLE_BIT_MASK) + +enum nxpwifi_data_frame_type { +NXPWIFI_DATA_FRAME_TYPE_ETH_II =0 , +NXPWIFI_DATA_FRAME_TYPE_802_11 , +}; + +struct nxpwifi_fw_image { +u8 *helper_buf; +u32 helper_len; +u8 *fw_buf; +u32 fw_len; +}; + +struct nxpwifi_802_11_ssid { +u32 ssid_len; +u8 ssid[IEEE80211_MAX_SSID_LEN ]; +}; + +struct nxpwifi_wait_queue { +wait_queue_head_t wait; +int status; +}; + +struct nxpwifi_rxinfo { +struct sk_buff *parent; +u8 bss_num; +u8 bss_type; +u8 use_count; +u8 buf_type; +u16 pkt_len; +}; + +struct nxpwifi_txinfo { +u8 flags; +u8 bss_num; +u8 bss_type; +u8 aggr_num; +u32 pkt_len; +u8 ack_frame_id; +u64 cookie; +}; + +enum nxpwifi_wmm_ac_e { +WMM_AC_BK , +WMM_AC_BE , +WMM_AC_VI , +WMM_AC_VO +} __packed; + +struct nxpwifi_types_wmm_info { +u8 oui[4 ]; +u8 subtype; +u8 version; +u8 qos_info; +u8 reserved; +struct ieee80211_wmm_ac_param ac[IEEE80211_NUM_ACS ]; +} __packed; + +struct nxpwifi_arp_eth_header { +struct arphdr hdr; +u8 ar_sha[ETH_ALEN ]; +u8 ar_sip[4 ]; +u8 ar_tha[ETH_ALEN ]; +u8 ar_tip[4 ]; +} __packed; + +struct nxpwifi_chan_stats { +u8 chan_num; +u8 bandcfg; +u8 flags; +s8 noise; +u16 total_bss; +u16 cca_scan_dur; +u16 cca_busy_dur; +} __packed; + +#define NXPWIFI_HIST_MAX_SAMPLES 1048576 +#define NXPWIFI_MAX_RX_RATES 44 +#define NXPWIFI_MAX_AC_RX_RATES 74 +#define NXPWIFI_MAX_SNR 256 +#define NXPWIFI_MAX_NOISE_FLR 256 +#define NXPWIFI_MAX_SIG_STRENGTH 256 + +struct nxpwifi_histogram_data { +atomic_t rx_rate[NXPWIFI_MAX_AC_RX_RATES ]; +atomic_t snr[NXPWIFI_MAX_SNR ]; +atomic_t noise_flr[NXPWIFI_MAX_NOISE_FLR ]; +atomic_t sig_str[NXPWIFI_MAX_SIG_STRENGTH ]; +atomic_t num_samples; +}; + +struct nxpwifi_iface_comb { +u8 sta_intf; +u8 uap_intf; +}; + +struct nxpwifi_radar_params { +struct cfg80211_chan_def *chandef; +u32 cac_time_ms; +} __packed; + +struct nxpwifi_11h_intf_state { +bool is_11h_enabled; +bool is_11h_active; +} __packed; + +#define NXPWIFI_FW_DUMP_IDX 0xff +#define NXPWIFI_FW_DUMP_MAX_MEMSIZE 0x160000 +#define NXPWIFI_DRV_INFO_IDX 20 +#define FW_DUMP_MAX_NAME_LEN 8 +#define FW_DUMP_HOST_READY 0xEE +#define FW_DUMP_DONE 0xFF +#define FW_DUMP_READ_DONE 0xFE + +struct memory_type_mapping { +u8 mem_name[FW_DUMP_MAX_NAME_LEN ]; +u8 *mem_ptr; +u32 mem_size; +u8 done_flag; +}; + +enum rdwr_status { +RDWR_STATUS_SUCCESS =0 , +RDWR_STATUS_FAILURE =1 , +RDWR_STATUS_DONE =2 +}; + +enum nxpwifi_chan_band { +BAND_2GHZ =0 , +BAND_5GHZ , +BAND_6GHZ , +BAND_4GHZ , +}; + +enum nxpwifi_chan_width { +CHAN_BW_20MHZ =0 , +CHAN_BW_10MHZ , +CHAN_BW_40MHZ , +CHAN_BW_80MHZ , +CHAN_BW_8080MHZ , +CHAN_BW_160MHZ , +CHAN_BW_5MHZ , +}; + +enum nxpwifi_chan_offset { +SEC_CHAN_NONE =0 , +SEC_CHAN_ABOVE =1 , +SEC_CHAN_5MHZ =2 , +SEC_CHAN_BELOW =3 +}; + +#endif /* !_NXPWIFI_DECL_H_ */
Signature · 1 line
2.34.1
PATCH v2 18/43 wifi: nxpwifi: add ethtool.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/ethtool.c | 58 ++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/ethtool.c
drivers/net/wireless/nxp/nxpwifi/ethtool.c new file +58 -0
@@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: ethtool +* +* Copyright 2011-2024 NXP +*/ + +#include "main.h" + +static void nxpwifi_ethtool_get_wol (struct net_device *dev, +struct ethtool_wolinfo *wol) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +u32 conditions =le32_to_cpu (priv->adapter->hs_cfg.conditions); + + wol->supported =WAKE_UCAST |WAKE_MCAST |WAKE_BCAST |WAKE_PHY ; + +if (conditions ==HS_CFG_COND_DEF ) +return ; + +if (conditions &HS_CFG_COND_UNICAST_DATA ) + wol->wolopts |=WAKE_UCAST ; +if (conditions &HS_CFG_COND_MULTICAST_DATA ) + wol->wolopts |=WAKE_MCAST ; +if (conditions &HS_CFG_COND_BROADCAST_DATA ) + wol->wolopts |=WAKE_BCAST ; +if (conditions &HS_CFG_COND_MAC_EVENT ) + wol->wolopts |=WAKE_PHY ; +} + +static int nxpwifi_ethtool_set_wol (struct net_device *dev, +struct ethtool_wolinfo *wol) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +u32 conditions =0 ; + +if (wol->wolopts & ~(WAKE_UCAST |WAKE_MCAST |WAKE_BCAST |WAKE_PHY )) +return -EOPNOTSUPP ; + +if (wol->wolopts &WAKE_UCAST ) + conditions |=HS_CFG_COND_UNICAST_DATA ; +if (wol->wolopts &WAKE_MCAST ) + conditions |=HS_CFG_COND_MULTICAST_DATA ; +if (wol->wolopts &WAKE_BCAST ) + conditions |=HS_CFG_COND_BROADCAST_DATA ; +if (wol->wolopts &WAKE_PHY ) + conditions |=HS_CFG_COND_MAC_EVENT ; +if (wol->wolopts ==0 ) + conditions |=HS_CFG_COND_DEF ; + priv->adapter->hs_cfg.conditions =cpu_to_le32 (conditions); + +return 0 ; +} + +const struct ethtool_ops nxpwifi_ethtool_ops = { + .get_wol = nxpwifi_ethtool_get_wol, + .set_wol = nxpwifi_ethtool_set_wol, +};
Signature · 1 line
2.34.1
PATCH v2 19/43 wifi: nxpwifi: add fw.h
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/fw.h | 2249 +++++++++++++++++++++++++ 1 file changed, 2249 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/fw.h
drivers/net/wireless/nxp/nxpwifi/fw.h new file +2249 -0
@@ -0,0 +1,2249 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* NXP Wireless LAN device driver: Firmware specific macros & structures +* +* Copyright 2011-2024 NXP +*/ + +#ifndef _NXPWIFI_FW_H_ +#define _NXPWIFI_FW_H_ + +#include <linux/if_ether.h> + +#define INTF_HEADER_LEN 4 + +struct rfc_1042_hdr { +u8 llc_dsap; +u8 llc_ssap; +u8 llc_ctrl; +u8 snap_oui[3 ]; +__be16 snap_type; +} __packed; + +struct rx_packet_hdr { +struct ethhdr eth803_hdr; +struct rfc_1042_hdr rfc1042_hdr; +} __packed; + +struct tx_packet_hdr { +struct ethhdr eth803_hdr; +struct rfc_1042_hdr rfc1042_hdr; +} __packed; + +struct nxpwifi_fw_header { +__le32 dnld_cmd; +__le32 base_addr; +__le32 data_length; +__le32 crc; +} __packed; + +struct nxpwifi_fw_data { +struct nxpwifi_fw_header header; +__le32 seq_num; +u8 data[]; +} __packed; + +struct nxpwifi_fw_dump_header { +__le16 seq_num; +__le16 reserved; +__le16 type; +__le16 len; +} __packed; + +#define FW_DUMP_INFO_ENDED 0x0002 + +#define NXPWIFI_FW_DNLD_CMD_1 0x1 +#define NXPWIFI_FW_DNLD_CMD_5 0x5 +#define NXPWIFI_FW_DNLD_CMD_6 0x6 +#define NXPWIFI_FW_DNLD_CMD_7 0x7 + +#define B_SUPPORTED_RATES 5 +#define G_SUPPORTED_RATES 9 +#define BG_SUPPORTED_RATES 13 +#define A_SUPPORTED_RATES 9 +#define HOSTCMD_SUPPORTED_RATES 14 +#define N_SUPPORTED_RATES 3 +#define ALL_802_11_BANDS (BAND_A | BAND_B | BAND_G | BAND_GN | \ + BAND_AN | BAND_AAC) + +#define FW_MULTI_BANDS_SUPPORT (BIT(8) | BIT(9) | BIT(10) | BIT(11) | \ + BIT(13)) +#define IS_SUPPORT_MULTI_BANDS (adapter) \ + ((adapter)->fw_cap_info & FW_MULTI_BANDS_SUPPORT) + +/* bit 13: 11ac BAND_AAC +* bit 12: reserved for lab testing, will be reused for BAND_AN +* bit 11: 11n BAND_GN +* bit 10: 11a BAND_A +* bit 9: 11g BAND_G +* bit 8: 11b BAND_B +* Map these bits to band capability by right shifting 8 bits. +*/ +#define GET_FW_DEFAULT_BANDS (adapter) \ + ((((adapter)->fw_cap_info & 0x2f00) >> 8) & \ + ALL_802_11_BANDS) + +#define HOST_WEP_KEY_INDEX_MASK 0x3fff + +#define KEY_INFO_ENABLED 0x01 +enum KEY_TYPE_ID { +KEY_TYPE_ID_WEP =0 , +KEY_TYPE_ID_TKIP , +KEY_TYPE_ID_AES , +KEY_TYPE_ID_WAPI , +KEY_TYPE_ID_AES_CMAC , +KEY_TYPE_ID_AES_CMAC_DEF , +}; + +#define WPA_PN_SIZE 8 +#define KEY_PARAMS_FIXED_LEN 10 +#define KEY_INDEX_MASK 0xf +#define KEY_API_VER_MAJOR_V2 2 + +#define KEY_MCAST BIT(0) +#define KEY_UNICAST BIT(1) +#define KEY_ENABLED BIT(2) +#define KEY_DEFAULT BIT(3) +#define KEY_TX_KEY BIT(4) +#define KEY_RX_KEY BIT(5) +#define KEY_IGTK BIT(10) + +#define MAX_POLL_TRIES 10000 +#define MAX_FIRMWARE_POLL_TRIES 300 + +#define FIRMWARE_READY_SDIO 0xfedc +#define FIRMWARE_READY_PCIE 0xfedcba00 + +#define NXPWIFI_COEX_MODE_TIMESHARE 0x01 +#define NXPWIFI_COEX_MODE_SPATIAL 0x82 + +enum nxpwifi_usb_ep { +NXPWIFI_USB_EP_CMD_EVENT =1 , +NXPWIFI_USB_EP_DATA =2 , +NXPWIFI_USB_EP_DATA_CH2 =3 , +}; + +enum NXPWIFI_802_11_PRIVACY_FILTER { +NXPWIFI_802_11_PRIV_FILTER_ACCEPT_ALL , +NXPWIFI_802_11_PRIV_FILTER_8021X_WEP +}; + +#define CAL_SNR (RSSI ,NF ) ((s16)((s16)(RSSI) - (s16)(NF))) +#define CAL_RSSI (SNR ,NF ) ((s16)((s16)(SNR) + (s16)(NF))) + +#define UAP_BSS_PARAMS_I 0 +#define UAP_CUSTOM_IE_I 1 +#define NXPWIFI_AUTO_IDX_MASK 0xffff +#define NXPWIFI_DELETE_MASK 0x0000 +#define MGMT_MASK_ASSOC_REQ 0x01 +#define MGMT_MASK_REASSOC_REQ 0x04 +#define MGMT_MASK_ASSOC_RESP 0x02 +#define MGMT_MASK_REASSOC_RESP 0x08 +#define MGMT_MASK_PROBE_REQ 0x10 +#define MGMT_MASK_PROBE_RESP 0x20 +#define MGMT_MASK_BEACON 0x100 + +#define TLV_TYPE_UAP_SSID 0x0000 +#define TLV_TYPE_UAP_RATES 0x0001 +#define TLV_TYPE_PWR_CONSTRAINT 0x0020 + +#define PROPRIETARY_TLV_BASE_ID 0x0100 +#define TLV_TYPE_KEY_MATERIAL (PROPRIETARY_TLV_BASE_ID + 0) +#define TLV_TYPE_CHANLIST (PROPRIETARY_TLV_BASE_ID + 1) +#define TLV_TYPE_NUMPROBES (PROPRIETARY_TLV_BASE_ID + 2) +#define TLV_TYPE_RSSI_LOW (PROPRIETARY_TLV_BASE_ID + 4) +#define TLV_TYPE_PASSTHROUGH (PROPRIETARY_TLV_BASE_ID + 10) +#define TLV_TYPE_WMMQSTATUS (PROPRIETARY_TLV_BASE_ID + 16) +#define TLV_TYPE_WILDCARDSSID (PROPRIETARY_TLV_BASE_ID + 18) +#define TLV_TYPE_TSFTIMESTAMP (PROPRIETARY_TLV_BASE_ID + 19) +#define TLV_TYPE_RSSI_HIGH (PROPRIETARY_TLV_BASE_ID + 22) +#define TLV_TYPE_BGSCAN_START_LATER (PROPRIETARY_TLV_BASE_ID + 30) +#define TLV_TYPE_AUTH_TYPE (PROPRIETARY_TLV_BASE_ID + 31) +#define TLV_TYPE_STA_MAC_ADDR (PROPRIETARY_TLV_BASE_ID + 32) +#define TLV_TYPE_BSSID (PROPRIETARY_TLV_BASE_ID + 35) +#define TLV_TYPE_CHANNELBANDLIST (PROPRIETARY_TLV_BASE_ID + 42) +#define TLV_TYPE_UAP_MAC_ADDRESS (PROPRIETARY_TLV_BASE_ID + 43) +#define TLV_TYPE_UAP_BEACON_PERIOD (PROPRIETARY_TLV_BASE_ID + 44) +#define TLV_TYPE_UAP_DTIM_PERIOD (PROPRIETARY_TLV_BASE_ID + 45) +#define TLV_TYPE_UAP_BCAST_SSID (PROPRIETARY_TLV_BASE_ID + 48) +#define TLV_TYPE_UAP_PREAMBLE_CTL (PROPRIETARY_TLV_BASE_ID + 49) +#define TLV_TYPE_UAP_RTS_THRESHOLD (PROPRIETARY_TLV_BASE_ID + 51) +#define TLV_TYPE_UAP_AO_TIMER (PROPRIETARY_TLV_BASE_ID + 57) +#define TLV_TYPE_UAP_WEP_KEY (PROPRIETARY_TLV_BASE_ID + 59) +#define TLV_TYPE_UAP_WPA_PASSPHRASE (PROPRIETARY_TLV_BASE_ID + 60) +#define TLV_TYPE_UAP_ENCRY_PROTOCOL (PROPRIETARY_TLV_BASE_ID + 64) +#define TLV_TYPE_UAP_AKMP (PROPRIETARY_TLV_BASE_ID + 65) +#define TLV_TYPE_UAP_FRAG_THRESHOLD (PROPRIETARY_TLV_BASE_ID + 70) +#define TLV_TYPE_RATE_DROP_CONTROL (PROPRIETARY_TLV_BASE_ID + 82) +#define TLV_TYPE_RATE_SCOPE (PROPRIETARY_TLV_BASE_ID + 83) +#define TLV_TYPE_POWER_GROUP (PROPRIETARY_TLV_BASE_ID + 84) +#define TLV_TYPE_BSS_SCAN_RSP (PROPRIETARY_TLV_BASE_ID + 86) +#define TLV_TYPE_BSS_SCAN_INFO (PROPRIETARY_TLV_BASE_ID + 87) +#define TLV_TYPE_CHANRPT_11H_BASIC (PROPRIETARY_TLV_BASE_ID + 91) +#define TLV_TYPE_UAP_RETRY_LIMIT (PROPRIETARY_TLV_BASE_ID + 93) +#define TLV_TYPE_ROBUST_COEX (PROPRIETARY_TLV_BASE_ID + 96) +#define TLV_TYPE_UAP_MGMT_FRAME (PROPRIETARY_TLV_BASE_ID + 104) +#define TLV_TYPE_MGMT_IE (PROPRIETARY_TLV_BASE_ID + 105) +#define TLV_TYPE_AUTO_DS_PARAM (PROPRIETARY_TLV_BASE_ID + 113) +#define TLV_TYPE_PS_PARAM (PROPRIETARY_TLV_BASE_ID + 114) +#define TLV_TYPE_UAP_PS_AO_TIMER (PROPRIETARY_TLV_BASE_ID + 123) +#define TLV_TYPE_PWK_CIPHER (PROPRIETARY_TLV_BASE_ID + 145) +#define TLV_TYPE_GWK_CIPHER (PROPRIETARY_TLV_BASE_ID + 146) +#define TLV_TYPE_TX_PAUSE (PROPRIETARY_TLV_BASE_ID + 148) +#define TLV_TYPE_RXBA_SYNC (PROPRIETARY_TLV_BASE_ID + 153) +#define TLV_TYPE_COALESCE_RULE (PROPRIETARY_TLV_BASE_ID + 154) +#define TLV_TYPE_KEY_PARAM_V2 (PROPRIETARY_TLV_BASE_ID + 156) +#define TLV_TYPE_REGION_DOMAIN_CODE (PROPRIETARY_TLV_BASE_ID + 171) +#define TLV_TYPE_REPEAT_COUNT (PROPRIETARY_TLV_BASE_ID + 176) +#define TLV_TYPE_PS_PARAMS_IN_HS (PROPRIETARY_TLV_BASE_ID + 181) +#define TLV_TYPE_MULTI_CHAN_INFO (PROPRIETARY_TLV_BASE_ID + 183) +#define TLV_TYPE_MC_GROUP_INFO (PROPRIETARY_TLV_BASE_ID + 184) +#define TLV_TYPE_SCAN_CHANNEL_GAP (PROPRIETARY_TLV_BASE_ID + 197) +#define TLV_TYPE_API_REV (PROPRIETARY_TLV_BASE_ID + 199) +#define TLV_TYPE_CHANNEL_STATS (PROPRIETARY_TLV_BASE_ID + 198) +#define TLV_BTCOEX_WL_AGGR_WINSIZE (PROPRIETARY_TLV_BASE_ID + 202) +#define TLV_BTCOEX_WL_SCANTIME (PROPRIETARY_TLV_BASE_ID + 203) +#define TLV_TYPE_BSS_MODE (PROPRIETARY_TLV_BASE_ID + 206) +#define TLV_TYPE_RANDOM_MAC (PROPRIETARY_TLV_BASE_ID + 236) +#define TLV_TYPE_CHAN_ATTR_CFG (PROPRIETARY_TLV_BASE_ID + 237) +#define TLV_TYPE_MAX_CONN (PROPRIETARY_TLV_BASE_ID + 279) +#define TLV_TYPE_HOST_MLME (PROPRIETARY_TLV_BASE_ID + 307) +#define TLV_TYPE_UAP_STA_FLAGS (PROPRIETARY_TLV_BASE_ID + 313) +#define TLV_TYPE_SAE_PWE_MODE (PROPRIETARY_TLV_BASE_ID + 339) + +#define NXPWIFI_TX_DATA_BUF_SIZE_2K 2048 + +#define SSN_MASK 0xfff0 + +#define BA_RESULT_SUCCESS 0x0 +#define BA_RESULT_TIMEOUT 0x2 + +#define IS_BASTREAM_SETUP (ptr) ((ptr)->ba_status) + +#define BA_STREAM_NOT_ALLOWED 0xff + +#define IS_11N_ENABLED (priv) ({ \ + typeof(priv) (_priv) = priv; \ + (((_priv)->adapter->config_bands & BAND_GN || \ + (_priv)->adapter->config_bands & BAND_AN) && \ + (_priv)->curr_bss_params.bss_descriptor.bcn_ht_cap && \ + !(_priv)->curr_bss_params.bss_descriptor.disable_11n); \ + }) +#define INITIATOR_BIT (del_ba_param_set) (((del_ba_param_set) &\ + BIT(DELBA_INITIATOR_POS)) >> DELBA_INITIATOR_POS) + +#define NXPWIFI_TX_DATA_BUF_SIZE_4K 4096 +#define NXPWIFI_TX_DATA_BUF_SIZE_8K 8192 +#define NXPWIFI_TX_DATA_BUF_SIZE_12K 12288 + +#define ISSUPP_11NENABLED (fw_cap_info) ((fw_cap_info) & BIT(11)) +#define ISSUPP_DRCS_ENABLED (fw_cap_info) ((fw_cap_info) & BIT(15)) +#define ISSUPP_SDIO_SPA_ENABLED (fw_cap_info) ((fw_cap_info) & BIT(16)) +#define ISSUPP_RANDOM_MAC (fw_cap_info) ((fw_cap_info) & BIT(27)) +#define ISSUPP_FIRMWARE_SUPPLICANT (fw_cap_info) ((fw_cap_info) & BIT(21)) + +#define NXPWIFI_DEF_HT_CAP (IEEE80211_HT_CAP_DSSSCCK40 | \ + (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) | \ + IEEE80211_HT_CAP_SM_PS) + +#define NXPWIFI_DEF_11N_TX_BF_CAP 0x09E1E008 + +#define NXPWIFI_DEF_AMPDU IEEE80211_HT_AMPDU_PARM_FACTOR + +/* dev_cap bitmap +* BIT +* 0-16 reserved +* 17 IEEE80211_HT_CAP_SUP_WIDTH_20_40 +* 18-22 reserved +* 23 IEEE80211_HT_CAP_SGI_20 +* 24 IEEE80211_HT_CAP_SGI_40 +* 25 IEEE80211_HT_CAP_TX_STBC +* 26 IEEE80211_HT_CAP_RX_STBC +* 27-28 reserved +* 29 IEEE80211_HT_CAP_GRN_FLD +* 30-31 reserved +*/ +#define ISSUPP_CHANWIDTH40 (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(17)) +#define ISSUPP_SHORTGI20 (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(23)) +#define ISSUPP_SHORTGI40 (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(24)) +#define ISSUPP_TXSTBC (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(25)) +#define ISSUPP_RXSTBC (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(26)) +#define ISSUPP_GREENFIELD (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(29)) +#define ISENABLED_40MHZ_INTOLERANT (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(8)) +#define ISSUPP_RXLDPC (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(22)) +#define ISSUPP_BEAMFORMING (dot_11n_dev_cap) ((dot_11n_dev_cap) & BIT(30)) +#define ISALLOWED_CHANWIDTH40 (ht_param) ((ht_param) & BIT(2)) +#define GETSUPP_TXBASTREAMS (dot_11n_dev_cap) (((dot_11n_dev_cap) >> 18) & 0xF) + +/* httxcfg bitmap +* 0 reserved +* 1 20/40 Mhz enable(1)/disable(0) +* 2-3 reserved +* 4 green field enable(1)/disable(0) +* 5 short GI in 20 Mhz enable(1)/disable(0) +* 6 short GI in 40 Mhz enable(1)/disable(0) +* 7-15 reserved +*/ +#define NXPWIFI_FW_DEF_HTTXCFG (BIT(1) | BIT(4) | BIT(5) | BIT(6)) + +/* 11AC Tx and Rx MCS map for 1x1 mode: +* IEEE80211_VHT_MCS_SUPPORT_0_9 for stream 1 +* IEEE80211_VHT_MCS_NOT_SUPPORTED for remaining 7 streams +*/ +#define NXPWIFI_11AC_MCS_MAP_1X1 0xfffefffe + +/* 11AC Tx and Rx MCS map for 2x2 mode: +* IEEE80211_VHT_MCS_SUPPORT_0_9 for stream 1 and 2 +* IEEE80211_VHT_MCS_NOT_SUPPORTED for remaining 6 streams +*/ +#define NXPWIFI_11AC_MCS_MAP_2X2 0xfffafffa + +#define GET_RXMCSSUPP (dev_mcs_supported) ((dev_mcs_supported) & 0x0f) +#define SETHT_MCS32 (x) (x[4] |= 1) +#define HT_STREAM_1X1 0x11 +#define HT_STREAM_2X2 0x22 + +#define SET_SECONDARYCHAN (radio_type, sec_chan) \ + ((radio_type) |= ((sec_chan) << 4)) + +#define LLC_SNAP_LEN 8 + +/* HW_SPEC fw_cap_info */ + +#define ISSUPP_11ACENABLED (fw_cap_info) ((fw_cap_info) & BIT(13)) + +#define GET_VHTCAP_CHWDSET (vht_cap_info) (((vht_cap_info) >> 2) & 0x3) +#define GET_VHTNSSMCS (mcs_mapset, nss) \ + (((mcs_mapset) >> (2 * ((nss) - 1))) & 0x3) +#define SET_VHTNSSMCS (mcs_mapset, nss, value) \ + ((mcs_mapset) |= ((value) & 0x3) << (2 * ((nss) - 1))) +#define GET_DEVTXMCSMAP (dev_mcs_map) ((dev_mcs_map) >> 16) +#define GET_DEVRXMCSMAP (dev_mcs_map) ((dev_mcs_map) & 0xFFFF) + +/* Clear SU Beanformer, MU beanformer, MU beanformee and +* sounding dimensions bits +*/ +#define NXPWIFI_DEF_11AC_CAP_BF_RESET_MASK \ + (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE | \ + IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE | \ + IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE | \ + IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK) + +#define MOD_CLASS_HR_DSSS 0x03 +#define MOD_CLASS_OFDM 0x07 +#define MOD_CLASS_HT 0x08 +#define HT_BW_20 0 +#define HT_BW_40 1 + +#define DFS_CHAN_MOVE_TIME 10000 + +#define HOST_CMD_GET_HW_SPEC 0x0003 +#define HOST_CMD_802_11_SCAN 0x0006 +#define HOST_CMD_802_11_GET_LOG 0x000b +#define HOST_CMD_MAC_MULTICAST_ADR 0x0010 +#define HOST_CMD_802_11_ASSOCIATE 0x0012 +#define HOST_CMD_802_11_SNMP_MIB 0x0016 +#define HOST_CMD_MAC_REG_ACCESS 0x0019 +#define HOST_CMD_BBP_REG_ACCESS 0x001a +#define HOST_CMD_RF_REG_ACCESS 0x001b +#define HOST_CMD_RF_TX_PWR 0x001e +#define HOST_CMD_RF_ANTENNA 0x0020 +#define HOST_CMD_802_11_DEAUTHENTICATE 0x0024 +#define HOST_CMD_MAC_CONTROL 0x0028 +#define HOST_CMD_802_11_MAC_ADDRESS 0x004D +#define HOST_CMD_802_11_EEPROM_ACCESS 0x0059 +#define HOST_CMD_802_11D_DOMAIN_INFO 0x005b +#define HOST_CMD_802_11_KEY_MATERIAL 0x005e +#define HOST_CMD_802_11_BG_SCAN_CONFIG 0x006b +#define HOST_CMD_802_11_BG_SCAN_QUERY 0x006c +#define HOST_CMD_WMM_GET_STATUS 0x0071 +#define HOST_CMD_802_11_SUBSCRIBE_EVENT 0x0075 +#define HOST_CMD_802_11_TX_RATE_QUERY 0x007f +#define HOST_CMD_MEM_ACCESS 0x0086 +#define HOST_CMD_CFG_DATA 0x008f +#define HOST_CMD_VERSION_EXT 0x0097 +#define HOST_CMD_MEF_CFG 0x009a +#define HOST_CMD_RSSI_INFO 0x00a4 +#define HOST_CMD_FUNC_INIT 0x00a9 +#define HOST_CMD_FUNC_SHUTDOWN 0x00aa +#define HOST_CMD_PMIC_REG_ACCESS 0x00ad +#define HOST_CMD_APCMD_SYS_RESET 0x00af +#define HOST_CMD_UAP_SYS_CONFIG 0x00b0 +#define HOST_CMD_UAP_BSS_START 0x00b1 +#define HOST_CMD_UAP_BSS_STOP 0x00b2 +#define HOST_CMD_APCMD_STA_LIST 0x00b3 +#define HOST_CMD_UAP_STA_DEAUTH 0x00b5 +#define HOST_CMD_11N_CFG 0x00cd +#define HOST_CMD_11N_ADDBA_REQ 0x00ce +#define HOST_CMD_11N_ADDBA_RSP 0x00cf +#define HOST_CMD_11N_DELBA 0x00d0 +#define HOST_CMD_TXPWR_CFG 0x00d1 +#define HOST_CMD_TX_RATE_CFG 0x00d6 +#define HOST_CMD_RECONFIGURE_TX_BUFF 0x00d9 +#define HOST_CMD_CHAN_REPORT_REQUEST 0x00dd +#define HOST_CMD_AMSDU_AGGR_CTRL 0x00df +#define HOST_CMD_ROBUST_COEX 0x00e0 +#define HOST_CMD_802_11_PS_MODE_ENH 0x00e4 +#define HOST_CMD_802_11_HS_CFG_ENH 0x00e5 +#define HOST_CMD_CAU_REG_ACCESS 0x00ed +#define HOST_CMD_SET_BSS_MODE 0x00f7 +#define HOST_CMD_PCIE_DESC_DETAILS 0x00fa +#define HOST_CMD_802_11_SCAN_EXT 0x0107 +#define HOST_CMD_COALESCE_CFG 0x010a +#define HOST_CMD_MGMT_FRAME_REG 0x010c +#define HOST_CMD_REMAIN_ON_CHAN 0x010d +#define HOST_CMD_GTK_REKEY_OFFLOAD_CFG 0x010f +#define HOST_CMD_11AC_CFG 0x0112 +#define HOST_CMD_HS_WAKEUP_REASON 0x0116 +#define HOST_CMD_MC_POLICY 0x0121 +#define HOST_CMD_FW_DUMP_EVENT 0x0125 +#define HOST_CMD_SDIO_SP_RX_AGGR_CFG 0x0223 +#define HOST_CMD_STA_CONFIGURE 0x023f +#define HOST_CMD_VDLL 0x0240 +#define HOST_CMD_CHAN_REGION_CFG 0x0242 +#define HOST_CMD_PACKET_AGGR_CTRL 0x0251 +#define HOST_CMD_ADD_NEW_STATION 0x025f + +#define PROTOCOL_NO_SECURITY 0x01 +#define PROTOCOL_STATIC_WEP 0x02 +#define PROTOCOL_WPA 0x08 +#define PROTOCOL_WPA2 0x20 +#define PROTOCOL_WPA2_MIXED 0x28 +#define PROTOCOL_EAP 0x40 +#define KEY_MGMT_EAP 0x01 +#define KEY_MGMT_PSK 0x02 +#define KEY_MGMT_NONE 0x04 +#define KEY_MGMT_PSK_SHA256 0x100 +#define KEY_MGMT_OWE 0x200 +#define KEY_MGMT_SAE 0x400 +#define CIPHER_TKIP 0x04 +#define CIPHER_AES_CCMP 0x08 +#define VALID_CIPHER_BITMAP 0x0c + +enum ENH_PS_MODES { +EN_PS =1 , +DIS_PS =2 , +EN_AUTO_DS =3 , +DIS_AUTO_DS =4 , +SLEEP_CONFIRM =5 , +GET_PS =0 , +EN_AUTO_PS =0xff , +DIS_AUTO_PS =0xfe , +}; + +enum nxpwifi_channel_flags { +NXPWIFI_CHANNEL_PASSIVE =BIT (0 ), +NXPWIFI_CHANNEL_DFS =BIT (1 ), +NXPWIFI_CHANNEL_NOHT40 =BIT (2 ), +NXPWIFI_CHANNEL_NOHT80 =BIT (3 ), +NXPWIFI_CHANNEL_DISABLED =BIT (7 ), +}; + +#define HOST_RET_BIT 0x8000 +#define HOST_ACT_GEN_GET 0x0000 +#define HOST_ACT_GEN_SET 0x0001 +#define HOST_ACT_GEN_REMOVE 0x0004 +#define HOST_ACT_BITWISE_SET 0x0002 +#define HOST_ACT_BITWISE_CLR 0x0003 +#define HOST_RESULT_OK 0x0000 +#define HOST_ACT_MAC_RX_ON BIT(0) +#define HOST_ACT_MAC_TX_ON BIT(1) +#define HOST_ACT_MAC_WEP_ENABLE BIT(3) +#define HOST_ACT_MAC_ETHERNETII_ENABLE BIT(4) +#define HOST_ACT_MAC_PROMISCUOUS_ENABLE BIT(7) +#define HOST_ACT_MAC_ALL_MULTICAST_ENABLE BIT(8) +#define HOST_ACT_MAC_DYNAMIC_BW_ENABLE BIT(16) + +#define HOST_BSS_MODE_IBSS 0x0002 +#define HOST_BSS_MODE_ANY 0x0003 + +#define HOST_SCAN_RADIO_TYPE_BG 0 +#define HOST_SCAN_RADIO_TYPE_A 1 + +#define HS_CFG_CANCEL 0xffffffff +#define HS_CFG_COND_DEF 0x00000000 +#define HS_CFG_GPIO_DEF 0xff +#define HS_CFG_GAP_DEF 0xff +#define HS_CFG_COND_BROADCAST_DATA 0x00000001 +#define HS_CFG_COND_UNICAST_DATA 0x00000002 +#define HS_CFG_COND_MAC_EVENT 0x00000004 +#define HS_CFG_COND_MULTICAST_DATA 0x00000008 + +#define CONNECT_ERR_AUTH_ERR_STA_FAILURE 0xFFFB +#define CONNECT_ERR_ASSOC_ERR_TIMEOUT 0xFFFC +#define CONNECT_ERR_ASSOC_ERR_AUTH_REFUSED 0xFFFD +#define CONNECT_ERR_AUTH_MSG_UNHANDLED 0xFFFE +#define CONNECT_ERR_STA_FAILURE 0xFFFF + +#define CMD_F_HOSTCMD BIT(0) + +#define HOST_CMD_ID_MASK 0x0fff + +#define HOST_SEQ_NUM_MASK 0x00ff + +#define HOST_BSS_NUM_MASK 0x0f00 + +#define HOST_BSS_TYPE_MASK 0xf000 + +#define HOST_ACT_SET_RX 0x0001 +#define HOST_ACT_SET_TX 0x0002 +#define HOST_ACT_SET_BOTH 0x0003 +#define HOST_ACT_GET_RX 0x0004 +#define HOST_ACT_GET_TX 0x0008 +#define HOST_ACT_GET_BOTH 0x000c + +#define HOST_ACT_REMOVE_STA 0x0 +#define HOST_ACT_ADD_STA 0x1 + +#define RF_ANTENNA_AUTO 0xFFFF + +#define HOST_SET_SEQ_NO_BSS_INFO (seq, num, type) \ + ((((seq) & 0x00ff) | \ + (((num) & 0x000f) << 8)) | \ + (((type) & 0x000f) << 12)) + +#define HOST_GET_SEQ_NO (seq) \ + ((seq) & HOST_SEQ_NUM_MASK) + +#define HOST_GET_BSS_NO (seq) \ + (((seq) & HOST_BSS_NUM_MASK) >> 8) + +#define HOST_GET_BSS_TYPE (seq) \ + (((seq) & HOST_BSS_TYPE_MASK) >> 12) + +#define EVENT_DUMMY_HOST_WAKEUP_SIGNAL 0x00000001 +#define EVENT_LINK_LOST 0x00000003 +#define EVENT_LINK_SENSED 0x00000004 +#define EVENT_MIB_CHANGED 0x00000006 +#define EVENT_INIT_DONE 0x00000007 +#define EVENT_DEAUTHENTICATED 0x00000008 +#define EVENT_DISASSOCIATED 0x00000009 +#define EVENT_PS_AWAKE 0x0000000a +#define EVENT_PS_SLEEP 0x0000000b +#define EVENT_MIC_ERR_MULTICAST 0x0000000d +#define EVENT_MIC_ERR_UNICAST 0x0000000e +#define EVENT_DEEP_SLEEP_AWAKE 0x00000010 +#define EVENT_WMM_STATUS_CHANGE 0x00000017 +#define EVENT_BG_SCAN_REPORT 0x00000018 +#define EVENT_RSSI_LOW 0x00000019 +#define EVENT_SNR_LOW 0x0000001a +#define EVENT_MAX_FAIL 0x0000001b +#define EVENT_RSSI_HIGH 0x0000001c +#define EVENT_SNR_HIGH 0x0000001d +#define EVENT_DATA_RSSI_LOW 0x00000024 +#define EVENT_DATA_SNR_LOW 0x00000025 +#define EVENT_DATA_RSSI_HIGH 0x00000026 +#define EVENT_DATA_SNR_HIGH 0x00000027 +#define EVENT_LINK_QUALITY 0x00000028 +#define EVENT_PORT_RELEASE 0x0000002b +#define EVENT_UAP_STA_DEAUTH 0x0000002c +#define EVENT_UAP_STA_ASSOC 0x0000002d +#define EVENT_UAP_BSS_START 0x0000002e +#define EVENT_PRE_BEACON_LOST 0x00000031 +#define EVENT_ADDBA 0x00000033 +#define EVENT_DELBA 0x00000034 +#define EVENT_BA_STREAM_TIEMOUT 0x00000037 +#define EVENT_AMSDU_AGGR_CTRL 0x00000042 +#define EVENT_UAP_BSS_IDLE 0x00000043 +#define EVENT_UAP_BSS_ACTIVE 0x00000044 +#define EVENT_WEP_ICV_ERR 0x00000046 +#define EVENT_HS_ACT_REQ 0x00000047 +#define EVENT_BW_CHANGE 0x00000048 +#define EVENT_UAP_MIC_COUNTERMEASURES 0x0000004c +#define EVENT_HOSTWAKE_STAIE 0x0000004d +#define EVENT_CHANNEL_SWITCH_ANN 0x00000050 +#define EVENT_RADAR_DETECTED 0x00000053 +#define EVENT_CHANNEL_REPORT_RDY 0x00000054 +#define EVENT_TX_DATA_PAUSE 0x00000055 +#define EVENT_EXT_SCAN_REPORT 0x00000058 +#define EVENT_RXBA_SYNC 0x00000059 +#define EVENT_REMAIN_ON_CHAN_EXPIRED 0x0000005f +#define EVENT_UNKNOWN_DEBUG 0x00000063 +#define EVENT_BG_SCAN_STOPPED 0x00000065 +#define EVENT_MULTI_CHAN_INFO 0x0000006a +#define EVENT_FW_DUMP_INFO 0x00000073 +#define EVENT_TX_STATUS_REPORT 0x00000074 +#define EVENT_BT_COEX_WLAN_PARA_CHANGE 0X00000076 +#define EVENT_VDLL_IND 0x00000081 + + +#define EVENT_ID_MASK 0xffff +#define BSS_NUM_MASK 0xf + +#define EVENT_GET_BSS_NUM (event_cause) \ + (((event_cause) >> 16) & BSS_NUM_MASK) + +#define EVENT_GET_BSS_TYPE (event_cause) \ + (((event_cause) >> 24) & 0x00ff) + +#define NXPWIFI_MAX_PATTERN_LEN 40 +#define NXPWIFI_MAX_OFFSET_LEN 100 +#define NXPWIFI_MAX_ND_MATCH_SETS 10 + +#define STACK_NBYTES 100 +#define TYPE_DNUM 1 +#define TYPE_BYTESEQ 2 +#define MAX_OPERAND 0x40 +#define TYPE_EQ (MAX_OPERAND + 1) +#define TYPE_EQ_DNUM (MAX_OPERAND + 2) +#define TYPE_EQ_BIT (MAX_OPERAND + 3) +#define TYPE_AND (MAX_OPERAND + 4) +#define TYPE_OR (MAX_OPERAND + 5) +#define MEF_MODE_HOST_SLEEP 1 +#define MEF_ACTION_ALLOW_AND_WAKEUP_HOST 3 +#define MEF_ACTION_AUTO_ARP 0x10 +#define NXPWIFI_CRITERIA_BROADCAST BIT(0) +#define NXPWIFI_CRITERIA_UNICAST BIT(1) +#define NXPWIFI_CRITERIA_MULTICAST BIT(3) +#define NXPWIFI_MAX_SUPPORTED_IPADDR 4 + +#define NXPWIFI_DEF_CS_UNIT_TIME 2 +#define NXPWIFI_DEF_CS_THR_OTHERLINK 10 +#define NXPWIFI_DEF_THR_DIRECTLINK 0 +#define NXPWIFI_DEF_CS_TIME 10 +#define NXPWIFI_DEF_CS_TIMEOUT 16 +#define NXPWIFI_DEF_CS_REG_CLASS 12 +#define NXPWIFI_DEF_CS_PERIODICITY 1 + +#define NXPWIFI_FW_V15 15 + +#define NXPWIFI_MASTER_RADAR_DET_MASK BIT(1) + +struct nxpwifi_ie_types_header { +__le16 type; +__le16 len; +} __packed; + +struct nxpwifi_ie_types_data { +struct nxpwifi_ie_types_header header; +u8 data[]; +} __packed; + +#define NXPWIFI_TxPD_POWER_MGMT_NULL_PACKET 0x01 +#define NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET 0x08 +#define NXPWIFI_TXPD_FLAGS_REQ_TX_STATUS 0x20 + +enum HS_WAKEUP_REASON { +NO_HSWAKEUP_REASON =0 , +BCAST_DATA_MATCHED , +MCAST_DATA_MATCHED , +UCAST_DATA_MATCHED , +MASKTABLE_EVENT_MATCHED , +NON_MASKABLE_EVENT_MATCHED , +NON_MASKABLE_CONDITION_MATCHED , +MAGIC_PATTERN_MATCHED , +CONTROL_FRAME_MATCHED , +MANAGEMENT_FRAME_MATCHED , +GTK_REKEY_FAILURE , +RESERVED +}; + +struct txpd { +u8 bss_type; +u8 bss_num; +__le16 tx_pkt_length; +__le16 tx_pkt_offset; +__le16 tx_pkt_type; +__le32 tx_control; +u8 priority; +u8 flags; +u8 pkt_delay_2ms; +u8 reserved1[2 ]; +u8 tx_token_id; +u8 reserved[2 ]; +} __packed; + +struct rxpd { +u8 bss_type; +u8 bss_num; +__le16 rx_pkt_length; +__le16 rx_pkt_offset; +__le16 rx_pkt_type; +__le16 seq_num; +u8 priority; +u8 rx_rate; +s8 snr; +s8 nf; + +/* For: Non-802.11 AC cards +* +* Ht Info [Bit 0] RxRate format: LG=0, HT=1 +* [Bit 1] HT Bandwidth: BW20 = 0, BW40 = 1 +* [Bit 2] HT Guard Interval: LGI = 0, SGI = 1 +* +* For: 802.11 AC cards +* [Bit 1] [Bit 0] RxRate format: legacy rate = 00 HT = 01 VHT = 10 +* [Bit 3] [Bit 2] HT/VHT Bandwidth BW20 = 00 BW40 = 01 +* BW80 = 10 BW160 = 11 +* [Bit 4] HT/VHT Guard interval LGI = 0 SGI = 1 +* [Bit 5] STBC support Enabled = 1 +* [Bit 6] LDPC support Enabled = 1 +* [Bit 7] Reserved +*/ +u8 ht_info; +u8 reserved[3 ]; +u8 flags; +} __packed; + +struct uap_txpd { +u8 bss_type; +u8 bss_num; +__le16 tx_pkt_length; +__le16 tx_pkt_offset; +__le16 tx_pkt_type; +__le32 tx_control; +u8 priority; +u8 flags; +u8 pkt_delay_2ms; +u8 reserved1[2 ]; +u8 tx_token_id; +u8 reserved[2 ]; +} __packed; + +struct uap_rxpd { +u8 bss_type; +u8 bss_num; +__le16 rx_pkt_length; +__le16 rx_pkt_offset; +__le16 rx_pkt_type; +__le16 seq_num; +u8 priority; +u8 rx_rate; +s8 snr; +s8 nf; +u8 ht_info; +u8 reserved[3 ]; +u8 flags; +} __packed; + +struct nxpwifi_auth { +__le16 auth_alg; +__le16 auth_transaction; +__le16 status_code; +/* possibly followed by Challenge text */ +u8 variable[]; +} __packed; + +struct nxpwifi_ieee80211_mgmt { +__le16 frame_control; +__le16 duration; +u8 da[ETH_ALEN ]; +u8 sa[ETH_ALEN ]; +u8 bssid[ETH_ALEN ]; +__le16 seq_ctrl; +u8 addr4[ETH_ALEN ]; +struct nxpwifi_auth auth; +} __packed; + +struct nxpwifi_fw_chan_stats { +u8 chan_num; +u8 bandcfg; +u8 flags; +s8 noise; +__le16 total_bss; +__le16 cca_scan_dur; +__le16 cca_busy_dur; +} __packed; + +enum nxpwifi_chan_scan_mode_bitmasks { +NXPWIFI_PASSIVE_SCAN =BIT (0 ), +NXPWIFI_DISABLE_CHAN_FILT =BIT (1 ), +NXPWIFI_HIDDEN_SSID_REPORT =BIT (4 ), +}; + +struct nxpwifi_chan_scan_param_set { +u8 radio_type; +u8 chan_number; +u8 chan_scan_mode_bmap; +__le16 min_scan_time; +__le16 max_scan_time; +} __packed; + +struct nxpwifi_ie_types_chan_list_param_set { +struct nxpwifi_ie_types_header header; +struct nxpwifi_chan_scan_param_set chan_scan_param[]; +} __packed; + +struct nxpwifi_ie_types_rxba_sync { +struct nxpwifi_ie_types_header header; +u8 mac[ETH_ALEN ]; +u8 tid; +u8 reserved; +__le16 seq_num; +__le16 bitmap_len; +u8 bitmap[]; +} __packed; + +struct chan_band_param_set { +u8 radio_type; +u8 chan_number; +}; + +struct nxpwifi_ie_types_chan_band_list_param_set { +struct nxpwifi_ie_types_header header; +struct chan_band_param_set chan_band_param[]; +} __packed; + +struct nxpwifi_ie_types_rates_param_set { +struct nxpwifi_ie_types_header header; +u8 rates[]; +} __packed; + +struct nxpwifi_ie_types_ssid_param_set { +struct nxpwifi_ie_types_header header; +u8 ssid[]; +} __packed; + +struct nxpwifi_ie_types_host_mlme { +struct nxpwifi_ie_types_header header; +u8 host_mlme; +} __packed; + +struct nxpwifi_ie_types_num_probes { +struct nxpwifi_ie_types_header header; +__le16 num_probes; +} __packed; + +struct nxpwifi_ie_types_repeat_count { +struct nxpwifi_ie_types_header header; +__le16 repeat_count; +} __packed; + +struct nxpwifi_ie_types_min_rssi_threshold { +struct nxpwifi_ie_types_header header; +__le16 rssi_threshold; +} __packed; + +struct nxpwifi_ie_types_bgscan_start_later { +struct nxpwifi_ie_types_header header; +__le16 start_later; +} __packed; + +struct nxpwifi_ie_types_scan_chan_gap { +struct nxpwifi_ie_types_header header; +/* time gap in TUs to be used between two consecutive channels scan */ +__le16 chan_gap; +} __packed; + +struct nxpwifi_ie_types_random_mac { +struct nxpwifi_ie_types_header header; +u8 mac[ETH_ALEN ]; +} __packed; + +struct nxpwifi_ietypes_chanstats { +struct nxpwifi_ie_types_header header; +struct nxpwifi_fw_chan_stats chanstats[]; +} __packed; + +struct nxpwifi_ie_types_wildcard_ssid_params { +struct nxpwifi_ie_types_header header; +u8 max_ssid_length; +u8 ssid[]; +} __packed; + +#define TSF_DATA_SIZE 8 +struct nxpwifi_ie_types_tsf_timestamp { +struct nxpwifi_ie_types_header header; +u8 tsf_data[]; +} __packed; + +struct nxpwifi_cf_param_set { +u8 cfp_cnt; +u8 cfp_period; +__le16 cfp_max_duration; +__le16 cfp_duration_remaining; +} __packed; + +struct nxpwifi_ibss_param_set { +__le16 atim_window; +} __packed; + +struct nxpwifi_ie_types_ss_param_set { +struct nxpwifi_ie_types_header header; +union { +struct nxpwifi_cf_param_set cf_param_set[1 ]; +struct nxpwifi_ibss_param_set ibss_param_set[1 ]; + } cf_ibss; +} __packed; + +struct nxpwifi_fh_param_set { +__le16 dwell_time; +u8 hop_set; +u8 hop_pattern; +u8 hop_index; +} __packed; + +struct nxpwifi_ds_param_set { +u8 current_chan; +} __packed; + +struct nxpwifi_ie_types_phy_param_set { +struct nxpwifi_ie_types_header header; +union { +struct nxpwifi_fh_param_set fh_param_set[1 ]; +struct nxpwifi_ds_param_set ds_param_set[1 ]; + } fh_ds; +} __packed; + +struct nxpwifi_ie_types_auth_type { +struct nxpwifi_ie_types_header header; +__le16 auth_type; +} __packed; + +struct nxpwifi_ie_types_vendor_param_set { +struct nxpwifi_ie_types_header header; +u8 ie[NXPWIFI_MAX_VSIE_LEN ]; +}; + +#define NXPWIFI_AUTHTYPE_SAE 6 + +struct nxpwifi_ie_types_sae_pwe_mode { +struct nxpwifi_ie_types_header header; +u8 pwe[]; +} __packed; + +struct nxpwifi_ie_types_rsn_param_set { +struct nxpwifi_ie_types_header header; +u8 rsn_ie[]; +} __packed; + +#define KEYPARAMSET_FIXED_LEN 6 + +#define IGTK_PN_LEN 8 + +struct nxpwifi_cmac_param { +u8 ipn[IGTK_PN_LEN ]; +u8 key[WLAN_KEY_LEN_AES_CMAC ]; +} __packed; + +struct nxpwifi_wep_param { +__le16 key_len; +u8 key[WLAN_KEY_LEN_WEP104 ]; +} __packed; + +struct nxpwifi_tkip_param { +u8 pn[WPA_PN_SIZE ]; +__le16 key_len; +u8 key[WLAN_KEY_LEN_TKIP ]; +} __packed; + +struct nxpwifi_aes_param { +u8 pn[WPA_PN_SIZE ]; +__le16 key_len; +u8 key[WLAN_KEY_LEN_CCMP_256 ]; +} __packed; + +struct nxpwifi_cmac_aes_param { +u8 ipn[IGTK_PN_LEN ]; +__le16 key_len; +u8 key[WLAN_KEY_LEN_AES_CMAC ]; +} __packed; + +struct nxpwifi_ie_type_key_param_set { +__le16 type; +__le16 len; +u8 mac_addr[ETH_ALEN ]; +u8 key_idx; +u8 key_type; +__le16 key_info; +union { +struct nxpwifi_wep_param wep; +struct nxpwifi_tkip_param tkip; +struct nxpwifi_aes_param aes; +struct nxpwifi_cmac_aes_param cmac_aes; + } key_params; +} __packed; + +struct host_cmd_ds_802_11_key_material { +__le16 action; +struct nxpwifi_ie_type_key_param_set key_param_set; +} __packed; + +struct host_cmd_ds_gen { +__le16 command; +__le16 size; +__le16 seq_num; +__le16 result; +}; + +#define S_DS_GEN sizeof(struct host_cmd_ds_gen) + +enum sleep_resp_ctrl { +RESP_NOT_NEEDED =0 , +RESP_NEEDED , +}; + +struct nxpwifi_ps_param { +__le16 null_pkt_interval; +__le16 multiple_dtims; +__le16 bcn_miss_timeout; +__le16 local_listen_interval; +__le16 reserved; +__le16 mode; +__le16 delay_to_ps; +} __packed; + +#define HS_DEF_WAKE_INTERVAL 100 +#define HS_DEF_INACTIVITY_TIMEOUT 50 + +struct nxpwifi_ps_param_in_hs { +struct nxpwifi_ie_types_header header; +__le32 hs_wake_int; +__le32 hs_inact_timeout; +} __packed; + +#define BITMAP_AUTO_DS 0x01 +#define BITMAP_STA_PS 0x10 + +struct nxpwifi_ie_types_auto_ds_param { +struct nxpwifi_ie_types_header header; +__le16 deep_sleep_timeout; +} __packed; + +struct nxpwifi_ie_types_ps_param { +struct nxpwifi_ie_types_header header; +struct nxpwifi_ps_param param; +} __packed; + +struct host_cmd_ds_802_11_ps_mode_enh { +__le16 action; + +union { +struct nxpwifi_ps_param opt_ps; +__le16 ps_bitmap; + } params; +} __packed; + +enum API_VER_ID { +KEY_API_VER_ID =1 , +FW_API_VER_ID =2 , +UAP_FW_API_VER_ID =3 , +CHANRPT_API_VER_ID =4 , +FW_HOTFIX_VER_ID =5 , +}; + +struct hw_spec_api_rev { +struct nxpwifi_ie_types_header header; +__le16 api_id; +u8 major_ver; +u8 minor_ver; +} __packed; + +struct host_cmd_ds_get_hw_spec { +__le16 hw_if_version; +__le16 version; +__le16 reserved; +__le16 num_of_mcast_adr; +u8 permanent_addr[ETH_ALEN ]; +__le16 region_code; +__le16 number_of_antenna; +__le32 fw_release_number; +__le32 reserved_1; +__le32 reserved_2; +__le32 reserved_3; +__le32 fw_cap_info; +__le32 dot_11n_dev_cap; +u8 dev_mcs_support; +__le16 mp_end_port;/* SDIO only, reserved for other interfacces */ +__le16 mgmt_buf_count;/* mgmt IE buffer count */ +__le32 reserved_4; +__le32 reserved_5; +__le32 dot_11ac_dev_cap; +__le32 dot_11ac_mcs_support; +u8 tlvs[]; +} __packed; + +struct host_cmd_ds_802_11_rssi_info { +__le16 action; +__le16 ndata; +__le16 nbcn; +__le16 reserved[9 ]; +long long reserved_1; +} __packed; + +struct host_cmd_ds_802_11_rssi_info_rsp { +__le16 action; +__le16 ndata; +__le16 nbcn; +__le16 data_rssi_last; +__le16 data_nf_last; +__le16 data_rssi_avg; +__le16 data_nf_avg; +__le16 bcn_rssi_last; +__le16 bcn_nf_last; +__le16 bcn_rssi_avg; +__le16 bcn_nf_avg; +long long tsf_bcn; +} __packed; + +struct host_cmd_ds_802_11_mac_address { +__le16 action; +u8 mac_addr[ETH_ALEN ]; +} __packed; + +struct host_cmd_ds_mac_control { +__le32 action; +}; + +struct host_cmd_ds_mac_multicast_adr { +__le16 action; +__le16 num_of_adrs; +u8 mac_list[NXPWIFI_MAX_MULTICAST_LIST_SIZE ][ETH_ALEN ]; +} __packed; + +struct host_cmd_ds_802_11_deauthenticate { +u8 mac_addr[ETH_ALEN ]; +__le16 reason_code; +} __packed; + +struct host_cmd_ds_802_11_associate { +u8 peer_sta_addr[ETH_ALEN ]; +__le16 cap_info_bitmap; +__le16 listen_interval; +__le16 beacon_period; +u8 dtim_period; +} __packed; + +struct ieee_types_assoc_rsp { +__le16 cap_info_bitmap; +__le16 status_code; +__le16 a_id; +u8 ie_buffer[]; +} __packed; + +struct host_cmd_ds_802_11_associate_rsp { +struct ieee_types_assoc_rsp assoc_rsp; +} __packed; + +struct ieee_types_cf_param_set { +u8 element_id; +u8 len; +u8 cfp_cnt; +u8 cfp_period; +__le16 cfp_max_duration; +__le16 cfp_duration_remaining; +} __packed; + +struct ieee_types_fh_param_set { +u8 element_id; +u8 len; +__le16 dwell_time; +u8 hop_set; +u8 hop_pattern; +u8 hop_index; +} __packed; + +struct ieee_types_ds_param_set { +u8 element_id; +u8 len; +u8 current_chan; +} __packed; + +union ieee_types_phy_param_set { +struct ieee_types_fh_param_set fh_param_set; +struct ieee_types_ds_param_set ds_param_set; +} __packed; + +struct ieee_types_oper_mode_ntf { +u8 element_id; +u8 len; +u8 oper_mode; +} __packed; + +struct host_cmd_ds_802_11_get_log { +__le32 mcast_tx_frame; +__le32 failed; +__le32 retry; +__le32 multi_retry; +__le32 frame_dup; +__le32 rts_success; +__le32 rts_failure; +__le32 ack_failure; +__le32 rx_frag; +__le32 mcast_rx_frame; +__le32 fcs_error; +__le32 tx_frame; +__le32 reserved; +__le32 wep_icv_err_cnt[4 ]; +__le32 bcn_rcv_cnt; +__le32 bcn_miss_cnt; +} __packed; + +/* Enumeration for rate format */ +enum nxpwifi_rate_format { +NXPWIFI_RATE_FORMAT_LG =0 , +NXPWIFI_RATE_FORMAT_HT , +NXPWIFI_RATE_FORMAT_VHT , +NXPWIFI_RATE_FORMAT_AUTO =0xFF , +}; + +struct host_cmd_ds_tx_rate_query { +u8 tx_rate; +/* Tx Rate Info: For 802.11 AC cards +* +* [Bit 0-1] tx rate formate: LG = 0, HT = 1, VHT = 2 +* [Bit 2-3] HT/VHT Bandwidth: BW20 = 0, BW40 = 1, BW80 = 2, BW160 = 3 +* [Bit 4] HT/VHT Guard Interval: LGI = 0, SGI = 1 +* +* For non-802.11 AC cards +* Ht Info [Bit 0] RxRate format: LG=0, HT=1 +* [Bit 1] HT Bandwidth: BW20 = 0, BW40 = 1 +* [Bit 2] HT Guard Interval: LGI = 0, SGI = 1 +*/ +u8 ht_info; +} __packed; + +struct nxpwifi_tx_pause_tlv { +struct nxpwifi_ie_types_header header; +u8 peermac[ETH_ALEN ]; +u8 tx_pause; +u8 pkt_cnt; +} __packed; + +enum host_sleep_action { +HS_CONFIGURE =0x0001 , +HS_ACTIVATE =0x0002 , +}; + +struct nxpwifi_hs_config_param { +__le32 conditions; +u8 gpio; +u8 gap; +} __packed; + +struct hs_activate_param { +__le16 resp_ctrl; +} __packed; + +struct host_cmd_ds_802_11_hs_cfg_enh { +__le16 action; + +union { +struct nxpwifi_hs_config_param hs_config; +struct hs_activate_param hs_activate; + } params; +} __packed; + +enum SNMP_MIB_INDEX { +OP_RATE_SET_I =1 , +DTIM_PERIOD_I =3 , +RTS_THRESH_I =5 , +SHORT_RETRY_LIM_I =6 , +LONG_RETRY_LIM_I =7 , +FRAG_THRESH_I =8 , +DOT11D_I =9 , +DOT11H_I =10 , +}; + +enum nxpwifi_assocmd_failurepoint { +NXPWIFI_ASSOC_CMD_SUCCESS =0 , +NXPWIFI_ASSOC_CMD_FAILURE_ASSOC , +NXPWIFI_ASSOC_CMD_FAILURE_AUTH , +NXPWIFI_ASSOC_CMD_FAILURE_JOIN +}; + +#define MAX_SNMP_BUF_SIZE 128 + +struct host_cmd_ds_802_11_snmp_mib { +__le16 query_type; +__le16 oid; +__le16 buf_size; +u8 value[]; +} __packed; + +struct nxpwifi_rate_scope { +__le16 type; +__le16 length; +__le16 hr_dsss_rate_bitmap; +__le16 ofdm_rate_bitmap; +__le16 ht_mcs_rate_bitmap[8 ]; +__le16 vht_mcs_rate_bitmap[8 ]; +} __packed; + +struct nxpwifi_rate_drop_pattern { +__le16 type; +__le16 length; +__le32 rate_drop_mode; +} __packed; + +struct host_cmd_ds_tx_rate_cfg { +__le16 action; +__le16 cfg_index; +} __packed; + +struct nxpwifi_power_group { +u8 modulation_class; +u8 first_rate_code; +u8 last_rate_code; +s8 power_step; +s8 power_min; +s8 power_max; +u8 ht_bandwidth; +u8 reserved; +} __packed; + +struct nxpwifi_types_power_group { +__le16 type; +__le16 length; +} __packed; + +struct host_cmd_ds_txpwr_cfg { +__le16 action; +__le16 cfg_index; +__le32 mode; +} __packed; + +struct host_cmd_ds_rf_tx_pwr { +__le16 action; +__le16 cur_level; +u8 max_power; +u8 min_power; +} __packed; + +struct host_cmd_ds_rf_ant_mimo { +__le16 action_tx; +__le16 tx_ant_mode; +__le16 action_rx; +__le16 rx_ant_mode; +} __packed; + +struct host_cmd_ds_rf_ant_siso { +__le16 action; +__le16 ant_mode; +} __packed; + +#define BAND_CFG_CHAN_BAND_MASK 0x03 +#define BAND_CFG_CHAN_BAND_SHIFT_BIT 0 +#define BAND_CFG_CHAN_WIDTH_MASK 0x0C +#define BAND_CFG_CHAN_WIDTH_SHIFT_BIT 2 +#define BAND_CFG_CHAN2_OFFSET_MASK 0x30 +#define BAND_CFG_CHAN2_SHIFT_BIT 4 + +struct nxpwifi_chan_desc { +__le16 start_freq; +u8 band_cfg; +u8 chan_num; +} __packed; + +struct host_cmd_ds_chan_rpt_req { +struct nxpwifi_chan_desc chan_desc; +__le32 msec_dwell_time; +} __packed; + +struct host_cmd_ds_chan_rpt_event { +__le32 result; +__le64 start_tsf; +__le32 duration; +u8 tlvbuf[]; +} __packed; + +struct host_cmd_sdio_sp_rx_aggr_cfg { +u8 action; +u8 enable; +__le16 block_size; +} __packed; + +struct nxpwifi_fixed_bcn_param { +__le64 timestamp; +__le16 beacon_period; +__le16 cap_info_bitmap; +} __packed; + +struct nxpwifi_event_scan_result { +__le16 event_id; +u8 bss_index; +u8 bss_type; +u8 more_event; +u8 reserved[3 ]; +__le16 buf_size; +u8 num_of_set; +} __packed; + +struct tx_status_event { +u8 packet_type; +u8 tx_token_id; +u8 status; +} __packed; + +#define NXPWIFI_USER_SCAN_CHAN_MAX 50 + +#define NXPWIFI_MAX_SSID_LIST_LENGTH 10 + +struct nxpwifi_scan_cmd_config { +/* BSS mode to be sent in the firmware command +*/ +u8 bss_mode; + +/* Specific BSSID used to filter scan results in the firmware */ +u8 specific_bssid[ETH_ALEN ]; + +/* Length of TLVs sent in command starting at tlvBuffer */ +u32 tlv_buf_len; + +/* SSID TLV(s) and ChanList TLVs to be sent in the firmware command +* +* TLV_TYPE_CHANLIST, nxpwifi_ie_types_chan_list_param_set +* WLAN_EID_SSID, nxpwifi_ie_types_ssid_param_set +*/ +u8 tlv_buf[1 ];/* SSID TLV(s) and ChanList TLVs are stored here */ +} __packed; + +struct nxpwifi_user_scan_chan { +u8 chan_number; +u8 radio_type; +u8 scan_type; +u8 reserved; +u32 scan_time; +} __packed; + +struct nxpwifi_user_scan_cfg { +/* BSS mode to be sent in the firmware command +*/ +u8 bss_mode; +/* Configure the number of probe requests for active chan scans */ +u8 num_probes; +u8 reserved; +/* BSSID filter sent in the firmware command to limit the results */ +u8 specific_bssid[ETH_ALEN ]; +/* SSID filter list used in the firmware to limit the scan results */ +struct cfg80211_ssid *ssid_list; +u8 num_ssids; +/* Variable number (fixed maximum) of channels to scan up */ +struct nxpwifi_user_scan_chan chan_list[NXPWIFI_USER_SCAN_CHAN_MAX ]; +u16 scan_chan_gap; +u8 random_mac[ETH_ALEN ]; +} __packed; + +#define NXPWIFI_BG_SCAN_CHAN_MAX 38 +#define NXPWIFI_BSS_MODE_INFRA 1 +#define NXPWIFI_BGSCAN_ACT_GET 0x0000 +#define NXPWIFI_BGSCAN_ACT_SET 0x0001 +#define NXPWIFI_BGSCAN_ACT_SET_ALL 0xff01 +/** ssid match */ +#define NXPWIFI_BGSCAN_SSID_MATCH 0x0001 +/** ssid match and RSSI exceeded */ +#define NXPWIFI_BGSCAN_SSID_RSSI_MATCH 0x0004 +/**wait for all channel scan to complete to report scan result*/ +#define NXPWIFI_BGSCAN_WAIT_ALL_CHAN_DONE 0x80000000 + +struct nxpwifi_bg_scan_cfg { +u16 action; +u8 enable; +u8 bss_type; +u8 chan_per_scan; +u32 scan_interval; +u32 report_condition; +u8 num_probes; +u8 rssi_threshold; +u8 snr_threshold; +u16 repeat_count; +u16 start_later; +struct cfg80211_match_set *ssid_list; +u8 num_ssids; +struct nxpwifi_user_scan_chan chan_list[NXPWIFI_BG_SCAN_CHAN_MAX ]; +u16 scan_chan_gap; +} __packed; + +struct ie_body { +u8 grp_key_oui[4 ]; +u8 ptk_cnt[2 ]; +u8 ptk_body[4 ]; +} __packed; + +struct host_cmd_ds_802_11_scan { +u8 bss_mode; +u8 bssid[ETH_ALEN ]; +u8 tlv_buffer[]; +} __packed; + +struct host_cmd_ds_802_11_scan_rsp { +__le16 bss_descript_size; +u8 number_of_sets; +u8 bss_desc_and_tlv_buffer[]; +} __packed; + +struct host_cmd_ds_802_11_scan_ext { +u32 reserved; +u8 tlv_buffer[]; +} __packed; + +struct nxpwifi_ie_types_bss_mode { +struct nxpwifi_ie_types_header header; +u8 bss_mode; +} __packed; + +struct nxpwifi_ie_types_bss_scan_rsp { +struct nxpwifi_ie_types_header header; +u8 bssid[ETH_ALEN ]; +u8 frame_body[]; +} __packed; + +struct nxpwifi_ie_types_bss_scan_info { +struct nxpwifi_ie_types_header header; +__le16 rssi; +__le16 anpi; +u8 cca_busy_fraction; +u8 radio_type; +u8 channel; +u8 reserved; +__le64 tsf; +} __packed; + +struct host_cmd_ds_802_11_bg_scan_config { +__le16 action; +u8 enable; +u8 bss_type; +u8 chan_per_scan; +u8 reserved; +__le16 reserved1; +__le32 scan_interval; +__le32 reserved2; +__le32 report_condition; +__le16 reserved3; +u8 tlv[]; +} __packed; + +struct host_cmd_ds_802_11_bg_scan_query { +u8 flush; +} __packed; + +struct host_cmd_ds_802_11_bg_scan_query_rsp { +__le32 report_condition; +struct host_cmd_ds_802_11_scan_rsp scan_resp; +} __packed; + +struct nxpwifi_ietypes_domain_code { +struct nxpwifi_ie_types_header header; +u8 domain_code; +u8 reserved; +} __packed; + +struct nxpwifi_ietypes_domain_param_set { +struct nxpwifi_ie_types_header header; +u8 country_code[IEEE80211_COUNTRY_STRING_LEN ]; +struct ieee80211_country_ie_triplet triplet[]; +} __packed; + +struct host_cmd_ds_802_11d_domain_info { +__le16 action; +struct nxpwifi_ietypes_domain_param_set domain; +} __packed; + +struct host_cmd_ds_802_11d_domain_info_rsp { +__le16 action; +struct nxpwifi_ietypes_domain_param_set domain; +} __packed; + +struct host_cmd_ds_11n_addba_req { +u8 add_req_result; +u8 peer_mac_addr[ETH_ALEN ]; +u8 dialog_token; +__le16 block_ack_param_set; +__le16 block_ack_tmo; +__le16 ssn; +} __packed; + +struct host_cmd_ds_11n_addba_rsp { +u8 add_rsp_result; +u8 peer_mac_addr[ETH_ALEN ]; +u8 dialog_token; +__le16 status_code; +__le16 block_ack_param_set; +__le16 block_ack_tmo; +__le16 ssn; +} __packed; + +struct host_cmd_ds_11n_delba { +u8 del_result; +u8 peer_mac_addr[ETH_ALEN ]; +__le16 del_ba_param_set; +__le16 reason_code; +u8 reserved; +} __packed; + +struct host_cmd_ds_11n_batimeout { +u8 tid; +u8 peer_mac_addr[ETH_ALEN ]; +u8 origninator; +} __packed; + +struct host_cmd_ds_11n_cfg { +__le16 action; +__le16 ht_tx_cap; +__le16 ht_tx_info; +__le16 misc_config;/* Needed for 802.11AC cards only */ +} __packed; + +struct host_cmd_ds_txbuf_cfg { +__le16 action; +__le16 buff_size; +__le16 mp_end_port;/* SDIO only, reserved for other interfacces */ +__le16 reserved3; +} __packed; + +struct host_cmd_ds_amsdu_aggr_ctrl { +__le16 action; +__le16 enable; +__le16 curr_buf_size; +} __packed; + +struct host_cmd_ds_sta_deauth { +u8 mac[ETH_ALEN ]; +__le16 reason; +} __packed; + +struct nxpwifi_ie_types_sta_info { +struct nxpwifi_ie_types_header header; +u8 mac[ETH_ALEN ]; +u8 power_mfg_status; +s8 rssi; +}; + +struct host_cmd_ds_sta_list { +__le16 sta_count; +u8 tlv[]; +} __packed; + +struct nxpwifi_ie_types_pwr_capability { +struct nxpwifi_ie_types_header header; +s8 min_pwr; +s8 max_pwr; +}; + +struct nxpwifi_ie_types_local_pwr_constraint { +struct nxpwifi_ie_types_header header; +u8 chan; +u8 constraint; +}; + +struct nxpwifi_ie_types_wmm_param_set { +struct nxpwifi_ie_types_header header; +u8 wmm_ie[]; +} __packed; + +struct nxpwifi_ie_types_mgmt_frame { +struct nxpwifi_ie_types_header header; +__le16 frame_control; +u8 frame_contents[]; +}; + +struct nxpwifi_ie_types_wmm_queue_status { +struct nxpwifi_ie_types_header header; +u8 queue_index; +u8 disabled; +__le16 medium_time; +u8 flow_required; +u8 flow_created; +u32 reserved; +}; + +struct ieee_types_wmm_info { +/* WMM Info IE - Vendor Specific Header: +* element_id [221/0xdd] +* Len [7] +* Oui [00:50:f2] +* OuiType [2] +* OuiSubType [0] +* Version [1] +*/ +struct ieee80211_vendor_ie vend_hdr; +u8 oui_subtype; +u8 version; + +u8 qos_info_bitmap; +} __packed; + +struct host_cmd_ds_wmm_get_status { +u8 queue_status_tlv[sizeof (struct nxpwifi_ie_types_wmm_queue_status ) * +IEEE80211_NUM_ACS ]; +u8 wmm_param_tlv[sizeof (struct ieee80211_wmm_param_ie ) +2 ]; +} __packed; + +struct nxpwifi_wmm_ac_status { +u8 disabled; +u8 flow_required; +u8 flow_created; +}; + +struct nxpwifi_ie_types_htcap { +struct nxpwifi_ie_types_header header; +struct ieee80211_ht_cap ht_cap; +} __packed; + +struct nxpwifi_ie_types_vhtcap { +struct nxpwifi_ie_types_header header; +struct ieee80211_vht_cap vht_cap; +} __packed; + +struct nxpwifi_ie_types_aid { +struct nxpwifi_ie_types_header header; +__le16 aid; +} __packed; + +struct nxpwifi_ie_types_oper_mode_ntf { +struct nxpwifi_ie_types_header header; +u8 oper_mode; +} __packed; + +/* VHT Operations IE */ +struct nxpwifi_ie_types_vht_oper { +struct nxpwifi_ie_types_header header; +u8 chan_width; +u8 chan_center_freq_1; +u8 chan_center_freq_2; +/* Basic MCS set map, each 2 bits stands for a NSS */ +__le16 basic_mcs_map; +} __packed; + +struct nxpwifi_ie_types_wmmcap { +struct nxpwifi_ie_types_header header; +struct nxpwifi_types_wmm_info wmm_info; +} __packed; + +struct nxpwifi_ie_types_htinfo { +struct nxpwifi_ie_types_header header; +struct ieee80211_ht_operation ht_oper; +} __packed; + +struct nxpwifi_ie_types_2040bssco { +struct nxpwifi_ie_types_header header; +u8 bss_co_2040; +} __packed; + +struct nxpwifi_ie_types_extcap { +struct nxpwifi_ie_types_header header; +u8 ext_capab[]; +} __packed; + +struct host_cmd_ds_mem_access { +__le16 action; +__le16 reserved; +__le32 addr; +__le32 value; +} __packed; + +struct nxpwifi_ie_types_qos_info { +struct nxpwifi_ie_types_header header; +u8 qos_info; +} __packed; + +struct host_cmd_ds_mac_reg_access { +__le16 action; +__le16 offset; +__le32 value; +} __packed; + +struct host_cmd_ds_bbp_reg_access { +__le16 action; +__le16 offset; +u8 value; +u8 reserved[3 ]; +} __packed; + +struct host_cmd_ds_rf_reg_access { +__le16 action; +__le16 offset; +u8 value; +u8 reserved[3 ]; +} __packed; + +struct host_cmd_ds_pmic_reg_access { +__le16 action; +__le16 offset; +u8 value; +u8 reserved[3 ]; +} __packed; + +struct host_cmd_ds_802_11_eeprom_access { +__le16 action; + +__le16 offset; +__le16 byte_count; +u8 value; +} __packed; + +struct nxpwifi_assoc_event { +u8 sta_addr[ETH_ALEN ]; +__le16 type; +__le16 len; +__le16 frame_control; +__le16 cap_info; +__le16 listen_interval; +u8 data[]; +} __packed; + +struct host_cmd_ds_sys_config { +__le16 action; +u8 tlv[]; +}; + +struct host_cmd_11ac_vht_cfg { +__le16 action; +u8 band_config; +u8 misc_config; +__le32 cap_info; +__le32 mcs_tx_set; +__le32 mcs_rx_set; +} __packed; + +struct host_cmd_tlv_akmp { +struct nxpwifi_ie_types_header header; +__le16 key_mgmt; +__le16 key_mgmt_operation; +} __packed; + +struct host_cmd_tlv_pwk_cipher { +struct nxpwifi_ie_types_header header; +__le16 proto; +u8 cipher; +u8 reserved; +} __packed; + +struct host_cmd_tlv_gwk_cipher { +struct nxpwifi_ie_types_header header; +u8 cipher; +u8 reserved; +} __packed; + +struct host_cmd_tlv_passphrase { +struct nxpwifi_ie_types_header header; +u8 passphrase[]; +} __packed; + +struct host_cmd_tlv_wep_key { +struct nxpwifi_ie_types_header header; +u8 key_index; +u8 is_default; +u8 key[]; +}; + +struct host_cmd_tlv_auth_type { +struct nxpwifi_ie_types_header header; +u8 auth_type; +u8 pwe_derivation; +u8 transition_disable; +} __packed; + +struct host_cmd_tlv_encrypt_protocol { +struct nxpwifi_ie_types_header header; +__le16 proto; +} __packed; + +struct host_cmd_tlv_ssid { +struct nxpwifi_ie_types_header header; +u8 ssid[]; +} __packed; + +struct host_cmd_tlv_rates { +struct nxpwifi_ie_types_header header; +u8 rates[]; +} __packed; + +struct nxpwifi_ie_types_bssid_list { +struct nxpwifi_ie_types_header header; +u8 bssid[ETH_ALEN ]; +} __packed; + +struct host_cmd_tlv_bcast_ssid { +struct nxpwifi_ie_types_header header; +u8 bcast_ctl; +} __packed; + +struct host_cmd_tlv_beacon_period { +struct nxpwifi_ie_types_header header; +__le16 period; +} __packed; + +struct host_cmd_tlv_dtim_period { +struct nxpwifi_ie_types_header header; +u8 period; +} __packed; + +struct host_cmd_tlv_frag_threshold { +struct nxpwifi_ie_types_header header; +__le16 frag_thr; +} __packed; + +struct host_cmd_tlv_rts_threshold { +struct nxpwifi_ie_types_header header; +__le16 rts_thr; +} __packed; + +struct host_cmd_tlv_retry_limit { +struct nxpwifi_ie_types_header header; +u8 limit; +} __packed; + +struct host_cmd_tlv_mac_addr { +struct nxpwifi_ie_types_header header; +u8 mac_addr[ETH_ALEN ]; +} __packed; + +struct host_cmd_tlv_channel_band { +struct nxpwifi_ie_types_header header; +u8 band_config; +u8 channel; +} __packed; + +struct host_cmd_tlv_ageout_timer { +struct nxpwifi_ie_types_header header; +__le32 sta_ao_timer; +} __packed; + +struct host_cmd_tlv_power_constraint { +struct nxpwifi_ie_types_header header; +u8 constraint; +} __packed; + +struct nxpwifi_ie_types_btcoex_scan_time { +struct nxpwifi_ie_types_header header; +u8 coex_scan; +u8 reserved; +__le16 min_scan_time; +__le16 max_scan_time; +} __packed; + +struct nxpwifi_ie_types_btcoex_aggr_win_size { +struct nxpwifi_ie_types_header header; +u8 coex_win_size; +u8 tx_win_size; +u8 rx_win_size; +u8 reserved; +} __packed; + +struct nxpwifi_ie_types_robust_coex { +struct nxpwifi_ie_types_header header; +__le32 mode; +} __packed; + +#define NXPWIFI_VERSION_STR_LENGTH 128 + +struct host_cmd_ds_version_ext { +u8 version_str_sel; +char version_str[NXPWIFI_VERSION_STR_LENGTH ]; +} __packed; + +struct host_cmd_ds_mgmt_frame_reg { +__le16 action; +__le32 mask; +} __packed; + +struct host_cmd_ds_remain_on_chan { +__le16 action; +u8 status; +u8 reserved; +u8 band_cfg; +u8 channel; +__le32 duration; +} __packed; + +struct host_cmd_ds_802_11_ibss_status { +__le16 action; +__le16 enable; +u8 bssid[ETH_ALEN ]; +__le16 beacon_interval; +__le16 atim_window; +__le16 use_g_rate_protect; +} __packed; + +struct nxpwifi_fw_mef_entry { +u8 mode; +u8 action; +__le16 exprsize; +u8 expr[]; +} __packed; + +struct host_cmd_ds_mef_cfg { +__le32 criteria; +__le16 num_entries; +u8 mef_entry_data[]; +} __packed; + +#define CONNECTION_TYPE_INFRA 0 +#define CONNECTION_TYPE_AP 2 + +struct host_cmd_ds_set_bss_mode { +u8 con_type; +} __packed; + +struct host_cmd_ds_pcie_details { +/* TX buffer descriptor ring address */ +__le32 txbd_addr_lo; +__le32 txbd_addr_hi; +/* TX buffer descriptor ring count */ +__le32 txbd_count; + +/* RX buffer descriptor ring address */ +__le32 rxbd_addr_lo; +__le32 rxbd_addr_hi; +/* RX buffer descriptor ring count */ +__le32 rxbd_count; + +/* Event buffer descriptor ring address */ +__le32 evtbd_addr_lo; +__le32 evtbd_addr_hi; +/* Event buffer descriptor ring count */ +__le32 evtbd_count; + +/* Sleep cookie buffer physical address */ +__le32 sleep_cookie_addr_lo; +__le32 sleep_cookie_addr_hi; +} __packed; + +struct nxpwifi_ie_types_rssi_threshold { +struct nxpwifi_ie_types_header header; +u8 abs_value; +u8 evt_freq; +} __packed; + +#define NXPWIFI_DFS_REC_HDR_LEN 8 +#define NXPWIFI_DFS_REC_HDR_NUM 10 +#define NXPWIFI_BIN_COUNTER_LEN 7 + +struct nxpwifi_radar_det_event { +__le32 detect_count; +u8 reg_domain;/*1=fcc, 2=etsi, 3=mic*/ +u8 det_type;/*0=none, 1=pw(chirp), 2=pri(radar)*/ +__le16 pw_chirp_type; +u8 pw_chirp_idx; +u8 pw_value; +u8 pri_radar_type; +u8 pri_bincnt; +u8 bin_counter[NXPWIFI_BIN_COUNTER_LEN ]; +u8 num_dfs_records; +u8 dfs_record_hdr[NXPWIFI_DFS_REC_HDR_NUM ][NXPWIFI_DFS_REC_HDR_LEN ]; +__le32 passed; +} __packed; + +struct nxpwifi_ie_types_multi_chan_info { +struct nxpwifi_ie_types_header header; +__le16 status; +u8 tlv_buffer[]; +} __packed; + +struct nxpwifi_ie_types_mc_group_info { +struct nxpwifi_ie_types_header header; +u8 chan_group_id; +u8 chan_buf_weight; +u8 band_config; +u8 chan_num; +__le32 chan_time; +__le32 reserved; +union { +u8 sdio_func_num; +u8 usb_ep_num; + } hid_num; +u8 intf_num; +u8 bss_type_numlist[]; +} __packed; + +#define MEAS_RPT_MAP_RADAR_MASK 0x08 +#define MEAS_RPT_MAP_RADAR_SHIFT_BIT 3 + +struct nxpwifi_ie_types_chan_rpt_data { +struct nxpwifi_ie_types_header header; +u8 meas_rpt_map; +} __packed; + +struct host_cmd_ds_802_11_subsc_evt { +__le16 action; +__le16 events; +} __packed; + +struct chan_switch_result { +u8 cur_chan; +u8 status; +u8 reason; +} __packed; + +struct nxpwifi_ie { +__le16 ie_index; +__le16 mgmt_subtype_mask; +__le16 ie_length; +u8 ie_buffer[IEEE_MAX_IE_SIZE ]; +} __packed; + +#define MAX_MGMT_IE_INDEX 16 +struct nxpwifi_ie_list { +__le16 type; +__le16 len; +struct nxpwifi_ie ie_list[MAX_MGMT_IE_INDEX ]; +} __packed; + +struct coalesce_filt_field_param { +u8 operation; +u8 operand_len; +__le16 offset; +u8 operand_byte_stream[4 ]; +}; + +struct coalesce_receive_filt_rule { +struct nxpwifi_ie_types_header header; +u8 num_of_fields; +u8 pkt_type; +__le16 max_coalescing_delay; +struct coalesce_filt_field_param params[]; +} __packed; + +struct host_cmd_ds_coalesce_cfg { +__le16 action; +__le16 num_of_rules; +u8 rule_data[]; +} __packed; + +struct host_cmd_ds_multi_chan_policy { +__le16 action; +__le16 policy; +} __packed; + +struct host_cmd_ds_robust_coex { +__le16 action; +__le16 reserved; +} __packed; + +struct host_cmd_ds_wakeup_reason { +__le16 wakeup_reason; +} __packed; + +struct host_cmd_ds_gtk_rekey_params { +__le16 action; +u8 kck[NL80211_KCK_LEN ]; +u8 kek[NL80211_KEK_LEN ]; +__le32 replay_ctr_low; +__le32 replay_ctr_high; +} __packed; + +struct host_cmd_ds_chan_region_cfg { +__le16 action; +} __packed; + +struct host_cmd_ds_pkt_aggr_ctrl { +__le16 action; +__le16 enable; +__le16 tx_aggr_max_size; +__le16 tx_aggr_max_num; +__le16 tx_aggr_align; +} __packed; + +struct host_cmd_ds_sta_configure { +__le16 action; +u8 tlv_buffer[]; +} __packed; + +struct nxpwifi_ie_types_sta_flag { +struct nxpwifi_ie_types_header header; +__le32 sta_flags; +} __packed; + +struct host_cmd_ds_add_station { +__le16 action; +__le16 aid; +u8 peer_mac[ETH_ALEN ]; +__le32 listen_interval; +__le16 cap_info; +u8 tlv[]; +} __packed; + +struct host_cmd_ds_command { +__le16 command; +__le16 size; +__le16 seq_num; +__le16 result; +union { +struct host_cmd_ds_get_hw_spec hw_spec; +struct host_cmd_ds_mac_control mac_ctrl; +struct host_cmd_ds_802_11_mac_address mac_addr; +struct host_cmd_ds_mac_multicast_adr mc_addr; +struct host_cmd_ds_802_11_get_log get_log; +struct host_cmd_ds_802_11_rssi_info rssi_info; +struct host_cmd_ds_802_11_rssi_info_rsp rssi_info_rsp; +struct host_cmd_ds_802_11_snmp_mib smib; +struct host_cmd_ds_tx_rate_query tx_rate; +struct host_cmd_ds_tx_rate_cfg tx_rate_cfg; +struct host_cmd_ds_txpwr_cfg txp_cfg; +struct host_cmd_ds_rf_tx_pwr txp; +struct host_cmd_ds_rf_ant_mimo ant_mimo; +struct host_cmd_ds_rf_ant_siso ant_siso; +struct host_cmd_ds_802_11_ps_mode_enh psmode_enh; +struct host_cmd_ds_802_11_hs_cfg_enh opt_hs_cfg; +struct host_cmd_ds_802_11_scan scan; +struct host_cmd_ds_802_11_scan_ext ext_scan; +struct host_cmd_ds_802_11_scan_rsp scan_resp; +struct host_cmd_ds_802_11_bg_scan_config bg_scan_config; +struct host_cmd_ds_802_11_bg_scan_query bg_scan_query; +struct host_cmd_ds_802_11_bg_scan_query_rsp bg_scan_query_resp; +struct host_cmd_ds_802_11_associate associate; +struct host_cmd_ds_802_11_associate_rsp associate_rsp; +struct host_cmd_ds_802_11_deauthenticate deauth; +struct host_cmd_ds_802_11d_domain_info domain_info; +struct host_cmd_ds_802_11d_domain_info_rsp domain_info_resp; +struct host_cmd_ds_11n_addba_req add_ba_req; +struct host_cmd_ds_11n_addba_rsp add_ba_rsp; +struct host_cmd_ds_11n_delba del_ba; +struct host_cmd_ds_txbuf_cfg tx_buf; +struct host_cmd_ds_amsdu_aggr_ctrl amsdu_aggr_ctrl; +struct host_cmd_ds_11n_cfg htcfg; +struct host_cmd_ds_wmm_get_status get_wmm_status; +struct host_cmd_ds_802_11_key_material key_material; +struct host_cmd_ds_version_ext verext; +struct host_cmd_ds_mgmt_frame_reg reg_mask; +struct host_cmd_ds_remain_on_chan roc_cfg; +struct host_cmd_ds_802_11_ibss_status ibss_coalescing; +struct host_cmd_ds_mef_cfg mef_cfg; +struct host_cmd_ds_mem_access mem; +struct host_cmd_ds_mac_reg_access mac_reg; +struct host_cmd_ds_bbp_reg_access bbp_reg; +struct host_cmd_ds_rf_reg_access rf_reg; +struct host_cmd_ds_pmic_reg_access pmic_reg; +struct host_cmd_ds_set_bss_mode bss_mode; +struct host_cmd_ds_pcie_details pcie_host_spec; +struct host_cmd_ds_802_11_eeprom_access eeprom; +struct host_cmd_ds_802_11_subsc_evt subsc_evt; +struct host_cmd_ds_sys_config uap_sys_config; +struct host_cmd_ds_sta_deauth sta_deauth; +struct host_cmd_ds_sta_list sta_list; +struct host_cmd_11ac_vht_cfg vht_cfg; +struct host_cmd_ds_coalesce_cfg coalesce_cfg; +struct host_cmd_ds_chan_rpt_req chan_rpt_req; +struct host_cmd_sdio_sp_rx_aggr_cfg sdio_rx_aggr_cfg; +struct host_cmd_ds_multi_chan_policy mc_policy; +struct host_cmd_ds_robust_coex coex; +struct host_cmd_ds_wakeup_reason hs_wakeup_reason; +struct host_cmd_ds_gtk_rekey_params rekey; +struct host_cmd_ds_chan_region_cfg reg_cfg; +struct host_cmd_ds_pkt_aggr_ctrl pkt_aggr_ctrl; +struct host_cmd_ds_sta_configure sta_cfg; +struct host_cmd_ds_add_station sta_info; + } params; +} __packed; + +struct nxpwifi_opt_sleep_confirm { +__le16 command; +__le16 size; +__le16 seq_num; +__le16 result; +__le16 action; +__le16 resp_ctrl; +} __packed; + +struct hw_spec_max_conn { +struct nxpwifi_ie_types_header header; +u8 reserved; +u8 max_sta_conn; +} __packed; + +#define VDLL_IND_TYPE_REQ 0 +#define VDLL_IND_TYPE_OFFSET 1 +#define VDLL_IND_TYPE_ERR_SIG 2 +#define VDLL_IND_TYPE_ERR_ID 3 +#define VDLL_IND_TYPE_SEC_ERR_ID 4 +#define VDLL_IND_TYPE_INTF_RESET 5 + +struct vdll_ind_event { +__le16 type; +__le16 vdll_id; +__le32 offset; +__le16 block_len; +} __packed; + +#endif /* !_NXPWIFI_FW_H_ */
Signature · 1 line
2.34.1
PATCH v2 20/43 wifi: nxpwifi: add ie.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/ie.c | 501 ++++++++++++++++++++++++++ 1 file changed, 501 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/ie.c
drivers/net/wireless/nxp/nxpwifi/ie.c new file +501 -0
@@ -0,0 +1,501 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: management IE handling- setting and +* deleting IE. +* +* Copyright 2011-2024 NXP +*/ + +#include "main.h" +#include "cmdevt.h" + +/* This function checks if current IE index is used by any on other interface. +* Return: true: yes, current IE index is used by someone else. +* false: no, current IE index is NOT used by other interface. +*/ +static bool +nxpwifi_ie_index_used_by_other_intf (struct nxpwifi_private *priv,u16 idx) +{ +int i; +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_ie *ie; + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i] != priv) { + ie = &adapter->priv[i]->mgmt_ie[idx]; +if (ie->mgmt_subtype_mask && ie->ie_length) +return true; + } + } + +return false; +} + +/* Get unused IE index. This index will be used for setting new IE */ +static int +nxpwifi_ie_get_autoidx (struct nxpwifi_private *priv,u16 subtype_mask, +struct nxpwifi_ie *ie,u16 *index) +{ +u16 mask, len, i; + +for (i =0 ; i < priv->adapter->max_mgmt_ie_index; i++) { + mask =le16_to_cpu (priv->mgmt_ie[i].mgmt_subtype_mask); + len =le16_to_cpu (ie->ie_length); + +if (mask ==NXPWIFI_AUTO_IDX_MASK ) +continue ; + +if (mask == subtype_mask) { +if (len >IEEE_MAX_IE_SIZE ) +continue ; + + *index = i; +return 0 ; + } + +if (!priv->mgmt_ie[i].ie_length) { +if (nxpwifi_ie_index_used_by_other_intf (priv, i)) +continue ; + + *index = i; +return 0 ; + } + } + +return -ENOENT ; +} + +/* This function prepares IE data buffer for command to be sent to FW */ +static int +nxpwifi_update_autoindex_ies (struct nxpwifi_private *priv, +struct nxpwifi_ie_list *ie_list) +{ +u16 travel_len, index, mask; +s16 input_len, tlv_len; +struct nxpwifi_ie *ie; +u8 *tmp; + + input_len =le16_to_cpu (ie_list->len); + travel_len =sizeof (struct nxpwifi_ie_types_header ); + + ie_list->len =0 ; + +while (input_len >=sizeof (struct nxpwifi_ie_types_header )) { + ie = (struct nxpwifi_ie *)(((u8 *)ie_list) + travel_len); + tlv_len =le16_to_cpu (ie->ie_length); + travel_len += tlv_len +NXPWIFI_IE_HDR_SIZE ; + +if (input_len < tlv_len +NXPWIFI_IE_HDR_SIZE ) +return -EINVAL ; + index =le16_to_cpu (ie->ie_index); + mask =le16_to_cpu (ie->mgmt_subtype_mask); + +if (index ==NXPWIFI_AUTO_IDX_MASK ) { +/* automatic addition */ +if (nxpwifi_ie_get_autoidx (priv, mask, ie, &index)) +return -ENOENT ; +if (index ==NXPWIFI_AUTO_IDX_MASK ) +return -EINVAL ; + + tmp = (u8 *)&priv->mgmt_ie[index].ie_buffer; +memcpy (tmp, &ie->ie_buffer,le16_to_cpu (ie->ie_length)); + priv->mgmt_ie[index].ie_length = ie->ie_length; + priv->mgmt_ie[index].ie_index =cpu_to_le16 (index); + priv->mgmt_ie[index].mgmt_subtype_mask = +cpu_to_le16 (mask); + + ie->ie_index =cpu_to_le16 (index); + }else { +if (mask !=NXPWIFI_DELETE_MASK ) +return -EINVAL ; +/* Check if this index is being used on any +* other interface. +*/ +if (nxpwifi_ie_index_used_by_other_intf (priv, index)) +return -EPERM ; + + ie->ie_length =0 ; +memcpy (&priv->mgmt_ie[index], ie, +sizeof (struct nxpwifi_ie )); + } + +le16_unaligned_add_cpu + (&ie_list->len, +le16_to_cpu (priv->mgmt_ie[index].ie_length) + +NXPWIFI_IE_HDR_SIZE ); + input_len -= tlv_len +NXPWIFI_IE_HDR_SIZE ; + } + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) +return nxpwifi_send_cmd (priv,HOST_CMD_UAP_SYS_CONFIG , +HOST_ACT_GEN_SET , +UAP_CUSTOM_IE_I , ie_list, true); + +return 0 ; +} + +/* Copy individual custom IEs for beacon, probe response and assoc response +* and prepare single structure for IE setting. +* This function also updates allocated IE indices from driver. +*/ +static int +nxpwifi_update_uap_custom_ie (struct nxpwifi_private *priv, +struct nxpwifi_ie *beacon_ie,u16 *beacon_idx, +struct nxpwifi_ie *pr_ie,u16 *probe_idx, +struct nxpwifi_ie *ar_ie,u16 *assoc_idx) +{ +struct nxpwifi_ie_list *ap_custom_ie; +u8 *pos; +u16 len; +int ret; + + ap_custom_ie =kzalloc (sizeof (*ap_custom_ie),GFP_KERNEL ); +if (!ap_custom_ie) +return -ENOMEM ; + + ap_custom_ie->type =cpu_to_le16 (TLV_TYPE_MGMT_IE ); + pos = (u8 *)ap_custom_ie->ie_list; + +if (beacon_ie) { + len =sizeof (struct nxpwifi_ie ) -IEEE_MAX_IE_SIZE + +le16_to_cpu (beacon_ie->ie_length); +memcpy (pos, beacon_ie, len); + pos += len; +le16_unaligned_add_cpu (&ap_custom_ie->len, len); + } +if (pr_ie) { + len =sizeof (struct nxpwifi_ie ) -IEEE_MAX_IE_SIZE + +le16_to_cpu (pr_ie->ie_length); +memcpy (pos, pr_ie, len); + pos += len; +le16_unaligned_add_cpu (&ap_custom_ie->len, len); + } +if (ar_ie) { + len =sizeof (struct nxpwifi_ie ) -IEEE_MAX_IE_SIZE + +le16_to_cpu (ar_ie->ie_length); +memcpy (pos, ar_ie, len); + pos += len; +le16_unaligned_add_cpu (&ap_custom_ie->len, len); + } + + ret =nxpwifi_update_autoindex_ies (priv, ap_custom_ie); + + pos = (u8 *)(&ap_custom_ie->ie_list[0 ].ie_index); +if (beacon_ie && *beacon_idx ==NXPWIFI_AUTO_IDX_MASK ) { +/* save beacon ie index after auto-indexing */ + *beacon_idx =le16_to_cpu (ap_custom_ie->ie_list[0 ].ie_index); + len =sizeof (*beacon_ie) -IEEE_MAX_IE_SIZE + +le16_to_cpu (beacon_ie->ie_length); + pos += len; + } +if (pr_ie &&le16_to_cpu (pr_ie->ie_index) ==NXPWIFI_AUTO_IDX_MASK ) { +/* save probe resp ie index after auto-indexing */ + *probe_idx = *((u16 *)pos); + len =sizeof (*pr_ie) -IEEE_MAX_IE_SIZE + +le16_to_cpu (pr_ie->ie_length); + pos += len; + } +if (ar_ie &&le16_to_cpu (ar_ie->ie_index) ==NXPWIFI_AUTO_IDX_MASK ) +/* save assoc resp ie index after auto-indexing */ + *assoc_idx = *((u16 *)pos); + +kfree (ap_custom_ie); +return ret; +} + +/* This function checks if the vendor specified IE is present in passed buffer +* and copies it to nxpwifi_ie structure. +* Function takes pointer to struct nxpwifi_ie pointer as argument. +* If the vendor specified IE is present then memory is allocated for +* nxpwifi_ie pointer and filled in with IE. Caller should take care of freeing +* this memory. +*/ +static int nxpwifi_update_vs_ie (const u8 *ies,int ies_len, +struct nxpwifi_ie **ie_ptr,u16 mask, +unsigned int oui,u8 oui_type) +{ +struct element *vs_ie; +struct nxpwifi_ie *ie = *ie_ptr; +const u8 *vendor_ie; + + vendor_ie =cfg80211_find_vendor_ie (oui, oui_type, ies, ies_len); +if (vendor_ie) { +if (!*ie_ptr) { + *ie_ptr =kzalloc (sizeof (*ie_ptr),GFP_KERNEL ); +if (!*ie_ptr) +return -ENOMEM ; + ie = *ie_ptr; + } + + vs_ie = (struct element *)vendor_ie; +if (le16_to_cpu (ie->ie_length) + vs_ie->datalen +2 > +IEEE_MAX_IE_SIZE ) +return -EINVAL ; +memcpy (ie->ie_buffer +le16_to_cpu (ie->ie_length), + vs_ie, vs_ie->datalen +2 ); +le16_unaligned_add_cpu (&ie->ie_length, vs_ie->datalen +2 ); + ie->mgmt_subtype_mask =cpu_to_le16 (mask); + ie->ie_index =cpu_to_le16 (NXPWIFI_AUTO_IDX_MASK ); + } + + *ie_ptr = ie; +return 0 ; +} + +/* This function parses beacon IEs, probe response IEs, association response IEs +* from cfg80211_ap_settings->beacon and sets these IE to FW. +*/ +static int nxpwifi_set_mgmt_beacon_data_ies (struct nxpwifi_private *priv, +struct cfg80211_beacon_data *data) +{ +struct nxpwifi_ie *beacon_ie =NULL , *pr_ie =NULL , *ar_ie =NULL ; +u16 beacon_idx =NXPWIFI_AUTO_IDX_MASK , pr_idx =NXPWIFI_AUTO_IDX_MASK ; +u16 ar_idx =NXPWIFI_AUTO_IDX_MASK ; +int ret =0 ; + +if (data->beacon_ies && data->beacon_ies_len) { +nxpwifi_update_vs_ie (data->beacon_ies, data->beacon_ies_len, + &beacon_ie,MGMT_MASK_BEACON , +WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPS ); +nxpwifi_update_vs_ie (data->beacon_ies, data->beacon_ies_len, + &beacon_ie,MGMT_MASK_BEACON , +WLAN_OUI_WFA ,WLAN_OUI_TYPE_WFA_P2P ); + } + +if (data->proberesp_ies && data->proberesp_ies_len) { +nxpwifi_update_vs_ie (data->proberesp_ies, + data->proberesp_ies_len, &pr_ie, +MGMT_MASK_PROBE_RESP ,WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPS ); +nxpwifi_update_vs_ie (data->proberesp_ies, + data->proberesp_ies_len, &pr_ie, +MGMT_MASK_PROBE_RESP , +WLAN_OUI_WFA ,WLAN_OUI_TYPE_WFA_P2P ); + } + +if (data->assocresp_ies && data->assocresp_ies_len) { +nxpwifi_update_vs_ie (data->assocresp_ies, + data->assocresp_ies_len, &ar_ie, +MGMT_MASK_ASSOC_RESP | +MGMT_MASK_REASSOC_RESP , +WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPS ); +nxpwifi_update_vs_ie (data->assocresp_ies, + data->assocresp_ies_len, &ar_ie, +MGMT_MASK_ASSOC_RESP | +MGMT_MASK_REASSOC_RESP ,WLAN_OUI_WFA , +WLAN_OUI_TYPE_WFA_P2P ); + } + +if (beacon_ie || pr_ie || ar_ie) { + ret =nxpwifi_update_uap_custom_ie (priv, beacon_ie, + &beacon_idx, pr_ie, + &pr_idx, ar_ie, &ar_idx); +if (ret) + goto done; + } + + priv->beacon_idx = beacon_idx; + priv->proberesp_idx = pr_idx; + priv->assocresp_idx = ar_idx; + +done: +kfree (beacon_ie); +kfree (pr_ie); +kfree (ar_ie); + +return ret; +} + +/* This function parses head and tail IEs, from cfg80211_beacon_data and sets +* these IE to FW. +*/ +static int nxpwifi_uap_parse_tail_ies (struct nxpwifi_private *priv, +struct cfg80211_beacon_data *info) +{ +struct nxpwifi_ie *gen_ie; +struct element *hdr; +struct ieee80211_vendor_ie *vendorhdr; +u16 gen_idx =NXPWIFI_AUTO_IDX_MASK , ie_len =0 ; +int left_len, parsed_len =0 ; +unsigned int token_len; +int ret =0 ; + +if (!info->tail || !info->tail_len) +return 0 ; + + gen_ie =kzalloc (sizeof (*gen_ie),GFP_KERNEL ); +if (!gen_ie) +return -ENOMEM ; + + left_len = info->tail_len; + +/* Many IEs are generated in FW by parsing bss configuration. +* Let's not add them here; else we may end up duplicating these IEs +*/ +while (left_len >sizeof (struct element )) { + hdr = (void *)(info->tail + parsed_len); + token_len = hdr->datalen +sizeof (struct element ); +if (token_len > left_len) { + ret = -EINVAL ; + goto done; + } + +switch (hdr->id) { +case WLAN_EID_SSID : +case WLAN_EID_SUPP_RATES : +case WLAN_EID_COUNTRY : +case WLAN_EID_PWR_CONSTRAINT : +case WLAN_EID_ERP_INFO : +case WLAN_EID_EXT_SUPP_RATES : +case WLAN_EID_HT_CAPABILITY : +case WLAN_EID_HT_OPERATION : +case WLAN_EID_VHT_CAPABILITY : +case WLAN_EID_VHT_OPERATION : +break ; +case WLAN_EID_VENDOR_SPECIFIC : +/* Skip only Microsoft WMM IE */ +if (cfg80211_find_vendor_ie (WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WMM , + (const u8 *)hdr, + token_len)) +break ; + fallthrough; +default : +if (ie_len + token_len >IEEE_MAX_IE_SIZE ) { + ret = -EINVAL ; + goto done; + } +memcpy (gen_ie->ie_buffer + ie_len, hdr, token_len); + ie_len += token_len; +break ; + } + left_len -= token_len; + parsed_len += token_len; + } + +/* parse only WPA vendor IE from tail, WMM IE is configured by +* bss_config command +*/ + vendorhdr = (void *)cfg80211_find_vendor_ie (WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPA , + info->tail, info->tail_len); +if (vendorhdr) { + token_len = vendorhdr->len +sizeof (struct element ); +if (ie_len + token_len >IEEE_MAX_IE_SIZE ) { + ret = -EINVAL ; + goto done; + } +memcpy (gen_ie->ie_buffer + ie_len, vendorhdr, token_len); + ie_len += token_len; + } + +if (!ie_len) + goto done; + + gen_ie->ie_index =cpu_to_le16 (gen_idx); + gen_ie->mgmt_subtype_mask =cpu_to_le16 (MGMT_MASK_BEACON | +MGMT_MASK_PROBE_RESP | +MGMT_MASK_ASSOC_RESP ); + gen_ie->ie_length =cpu_to_le16 (ie_len); + + ret =nxpwifi_update_uap_custom_ie (priv, gen_ie, &gen_idx,NULL , +NULL ,NULL ,NULL ); + +if (ret) + goto done; + + priv->gen_idx = gen_idx; + + done: +kfree (gen_ie); +return ret; +} + +/* This function parses different IEs-head & tail IEs, beacon IEs, +* probe response IEs, association response IEs from cfg80211_ap_settings +* function and sets these IE to FW. +*/ +int nxpwifi_set_mgmt_ies (struct nxpwifi_private *priv, +struct cfg80211_beacon_data *info) +{ +int ret; + + ret =nxpwifi_uap_parse_tail_ies (priv, info); + +if (ret) +return ret; + +return nxpwifi_set_mgmt_beacon_data_ies (priv, info); +} + +/* This function removes management IE set */ +int nxpwifi_del_mgmt_ies (struct nxpwifi_private *priv) +{ +struct nxpwifi_ie *beacon_ie =NULL , *pr_ie =NULL ; +struct nxpwifi_ie *ar_ie =NULL , *gen_ie =NULL ; +int ret =0 ; + +if (priv->gen_idx !=NXPWIFI_AUTO_IDX_MASK ) { + gen_ie =kmalloc (sizeof (*gen_ie),GFP_KERNEL ); +if (!gen_ie) +return -ENOMEM ; + + gen_ie->ie_index =cpu_to_le16 (priv->gen_idx); + gen_ie->mgmt_subtype_mask =cpu_to_le16 (NXPWIFI_DELETE_MASK ); + gen_ie->ie_length =0 ; + ret =nxpwifi_update_uap_custom_ie (priv, gen_ie, &priv->gen_idx, +NULL , &priv->proberesp_idx, +NULL , &priv->assocresp_idx); +if (ret) + goto done; + + priv->gen_idx =NXPWIFI_AUTO_IDX_MASK ; + } + +if (priv->beacon_idx !=NXPWIFI_AUTO_IDX_MASK ) { + beacon_ie =kmalloc (sizeof (*beacon_ie),GFP_KERNEL ); +if (!beacon_ie) { + ret = -ENOMEM ; + goto done; + } + beacon_ie->ie_index =cpu_to_le16 (priv->beacon_idx); + beacon_ie->mgmt_subtype_mask =cpu_to_le16 (NXPWIFI_DELETE_MASK ); + beacon_ie->ie_length =0 ; + } +if (priv->proberesp_idx !=NXPWIFI_AUTO_IDX_MASK ) { + pr_ie =kmalloc (sizeof (*pr_ie),GFP_KERNEL ); +if (!pr_ie) { + ret = -ENOMEM ; + goto done; + } + pr_ie->ie_index =cpu_to_le16 (priv->proberesp_idx); + pr_ie->mgmt_subtype_mask =cpu_to_le16 (NXPWIFI_DELETE_MASK ); + pr_ie->ie_length =0 ; + } +if (priv->assocresp_idx !=NXPWIFI_AUTO_IDX_MASK ) { + ar_ie =kmalloc (sizeof (*ar_ie),GFP_KERNEL ); +if (!ar_ie) { + ret = -ENOMEM ; + goto done; + } + ar_ie->ie_index =cpu_to_le16 (priv->assocresp_idx); + ar_ie->mgmt_subtype_mask =cpu_to_le16 (NXPWIFI_DELETE_MASK ); + ar_ie->ie_length =0 ; + } + +if (beacon_ie || pr_ie || ar_ie) + ret =nxpwifi_update_uap_custom_ie (priv, + beacon_ie, &priv->beacon_idx, + pr_ie, &priv->proberesp_idx, + ar_ie, &priv->assocresp_idx); + +done: +kfree (gen_ie); +kfree (beacon_ie); +kfree (pr_ie); +kfree (ar_ie); + +return ret; +}
Signature · 1 line
2.34.1
PATCH v2 21/43 wifi: nxpwifi: add init.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/init.c | 694 ++++++++++++++++++++++++ 1 file changed, 694 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/init.c
drivers/net/wireless/nxp/nxpwifi/init.c new file +694 -0
@@ -0,0 +1,694 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: HW/FW Initialization +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" + +/* This function adds a BSS priority table to the table list. +* +* The function allocates a new BSS priority table node and adds it to +* the end of BSS priority table list, kept in driver memory. +*/ +static int nxpwifi_add_bss_prio_tbl (struct nxpwifi_private *priv) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_bss_prio_node *bss_prio; +struct nxpwifi_bss_prio_tbl *tbl = adapter->bss_prio_tbl; + + bss_prio =kzalloc (sizeof (*bss_prio),GFP_KERNEL ); +if (!bss_prio) +return -ENOMEM ; + + bss_prio->priv = priv; +INIT_LIST_HEAD (&bss_prio->list); + +spin_lock_bh (&tbl[priv->bss_priority].bss_prio_lock); +list_add_tail (&bss_prio->list, &tbl[priv->bss_priority].bss_prio_head); +spin_unlock_bh (&tbl[priv->bss_priority].bss_prio_lock); + +return 0 ; +} + +static void wakeup_timer_fn (struct timer_list *t) +{ +struct nxpwifi_adapter *adapter =from_timer (adapter, t, wakeup_timer); + +nxpwifi_dbg (adapter,ERROR ,"Firmware wakeup failed\n" ); + adapter->hw_status =NXPWIFI_HW_STATUS_RESET ; +nxpwifi_cancel_all_pending_cmd (adapter); + +if (adapter->if_ops.card_reset) + adapter->if_ops.card_reset (adapter); +} + +/* This function initializes the private structure and sets default +* values to the members. +* +* Additionally, it also initializes all the locks and sets up all the +* lists. +*/ +int nxpwifi_init_priv (struct nxpwifi_private *priv) +{ +u32 i; + + priv->media_connected = false; +eth_broadcast_addr (priv->curr_addr); + priv->port_open = false; + priv->usb_port =NXPWIFI_USB_EP_DATA ; + priv->pkt_tx_ctrl =0 ; + priv->bss_mode =NL80211_IFTYPE_UNSPECIFIED ; + priv->data_rate =0 ;/* Initially indicate the rate as auto */ + priv->is_data_rate_auto = true; + priv->bcn_avg_factor =DEFAULT_BCN_AVG_FACTOR ; + priv->data_avg_factor =DEFAULT_DATA_AVG_FACTOR ; + + priv->auth_flag =0 ; + priv->auth_alg =WLAN_AUTH_NONE ; + + priv->sec_info.wep_enabled =0 ; + priv->sec_info.authentication_mode =NL80211_AUTHTYPE_OPEN_SYSTEM ; + priv->sec_info.encryption_mode =0 ; +for (i =0 ; i <ARRAY_SIZE (priv->wep_key); i++) +memset (&priv->wep_key[i],0 ,sizeof (struct nxpwifi_wep_key )); + priv->wep_key_curr_index =0 ; + priv->curr_pkt_filter =HOST_ACT_MAC_DYNAMIC_BW_ENABLE | +HOST_ACT_MAC_RX_ON |HOST_ACT_MAC_TX_ON | +HOST_ACT_MAC_ETHERNETII_ENABLE ; + + priv->beacon_period =100 ;/* beacon interval */ + priv->attempted_bss_desc =NULL ; +memset (&priv->curr_bss_params,0 ,sizeof (priv->curr_bss_params)); + priv->listen_interval =NXPWIFI_DEFAULT_LISTEN_INTERVAL ; + +memset (&priv->prev_ssid,0 ,sizeof (priv->prev_ssid)); +memset (&priv->prev_bssid,0 ,sizeof (priv->prev_bssid)); +memset (&priv->assoc_rsp_buf,0 ,sizeof (priv->assoc_rsp_buf)); + priv->assoc_rsp_size =0 ; + priv->atim_window =0 ; + priv->tx_power_level =0 ; + priv->max_tx_power_level =0 ; + priv->min_tx_power_level =0 ; + priv->tx_ant =0 ; + priv->rx_ant =0 ; + priv->tx_rate =0 ; + priv->rxpd_htinfo =0 ; + priv->rxpd_rate =0 ; + priv->rate_bitmap =0 ; + priv->data_rssi_last =0 ; + priv->data_rssi_avg =0 ; + priv->data_nf_avg =0 ; + priv->data_nf_last =0 ; + priv->bcn_rssi_last =0 ; + priv->bcn_rssi_avg =0 ; + priv->bcn_nf_avg =0 ; + priv->bcn_nf_last =0 ; +memset (&priv->wpa_ie,0 ,sizeof (priv->wpa_ie)); +memset (&priv->aes_key,0 ,sizeof (priv->aes_key)); + priv->wpa_ie_len =0 ; + priv->wpa_is_gtk_set = false; + +memset (&priv->assoc_tlv_buf,0 ,sizeof (priv->assoc_tlv_buf)); + priv->assoc_tlv_buf_len =0 ; +memset (&priv->wps,0 ,sizeof (priv->wps)); +memset (&priv->gen_ie_buf,0 ,sizeof (priv->gen_ie_buf)); + priv->gen_ie_buf_len =0 ; +memset (priv->vs_ie,0 ,sizeof (priv->vs_ie)); + + priv->wmm_required = true; + priv->wmm_enabled = false; + priv->wmm_qosinfo =0 ; + priv->curr_bcn_buf =NULL ; + priv->curr_bcn_size =0 ; + priv->wps_ie =NULL ; + priv->wps_ie_len =0 ; + priv->ap_11n_enabled =0 ; +memset (&priv->roc_cfg,0 ,sizeof (priv->roc_cfg)); + + priv->scan_block = false; + + priv->csa_chan =0 ; + priv->csa_expire_time =0 ; + priv->del_list_idx =0 ; + priv->hs2_enabled = false; +memcpy (priv->tos_to_tid_inv, tos_to_tid_inv,MAX_NUM_TID ); + +nxpwifi_init_11h_params (priv); + +return nxpwifi_add_bss_prio_tbl (priv); +} + +/* This function allocates buffers for members of the adapter +* structure. +* +* The memory allocated includes scan table, command buffers, and +* sleep confirm command buffer. In addition, the queues are +* also initialized. +*/ +static int nxpwifi_allocate_adapter (struct nxpwifi_adapter *adapter) +{ +int ret; + +/* Allocate command buffer */ + ret =nxpwifi_alloc_cmd_buffer (adapter); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"%s: failed to alloc cmd buffer\n" , + __func__); +return ret; + } + + adapter->sleep_cfm = +dev_alloc_skb (sizeof (struct nxpwifi_opt_sleep_confirm ) + +INTF_HEADER_LEN ); + +if (!adapter->sleep_cfm) { +nxpwifi_dbg (adapter,ERROR , +"%s: failed to alloc sleep cfm\t" +" cmd buffer\n" , __func__); +return -ENOMEM ; + } +skb_reserve (adapter->sleep_cfm,INTF_HEADER_LEN ); + +return 0 ; +} + +/* This function initializes the adapter structure and sets default +* values to the members of adapter. +* +* This also initializes the WMM related parameters in the driver private +* structures. +*/ +static void nxpwifi_init_adapter (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_opt_sleep_confirm *sleep_cfm_buf =NULL ; + +skb_put (adapter->sleep_cfm,sizeof (struct nxpwifi_opt_sleep_confirm )); + + adapter->cmd_sent = false; + adapter->data_sent = true; + + adapter->intf_hdr_len =INTF_HEADER_LEN ; + + adapter->cmd_resp_received = false; + adapter->event_received = false; + adapter->data_received = false; + adapter->assoc_resp_received = false; + adapter->priv_link_lost =NULL ; + adapter->host_mlme_link_lost = false; + +clear_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; + + adapter->ps_mode =NXPWIFI_802_11_POWER_MODE_CAM ; + adapter->ps_state =PS_STATE_AWAKE ; + adapter->need_to_wakeup = false; + + adapter->scan_mode =HOST_BSS_MODE_ANY ; + adapter->specific_scan_time =NXPWIFI_SPECIFIC_SCAN_CHAN_TIME ; + adapter->active_scan_time =NXPWIFI_ACTIVE_SCAN_CHAN_TIME ; + adapter->passive_scan_time =NXPWIFI_PASSIVE_SCAN_CHAN_TIME ; + adapter->scan_chan_gap_time =NXPWIFI_DEF_SCAN_CHAN_GAP_TIME ; + + adapter->scan_probes =1 ; + + adapter->multiple_dtim =1 ; + +/* default value in firmware will be used */ + adapter->local_listen_interval =0 ; + + adapter->is_deep_sleep = false; + + adapter->delay_null_pkt = false; + adapter->delay_to_ps =1000 ; + adapter->enhanced_ps_mode =PS_MODE_AUTO ; + +/* Disable NULL Pkg generation by default */ + adapter->gen_null_pkt = false; +/* Disable pps/uapsd mode by default */ + adapter->pps_uapsd_mode = false; + adapter->pm_wakeup_card_req = false; + + adapter->pm_wakeup_fw_try = false; + + adapter->curr_tx_buf_size =NXPWIFI_TX_DATA_BUF_SIZE_2K ; + +clear_bit (NXPWIFI_IS_HS_CONFIGURED , &adapter->work_flags); + adapter->hs_cfg.conditions =cpu_to_le32 (HS_CFG_COND_DEF ); + adapter->hs_cfg.gpio =HS_CFG_GPIO_DEF ; + adapter->hs_cfg.gap =HS_CFG_GAP_DEF ; + adapter->hs_activated = false; + +memset (adapter->event_body,0 ,sizeof (adapter->event_body)); + adapter->hw_dot_11n_dev_cap =0 ; + adapter->hw_dev_mcs_support =0 ; + adapter->sec_chan_offset =0 ; + +nxpwifi_wmm_init (adapter); +atomic_set (&adapter->tx_hw_pending,0 ); + + sleep_cfm_buf = (struct nxpwifi_opt_sleep_confirm *) + adapter->sleep_cfm->data; +memset (sleep_cfm_buf,0 , adapter->sleep_cfm->len); + sleep_cfm_buf->command =cpu_to_le16 (HOST_CMD_802_11_PS_MODE_ENH ); + sleep_cfm_buf->size =cpu_to_le16 (adapter->sleep_cfm->len); + sleep_cfm_buf->result =0 ; + sleep_cfm_buf->action =cpu_to_le16 (SLEEP_CONFIRM ); + sleep_cfm_buf->resp_ctrl =cpu_to_le16 (RESP_NEEDED ); + +memset (&adapter->sleep_period,0 ,sizeof (adapter->sleep_period)); + adapter->tx_lock_flag = false; + adapter->null_pkt_interval =0 ; + adapter->fw_bands =0 ; + adapter->config_bands =0 ; + adapter->fw_release_number =0 ; + adapter->fw_cap_info =0 ; +memset (&adapter->upld_buf,0 ,sizeof (adapter->upld_buf)); + adapter->event_cause =0 ; + adapter->region_code =0 ; + adapter->bcn_miss_time_out =DEFAULT_BCN_MISS_TIMEOUT ; +memset (&adapter->arp_filter,0 ,sizeof (adapter->arp_filter)); + adapter->arp_filter_size =0 ; + adapter->max_mgmt_ie_index =MAX_MGMT_IE_INDEX ; + adapter->key_api_major_ver =0 ; + adapter->key_api_minor_ver =0 ; +eth_broadcast_addr (adapter->perm_addr); + adapter->iface_limit.sta_intf =NXPWIFI_MAX_STA_NUM ; + adapter->iface_limit.uap_intf =NXPWIFI_MAX_UAP_NUM ; + adapter->active_scan_triggered = false; +timer_setup (&adapter->wakeup_timer, wakeup_timer_fn,0 ); + adapter->devdump_len =0 ; +memset (&adapter->vdll_ctrl,0 ,sizeof (adapter->vdll_ctrl)); + adapter->vdll_ctrl.skb =dev_alloc_skb (NXPWIFI_SIZE_OF_CMD_BUFFER ); +} + +/* This function sets trans_start per tx_queue +*/ +void nxpwifi_set_trans_start (struct net_device *dev) +{ +int i; + +for (i =0 ; i < dev->num_tx_queues; i++) +txq_trans_cond_update (netdev_get_tx_queue (dev, i)); + +netif_trans_update (dev); +} + +/* This function wakes up all queues in net_device +*/ +void nxpwifi_wake_up_net_dev_queue (struct net_device *netdev, +struct nxpwifi_adapter *adapter) +{ +spin_lock_bh (&adapter->queue_lock); +netif_tx_wake_all_queues (netdev); +spin_unlock_bh (&adapter->queue_lock); +} + +/* This function stops all queues in net_device +*/ +void nxpwifi_stop_net_dev_queue (struct net_device *netdev, +struct nxpwifi_adapter *adapter) +{ +spin_lock_bh (&adapter->queue_lock); +netif_tx_stop_all_queues (netdev); +spin_unlock_bh (&adapter->queue_lock); +} + +/* This function invalidates the list heads. +*/ +static void nxpwifi_invalidate_lists (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +s32 i, j; + +list_del (&adapter->cmd_free_q); +list_del (&adapter->cmd_pending_q); +list_del (&adapter->scan_pending_q); + +for (i =0 ; i < adapter->priv_num; i++) +list_del (&adapter->bss_prio_tbl[i].bss_prio_head); + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + priv = adapter->priv[i]; +for (j =0 ; j <MAX_NUM_TID ; ++j) +list_del (&priv->wmm.tid_tbl_ptr[j].ra_list); +list_del (&priv->tx_ba_stream_tbl_ptr); +list_del (&priv->rx_reorder_tbl_ptr); +list_del (&priv->sta_list); + } + } +} + +/* This function performs cleanup for adapter structure. +* +* The cleanup is done recursively, by canceling all pending +* commands, freeing the member buffers previously allocated +* (command buffers, scan table buffer, sleep confirm command +* buffer), stopping the timers and calling the cleanup routines +* for every interface. +*/ +static void +nxpwifi_adapter_cleanup (struct nxpwifi_adapter *adapter) +{ +del_timer (&adapter->wakeup_timer); +nxpwifi_cancel_all_pending_cmd (adapter); +wake_up_interruptible (&adapter->cmd_wait_q.wait); +wake_up_interruptible (&adapter->hs_activate_wait_q); +if (adapter->vdll_ctrl.vdll_mem) { +vfree (adapter->vdll_ctrl.vdll_mem); + adapter->vdll_ctrl.vdll_mem =NULL ; + adapter->vdll_ctrl.vdll_len =0 ; + } +if (adapter->vdll_ctrl.skb) { +dev_kfree_skb_any (adapter->vdll_ctrl.skb); + adapter->vdll_ctrl.skb =NULL ; + } +} + +void nxpwifi_free_cmd_buffers (struct nxpwifi_adapter *adapter) +{ +nxpwifi_invalidate_lists (adapter); + +/* Free command buffer */ +nxpwifi_dbg (adapter,INFO ,"info: free cmd buffer\n" ); +nxpwifi_free_cmd_buffer (adapter); + +if (adapter->sleep_cfm) +dev_kfree_skb_any (adapter->sleep_cfm); +} + +/* This function intializes the lock variables and +* the list heads. +*/ +void nxpwifi_init_lock_list (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +s32 i, j; + +spin_lock_init (&adapter->int_lock); +spin_lock_init (&adapter->main_proc_lock); +spin_lock_init (&adapter->nxpwifi_cmd_lock); +spin_lock_init (&adapter->queue_lock); +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + priv = adapter->priv[i]; +spin_lock_init (&priv->wmm.ra_list_spinlock); +spin_lock_init (&priv->curr_bcn_buf_lock); +spin_lock_init (&priv->sta_list_spinlock); + } + } + +/* Initialize cmd_free_q */ +INIT_LIST_HEAD (&adapter->cmd_free_q); +/* Initialize cmd_pending_q */ +INIT_LIST_HEAD (&adapter->cmd_pending_q); +/* Initialize scan_pending_q */ +INIT_LIST_HEAD (&adapter->scan_pending_q); + +spin_lock_init (&adapter->cmd_free_q_lock); +spin_lock_init (&adapter->cmd_pending_q_lock); +spin_lock_init (&adapter->scan_pending_q_lock); + +skb_queue_head_init (&adapter->rx_mlme_q); +skb_queue_head_init (&adapter->rx_data_q); +skb_queue_head_init (&adapter->tx_data_q); + +for (i =0 ; i < adapter->priv_num; ++i) { +INIT_LIST_HEAD (&adapter->bss_prio_tbl[i].bss_prio_head); +spin_lock_init (&adapter->bss_prio_tbl[i].bss_prio_lock); + } + +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i]) +continue ; + priv = adapter->priv[i]; +for (j =0 ; j <MAX_NUM_TID ; ++j) +INIT_LIST_HEAD (&priv->wmm.tid_tbl_ptr[j].ra_list); +INIT_LIST_HEAD (&priv->tx_ba_stream_tbl_ptr); +INIT_LIST_HEAD (&priv->rx_reorder_tbl_ptr); +INIT_LIST_HEAD (&priv->sta_list); +skb_queue_head_init (&priv->bypass_txq); + +spin_lock_init (&priv->tx_ba_stream_tbl_lock); +spin_lock_init (&priv->rx_reorder_tbl_lock); + +spin_lock_init (&priv->ack_status_lock); +idr_init (&priv->ack_status_frames); + } +} + +/* This function initializes the firmware. +* +* The following operations are performed sequentially - +* - Allocate adapter structure +* - Initialize the adapter structure +* - Initialize the private structure +* - Add BSS priority tables to the adapter structure +* - For each interface, send the init commands to firmware +* - Send the first command in command pending queue, if available +*/ +int nxpwifi_init_fw (struct nxpwifi_adapter *adapter) +{ +int ret; +struct nxpwifi_private *priv; +u8 i; +bool first_sta = true; +int is_cmd_pend_q_empty; + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; + +/* Allocate memory for member of adapter structure */ + ret =nxpwifi_allocate_adapter (adapter); +if (ret) +return ret; + +/* Initialize adapter structure */ +nxpwifi_init_adapter (adapter); + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + priv = adapter->priv[i]; + +/* Initialize private structure */ + ret =nxpwifi_init_priv (priv); +if (ret) +return ret; + } + } + +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + ret =nxpwifi_sta_init_cmd (adapter->priv[i], + first_sta, true); +if (ret && ret != -EINPROGRESS ) +return ret; + + first_sta = false; + } + } + +spin_lock_bh (&adapter->cmd_pending_q_lock); + is_cmd_pend_q_empty =list_empty (&adapter->cmd_pending_q); +spin_unlock_bh (&adapter->cmd_pending_q_lock); +if (!is_cmd_pend_q_empty) +/* Send the first command in queue and return */ +nxpwifi_main_process (adapter); +else + adapter->hw_status =NXPWIFI_HW_STATUS_READY ; + +return ret; +} + +/* This function deletes the BSS priority tables. +* +* The function traverses through all the allocated BSS priority nodes +* in every BSS priority table and frees them. +*/ +static void nxpwifi_delete_bss_prio_tbl (struct nxpwifi_private *priv) +{ +int i; +struct nxpwifi_adapter *adapter = priv->adapter; +struct nxpwifi_bss_prio_node *bssprio_node, *tmp_node; +struct list_head *head; +spinlock_t *lock;/* bss priority lock */ + +for (i =0 ; i < adapter->priv_num; ++i) { + head = &adapter->bss_prio_tbl[i].bss_prio_head; + lock = &adapter->bss_prio_tbl[i].bss_prio_lock; +nxpwifi_dbg (adapter,INFO , +"info: delete BSS priority table,\t" +"bss_type = %d, bss_num = %d, i = %d,\t" +"head = %p\n" , + priv->bss_type, priv->bss_num, i, head); + + { +spin_lock_bh (lock); +list_for_each_entry_safe (bssprio_node, tmp_node, head, + list) { +if (bssprio_node->priv == priv) { +nxpwifi_dbg (adapter,INFO , +"info: Delete\t" +"node %p, next = %p\n" , + bssprio_node, tmp_node); +list_del (&bssprio_node->list); +kfree (bssprio_node); + } + } +spin_unlock_bh (lock); + } + } +} + +/* This function frees the private structure, including cleans +* up the TX and RX queues and frees the BSS priority tables. +*/ +void nxpwifi_free_priv (struct nxpwifi_private *priv) +{ +nxpwifi_clean_txrx (priv); +nxpwifi_delete_bss_prio_tbl (priv); +nxpwifi_free_curr_bcn (priv); +} + +/* This function is used to shutdown the driver. +* +* The following operations are performed sequentially - +* - Check if already shut down +* - Make sure the main process has stopped +* - Clean up the Tx and Rx queues +* - Delete BSS priority tables +* - Free the adapter +* - Notify completion +*/ +void +nxpwifi_shutdown_drv (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +s32 i; +struct sk_buff *skb; + +/* nxpwifi already shutdown */ +if (adapter->hw_status ==NXPWIFI_HW_STATUS_NOT_READY ) +return ; + +/* cancel current command */ +if (adapter->curr_cmd) { +nxpwifi_dbg (adapter,WARN , +"curr_cmd is still in processing\n" ); +del_timer_sync (&adapter->cmd_timer); +nxpwifi_recycle_cmd_node (adapter, adapter->curr_cmd); + adapter->curr_cmd =NULL ; + } + +/* shut down nxpwifi */ +nxpwifi_dbg (adapter,MSG , +"info: shutdown nxpwifi...\n" ); + +/* Clean up Tx/Rx queues and delete BSS priority table */ +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { + priv = adapter->priv[i]; + +nxpwifi_abort_cac (priv); +nxpwifi_free_priv (priv); + } + } + +atomic_set (&adapter->tx_queued,0 ); +while ((skb =skb_dequeue (&adapter->tx_data_q))) +nxpwifi_write_data_complete (adapter, skb,0 ,0 ); + +tasklet_disable (&adapter->rx_task); + +while ((skb =skb_dequeue (&adapter->rx_mlme_q))) +dev_kfree_skb_any (skb); + +while ((skb =skb_dequeue (&adapter->rx_data_q))) { +struct nxpwifi_rxinfo *rx_info =NXPWIFI_SKB_RXCB (skb); + + priv = adapter->priv[rx_info->bss_num]; +if (priv) + priv->stats.rx_dropped++; + +dev_kfree_skb_any (skb); + } + +nxpwifi_adapter_cleanup (adapter); + + adapter->hw_status =NXPWIFI_HW_STATUS_NOT_READY ; +} + +/* This function downloads the firmware to the card. +* +* The actual download is preceded by two sanity checks - +* - Check if firmware is already running +* - Check if the interface is the winner to download the firmware +* +* ...and followed by another - +* - Check if the firmware is downloaded successfully +* +* After download is successfully completed, the host interrupts are enabled. +*/ +int nxpwifi_dnld_fw (struct nxpwifi_adapter *adapter, +struct nxpwifi_fw_image *pmfw) +{ +int ret; +u32 poll_num =1 ; + +/* check if firmware is already running */ + ret = adapter->if_ops.check_fw_status (adapter, poll_num); +if (!ret) { +nxpwifi_dbg (adapter,MSG , +"WLAN FW already running! Skip FW dnld\n" ); +return 0 ; + } + +/* check if we are the winner for downloading FW */ +if (adapter->if_ops.check_winner_status) { + adapter->winner =0 ; + ret = adapter->if_ops.check_winner_status (adapter); + + poll_num =MAX_FIRMWARE_POLL_TRIES ; +if (ret) { +nxpwifi_dbg (adapter,MSG , +"WLAN read winner status failed!\n" ); +return ret; + } + +if (!adapter->winner) { +nxpwifi_dbg (adapter,MSG , +"WLAN is not the winner! Skip FW dnld\n" ); + goto poll_fw; + } + } + +if (pmfw) { +/* Download firmware with helper */ + ret = adapter->if_ops.prog_fw (adapter, pmfw); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"prog_fw failed ret=%#x\n" , ret); +return ret; + } + } + +poll_fw: +/* Check if the firmware is downloaded successfully or not */ + ret = adapter->if_ops.check_fw_status (adapter, poll_num); +if (ret) +nxpwifi_dbg (adapter,ERROR , +"FW failed to be active in time\n" ); + +return ret; +} +EXPORT_SYMBOL_GPL (nxpwifi_dnld_fw);
Signature · 1 line
2.34.1
PATCH v2 22/43 wifi: nxpwifi: add join.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/join.c | 915 ++++++++++++++++++++++++ 1 file changed, 915 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/join.c
drivers/net/wireless/nxp/nxpwifi/join.c new file +915 -0
@@ -0,0 +1,915 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: association and ad-hoc start/join +* +* Copyright 2011-2024 NXP +*/ + +#include "decl.h" +#include "cfg.h" +#include "util.h" +#include "fw.h" +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "11n.h" +#include "11ac.h" + +#define CAPINFO_MASK (~(BIT(15) | BIT(14) | BIT(12) | BIT(11) | BIT(9))) + +/* Append a generic IE as a pass through TLV to a TLV buffer. +* +* This function is called from the network join command preparation routine. +* +* If the IE buffer has been setup by the application, this routine appends +* the buffer as a pass through TLV type to the request. +*/ +static int +nxpwifi_cmd_append_generic_ie (struct nxpwifi_private *priv,u8 **buffer) +{ +int ret_len =0 ; +struct nxpwifi_ie_types_header ie_header; + +/* Null Checks */ +if (!buffer) +return 0 ; +if (!(*buffer)) +return 0 ; + +/* If there is a generic ie buffer setup, append it to the return +* parameter buffer pointer. +*/ +if (priv->gen_ie_buf_len) { +nxpwifi_dbg (priv->adapter,INFO , +"info: %s: append generic ie len %d to %p\n" , + __func__, priv->gen_ie_buf_len, *buffer); + +/* Wrap the generic IE buffer with a pass through TLV type */ + ie_header.type =cpu_to_le16 (TLV_TYPE_PASSTHROUGH ); + ie_header.len =cpu_to_le16 (priv->gen_ie_buf_len); +memcpy (*buffer, &ie_header,sizeof (ie_header)); + +/* Increment the return size and the return buffer pointer +* param +*/ + *buffer +=sizeof (ie_header); + ret_len +=sizeof (ie_header); + +/* Copy the generic IE buffer to the output buffer, advance +* pointer +*/ +memcpy (*buffer, priv->gen_ie_buf, priv->gen_ie_buf_len); + +/* Increment the return size and the return buffer pointer +* param +*/ + *buffer += priv->gen_ie_buf_len; + ret_len += priv->gen_ie_buf_len; + +/* Reset the generic IE buffer */ + priv->gen_ie_buf_len =0 ; + } + +/* return the length appended to the buffer */ +return ret_len; +} + +/* Append TSF tracking info from the scan table for the target AP. +* +* This function is called from the network join command preparation routine. +* +* The TSF table TSF sent to the firmware contains two TSF values: +* - The TSF of the target AP from its previous beacon/probe response +* - The TSF timestamp of our local MAC at the time we observed the +* beacon/probe response. +* +* The firmware uses the timestamp values to set an initial TSF value +* in the MAC for the new association after a reassociation attempt. +*/ +static int +nxpwifi_cmd_append_tsf_tlv (struct nxpwifi_private *priv,u8 **buffer, +struct nxpwifi_bssdescriptor *bss_desc) +{ +struct nxpwifi_ie_types_tsf_timestamp tsf_tlv; +__le64 tsf_val; + +/* Null Checks */ +if (!buffer) +return 0 ; +if (!*buffer) +return 0 ; + +memset (&tsf_tlv,0x00 ,sizeof (struct nxpwifi_ie_types_tsf_timestamp )); + + tsf_tlv.header.type =cpu_to_le16 (TLV_TYPE_TSFTIMESTAMP ); + tsf_tlv.header.len =cpu_to_le16 (2 *sizeof (tsf_val)); + +memcpy (*buffer, &tsf_tlv,sizeof (tsf_tlv.header)); + *buffer +=sizeof (tsf_tlv.header); + +/* TSF at the time when beacon/probe_response was received */ + tsf_val =cpu_to_le64 (bss_desc->fw_tsf); +memcpy (*buffer, &tsf_val,sizeof (tsf_val)); + *buffer +=sizeof (tsf_val); + + tsf_val =cpu_to_le64 (bss_desc->timestamp); + +nxpwifi_dbg (priv->adapter,INFO , +"info: %s: TSF offset calc: %016llx - %016llx\n" , + __func__, bss_desc->timestamp, bss_desc->fw_tsf); + +memcpy (*buffer, &tsf_val,sizeof (tsf_val)); + *buffer +=sizeof (tsf_val); + +return sizeof (tsf_tlv.header) + (2 *sizeof (tsf_val)); +} + +/* This function finds out the common rates between rate1 and rate2. +* +* It will fill common rates in rate1 as output if found. +* +* NOTE: Setting the MSB of the basic rates needs to be taken +* care of, either before or after calling this function. +*/ +static int nxpwifi_get_common_rates (struct nxpwifi_private *priv,u8 *rate1, +u32 rate1_size,u8 *rate2,u32 rate2_size) +{ +int ret; +u8 *ptr = rate1, *tmp; +u32 i, j; + + tmp =kmemdup (rate1, rate1_size,GFP_KERNEL ); +if (!tmp) +return -ENOMEM ; + +memset (rate1,0 , rate1_size); + +for (i =0 ; i < rate2_size && rate2[i]; i++) { +for (j =0 ; j < rate1_size && tmp[j]; j++) { +/* Check common rate, excluding the bit for +* basic rate +*/ +if ((rate2[i] &0x7F ) == (tmp[j] &0x7F )) { + *rate1++ = tmp[j]; +break ; + } + } + } + +nxpwifi_dbg (priv->adapter,INFO ,"info: Tx data rate set to %#x\n" , + priv->data_rate); + +if (!priv->is_data_rate_auto) { +while (*ptr) { +if ((*ptr &0x7f ) == priv->data_rate) { + ret =0 ; + goto done; + } + ptr++; + } +nxpwifi_dbg (priv->adapter,ERROR , +"previously set fixed data rate %#x\t" +"is not compatible with the network\n" , + priv->data_rate); + + ret = -EPERM ; + goto done; + } + + ret =0 ; +done: +kfree (tmp); +return ret; +} + +/* This function creates the intersection of the rates supported by a +* target BSS and our adapter settings for use in an assoc/join command. +*/ +static int +nxpwifi_setup_rates_from_bssdesc (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc, +u8 *out_rates,u32 *out_rates_size) +{ +u8 card_rates[NXPWIFI_SUPPORTED_RATES ]; +u32 card_rates_size; +int ret; + +/* Copy AP supported rates */ +memcpy (out_rates, bss_desc->supported_rates,NXPWIFI_SUPPORTED_RATES ); +/* Get the STA supported rates */ + card_rates_size =nxpwifi_get_active_data_rates (priv, card_rates); +/* Get the common rates between AP and STA supported rates */ + ret =nxpwifi_get_common_rates (priv, out_rates,NXPWIFI_SUPPORTED_RATES , + card_rates, card_rates_size); +if (ret) { + *out_rates_size =0 ; +nxpwifi_dbg (priv->adapter,ERROR , +"%s: cannot get common rates\n" , + __func__); + }else { + *out_rates_size = +min_t (size_t,strlen (out_rates),NXPWIFI_SUPPORTED_RATES ); + } + +return ret; +} + +/* This function appends a WPS IE. It is called from the network join command +* preparation routine. +* +* If the IE buffer has been setup by the application, this routine appends +* the buffer as a WPS TLV type to the request. +*/ +static int +nxpwifi_cmd_append_wps_ie (struct nxpwifi_private *priv,u8 **buffer) +{ +int ret_len =0 ; +struct nxpwifi_ie_types_header ie_header; + +if (!buffer || !*buffer) +return 0 ; + +/* If there is a wps ie buffer setup, append it to the return +* parameter buffer pointer. +*/ +if (priv->wps_ie_len) { +nxpwifi_dbg (priv->adapter,CMD , +"cmd: append wps ie %d to %p\n" , + priv->wps_ie_len, *buffer); + +/* Wrap the generic IE buffer with a pass through TLV type */ + ie_header.type =cpu_to_le16 (TLV_TYPE_PASSTHROUGH ); + ie_header.len =cpu_to_le16 (priv->wps_ie_len); +memcpy (*buffer, &ie_header,sizeof (ie_header)); + *buffer +=sizeof (ie_header); + ret_len +=sizeof (ie_header); + +memcpy (*buffer, priv->wps_ie, priv->wps_ie_len); + *buffer += priv->wps_ie_len; + ret_len += priv->wps_ie_len; + } + +kfree (priv->wps_ie); + priv->wps_ie_len =0 ; +return ret_len; +} + +/* This function appends rsn ie tlv for wpa/wpa2 security modes. +* It is called from the network join command preparation routine. +*/ +static int nxpwifi_append_rsn_ie_wpa_wpa2 (struct nxpwifi_private *priv, +u8 **buffer) +{ +struct nxpwifi_ie_types_rsn_param_set *rsn_ie_tlv; +int rsn_ie_len; + +if (!buffer || !(*buffer)) +return 0 ; + + rsn_ie_tlv = (struct nxpwifi_ie_types_rsn_param_set *)(*buffer); + rsn_ie_tlv->header.type =cpu_to_le16 ((u16 )priv->wpa_ie[0 ]); + rsn_ie_tlv->header.type = +cpu_to_le16 (le16_to_cpu (rsn_ie_tlv->header.type) &0x00FF ); + rsn_ie_tlv->header.len =cpu_to_le16 ((u16 )priv->wpa_ie[1 ]); + rsn_ie_tlv->header.len =cpu_to_le16 (le16_to_cpu (rsn_ie_tlv->header.len) + &0x00FF ); +if (le16_to_cpu (rsn_ie_tlv->header.len) <= (sizeof (priv->wpa_ie) -2 )) +memcpy (rsn_ie_tlv->rsn_ie, &priv->wpa_ie[2 ], +le16_to_cpu (rsn_ie_tlv->header.len)); +else +return -ENOMEM ; + + rsn_ie_len =sizeof (rsn_ie_tlv->header) + +le16_to_cpu (rsn_ie_tlv->header.len); + *buffer += rsn_ie_len; + +return rsn_ie_len; +} + +/* This function prepares command for association. +* +* This sets the following parameters - +* - Peer MAC address +* - Listen interval +* - Beacon interval +* - Capability information +* +* ...and the following TLVs, as required - +* - SSID TLV +* - PHY TLV +* - SS TLV +* - Rates TLV +* - Authentication TLV +* - Channel TLV +* - WPA/WPA2 IE +* - 11n TLV +* - Vendor specific TLV +* - WMM TLV +* - Generic IE +* - TSF TLV +* +* Preparation also includes - +* - Setting command ID and proper size +* - Ensuring correct endian-ness +*/ +int nxpwifi_cmd_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *cmd, +struct nxpwifi_bssdescriptor *bss_desc) +{ +struct host_cmd_ds_802_11_associate *assoc = &cmd->params.associate; +struct nxpwifi_ie_types_host_mlme *host_mlme_tlv; +struct nxpwifi_ie_types_ssid_param_set *ssid_tlv; +struct nxpwifi_ie_types_phy_param_set *phy_tlv; +struct nxpwifi_ie_types_ss_param_set *ss_tlv; +struct nxpwifi_ie_types_rates_param_set *rates_tlv; +struct nxpwifi_ie_types_auth_type *auth_tlv; +struct nxpwifi_ie_types_sae_pwe_mode *sae_pwe_tlv; +struct nxpwifi_ie_types_chan_list_param_set *chan_tlv; +u8 rates[NXPWIFI_SUPPORTED_RATES ]; +u32 rates_size; +u16 tmp_cap; +u8 *pos; +int rsn_ie_len =0 ; +int ret; + + pos = (u8 *)assoc; + + cmd->command =cpu_to_le16 (HOST_CMD_802_11_ASSOCIATE ); + +/* Save so we know which BSS Desc to use in the response handler */ + priv->attempted_bss_desc = bss_desc; + +memcpy (assoc->peer_sta_addr, + bss_desc->mac_address,sizeof (assoc->peer_sta_addr)); + pos +=sizeof (assoc->peer_sta_addr); + +/* Set the listen interval */ + assoc->listen_interval =cpu_to_le16 (priv->listen_interval); +/* Set the beacon period */ + assoc->beacon_period =cpu_to_le16 (bss_desc->beacon_period); + + pos +=sizeof (assoc->cap_info_bitmap); + pos +=sizeof (assoc->listen_interval); + pos +=sizeof (assoc->beacon_period); + pos +=sizeof (assoc->dtim_period); + + host_mlme_tlv = (struct nxpwifi_ie_types_host_mlme *)pos; + host_mlme_tlv->header.type =cpu_to_le16 (TLV_TYPE_HOST_MLME ); + host_mlme_tlv->header.len =cpu_to_le16 (sizeof (host_mlme_tlv->host_mlme)); + host_mlme_tlv->host_mlme =1 ; + pos +=sizeof (host_mlme_tlv->header) +sizeof (host_mlme_tlv->host_mlme); + + ssid_tlv = (struct nxpwifi_ie_types_ssid_param_set *)pos; + ssid_tlv->header.type =cpu_to_le16 (WLAN_EID_SSID ); + ssid_tlv->header.len =cpu_to_le16 ((u16 )bss_desc->ssid.ssid_len); +memcpy (ssid_tlv->ssid, bss_desc->ssid.ssid, +le16_to_cpu (ssid_tlv->header.len)); + pos +=sizeof (ssid_tlv->header) +le16_to_cpu (ssid_tlv->header.len); + + phy_tlv = (struct nxpwifi_ie_types_phy_param_set *)pos; + phy_tlv->header.type =cpu_to_le16 (WLAN_EID_DS_PARAMS ); + phy_tlv->header.len =cpu_to_le16 (sizeof (phy_tlv->fh_ds.ds_param_set)); +memcpy (&phy_tlv->fh_ds.ds_param_set, + &bss_desc->phy_param_set.ds_param_set.current_chan, +sizeof (phy_tlv->fh_ds.ds_param_set)); + pos +=sizeof (phy_tlv->header) +le16_to_cpu (phy_tlv->header.len); + + ss_tlv = (struct nxpwifi_ie_types_ss_param_set *)pos; + ss_tlv->header.type =cpu_to_le16 (WLAN_EID_CF_PARAMS ); + ss_tlv->header.len =cpu_to_le16 (sizeof (ss_tlv->cf_ibss.cf_param_set)); + pos +=sizeof (ss_tlv->header) +le16_to_cpu (ss_tlv->header.len); + +/* Get the common rates supported between the driver and the BSS Desc */ + ret =nxpwifi_setup_rates_from_bssdesc (priv, bss_desc, + rates, &rates_size); +if (ret) +return ret; + +/* Save the data rates into Current BSS state structure */ + priv->curr_bss_params.num_of_rates = rates_size; +memcpy (&priv->curr_bss_params.data_rates, rates, rates_size); + +/* Setup the Rates TLV in the association command */ + rates_tlv = (struct nxpwifi_ie_types_rates_param_set *)pos; + rates_tlv->header.type =cpu_to_le16 (WLAN_EID_SUPP_RATES ); + rates_tlv->header.len =cpu_to_le16 ((u16 )rates_size); +memcpy (rates_tlv->rates, rates, rates_size); + pos +=sizeof (rates_tlv->header) + rates_size; +nxpwifi_dbg (priv->adapter,INFO ,"info: ASSOC_CMD: rates size = %d\n" , + rates_size); + +/* Add the Authentication type */ + auth_tlv = (struct nxpwifi_ie_types_auth_type *)pos; + auth_tlv->header.type =cpu_to_le16 (TLV_TYPE_AUTH_TYPE ); + auth_tlv->header.len =cpu_to_le16 (sizeof (auth_tlv->auth_type)); +if (priv->sec_info.wep_enabled) + auth_tlv->auth_type = +cpu_to_le16 ((u16 )priv->sec_info.authentication_mode); +else + auth_tlv->auth_type =cpu_to_le16 (NL80211_AUTHTYPE_OPEN_SYSTEM ); + + pos +=sizeof (auth_tlv->header) +le16_to_cpu (auth_tlv->header.len); + +if (priv->sec_info.authentication_mode ==WLAN_AUTH_SAE ) { + auth_tlv->auth_type =cpu_to_le16 (NXPWIFI_AUTHTYPE_SAE ); +if (bss_desc->bcn_rsnx_ie && + bss_desc->bcn_rsnx_ie->datalen && + (bss_desc->bcn_rsnx_ie->data[0 ] & +WLAN_RSNX_CAPA_SAE_H2E )) { + sae_pwe_tlv = + (struct nxpwifi_ie_types_sae_pwe_mode *)pos; + sae_pwe_tlv->header.type = +cpu_to_le16 (TLV_TYPE_SAE_PWE_MODE ); + sae_pwe_tlv->header.len = +cpu_to_le16 (sizeof (sae_pwe_tlv->pwe[0 ])); + sae_pwe_tlv->pwe[0 ] = bss_desc->bcn_rsnx_ie->data[0 ]; + pos +=sizeof (sae_pwe_tlv->header) + +sizeof (sae_pwe_tlv->pwe[0 ]); + } + } + +if (IS_SUPPORT_MULTI_BANDS (priv->adapter) && + !(ISSUPP_11NENABLED (priv->adapter->fw_cap_info) && + !bss_desc->disable_11n && + (priv->adapter->config_bands &BAND_GN || + priv->adapter->config_bands &BAND_AN ) && + bss_desc->bcn_ht_cap)) { +/* Append a channel TLV for the channel the attempted AP was +* found on +*/ + chan_tlv = (struct nxpwifi_ie_types_chan_list_param_set *)pos; + chan_tlv->header.type =cpu_to_le16 (TLV_TYPE_CHANLIST ); + chan_tlv->header.len = +cpu_to_le16 (sizeof (struct nxpwifi_chan_scan_param_set )); + +memset (chan_tlv->chan_scan_param,0x00 , +sizeof (struct nxpwifi_chan_scan_param_set )); + chan_tlv->chan_scan_param[0 ].chan_number = + (bss_desc->phy_param_set.ds_param_set.current_chan); +nxpwifi_dbg (priv->adapter,INFO ,"info: Assoc: TLV Chan = %d\n" , + chan_tlv->chan_scan_param[0 ].chan_number); + + chan_tlv->chan_scan_param[0 ].radio_type = +nxpwifi_band_to_radio_type ((u8 )bss_desc->bss_band); + +nxpwifi_dbg (priv->adapter,INFO ,"info: Assoc: TLV Band = %d\n" , + chan_tlv->chan_scan_param[0 ].radio_type); + pos +=sizeof (chan_tlv->header) + +sizeof (struct nxpwifi_chan_scan_param_set ); + } + +if (!priv->wps.session_enable) { +if (priv->sec_info.wpa_enabled || priv->sec_info.wpa2_enabled) + rsn_ie_len =nxpwifi_append_rsn_ie_wpa_wpa2 (priv, &pos); + +if (rsn_ie_len == -ENOMEM ) +return -ENOMEM ; + } + +if (ISSUPP_11NENABLED (priv->adapter->fw_cap_info) && + !bss_desc->disable_11n && + (priv->adapter->config_bands &BAND_GN || + priv->adapter->config_bands &BAND_AN )) +nxpwifi_cmd_append_11n_tlv (priv, bss_desc, &pos); + +if (ISSUPP_11ACENABLED (priv->adapter->fw_cap_info) && + !bss_desc->disable_11n && !bss_desc->disable_11ac && + priv->adapter->config_bands &BAND_AAC ) +nxpwifi_cmd_append_11ac_tlv (priv, bss_desc, &pos); + +/* Append vendor specific IE TLV */ +nxpwifi_cmd_append_vsie_tlv (priv,NXPWIFI_VSIE_MASK_ASSOC , &pos); + +nxpwifi_wmm_process_association_req (priv, &pos, &bss_desc->wmm_ie, + bss_desc->bcn_ht_cap); + +if (priv->wps.session_enable && priv->wps_ie_len) +nxpwifi_cmd_append_wps_ie (priv, &pos); + +nxpwifi_cmd_append_generic_ie (priv, &pos); + +nxpwifi_cmd_append_tsf_tlv (priv, &pos, bss_desc); + +nxpwifi_11h_process_join (priv, &pos, bss_desc); + + cmd->size =cpu_to_le16 ((u16)(pos - (u8 *)assoc) +S_DS_GEN ); + +/* Set the Capability info at last */ + tmp_cap = bss_desc->cap_info_bitmap; + +if (priv->adapter->config_bands ==BAND_B ) + tmp_cap &= ~WLAN_CAPABILITY_SHORT_SLOT_TIME ; + + tmp_cap &=CAPINFO_MASK ; +nxpwifi_dbg (priv->adapter,INFO , +"info: ASSOC_CMD: tmp_cap=%4X CAPINFO_MASK=%4lX\n" , + tmp_cap,CAPINFO_MASK ); + assoc->cap_info_bitmap =cpu_to_le16 (tmp_cap); + +return ret; +} + +static const char *assoc_failure_reason_to_str (u16 cap_info) +{ +switch (cap_info) { +case CONNECT_ERR_AUTH_ERR_STA_FAILURE : +return "CONNECT_ERR_AUTH_ERR_STA_FAILURE" ; +case CONNECT_ERR_AUTH_MSG_UNHANDLED : +return "CONNECT_ERR_AUTH_MSG_UNHANDLED" ; +case CONNECT_ERR_ASSOC_ERR_TIMEOUT : +return "CONNECT_ERR_ASSOC_ERR_TIMEOUT" ; +case CONNECT_ERR_ASSOC_ERR_AUTH_REFUSED : +return "CONNECT_ERR_ASSOC_ERR_AUTH_REFUSED" ; +case CONNECT_ERR_STA_FAILURE : +return "CONNECT_ERR_STA_FAILURE" ; + } + +return "Unknown connect failure" ; +} + +/* Association firmware command response handler +* +* The response buffer for the association command has the following +* memory layout. +* +* For cases where an association response was not received (indicated +* by the CapInfo and AId field): +* +* .------------------------------------------------------------. +* | Header(4 * sizeof(t_u16)): Standard command response hdr | +* .------------------------------------------------------------. +* | cap_info/Error Return(t_u16): | +* | 0xFFFF(-1): Internal error | +* | 0xFFFE(-2): Authentication unhandled message | +* | 0xFFFD(-3): Authentication refused | +* | 0xFFFC(-4): Timeout waiting for AP response | +* .------------------------------------------------------------. +* | status_code(t_u16): | +* | If cap_info is -1: | +* | An internal firmware failure prevented the | +* | command from being processed. The status_code | +* | will be set to 1. | +* | | +* | If cap_info is -2: | +* | An authentication frame was received but was | +* | not handled by the firmware. IEEE Status | +* | code for the failure is returned. | +* | | +* | If cap_info is -3: | +* | An authentication frame was received and the | +* | status_code is the IEEE Status reported in the | +* | response. | +* | | +* | If cap_info is -4: | +* | (1) Association response timeout | +* | (2) Authentication response timeout | +* .------------------------------------------------------------. +* | a_id(t_u16): 0xFFFF | +* .------------------------------------------------------------. +* +* +* For cases where an association response was received, the IEEE +* standard association response frame is returned: +* +* .------------------------------------------------------------. +* | Header(4 * sizeof(t_u16)): Standard command response hdr | +* .------------------------------------------------------------. +* | cap_info(t_u16): IEEE Capability | +* .------------------------------------------------------------. +* | status_code(t_u16): IEEE Status Code | +* .------------------------------------------------------------. +* | a_id(t_u16): IEEE Association ID | +* .------------------------------------------------------------. +* | IEEE IEs(variable): Any received IEs comprising the | +* | remaining portion of a received | +* | association response frame. | +* .------------------------------------------------------------. +* +* For simplistic handling, the status_code field can be used to determine +* an association success (0) or failure (non-zero). +*/ +int nxpwifi_ret_802_11_associate (struct nxpwifi_private *priv, +struct host_cmd_ds_command *resp) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +int ret =0 ; +struct ieee_types_assoc_rsp *assoc_rsp; +struct nxpwifi_bssdescriptor *bss_desc; +bool enable_data = true; +u16 cap_info, status_code, aid; +const u8 *ie_ptr; +struct ieee80211_ht_operation *assoc_resp_ht_oper; +struct ieee80211_mgmt *hdr; + +if (!priv->attempted_bss_desc) { +nxpwifi_dbg (priv->adapter,ERROR , +"%s: failed, association terminated by host\n" , + __func__); + goto done; + } + + hdr = (struct ieee80211_mgmt *)&resp->params; +if (!memcmp (hdr->bssid, priv->attempted_bss_desc->mac_address, +ETH_ALEN )) + assoc_rsp = (struct ieee_types_assoc_rsp *)&hdr->u.assoc_resp; +else + assoc_rsp = (struct ieee_types_assoc_rsp *)&resp->params; + + cap_info =le16_to_cpu (assoc_rsp->cap_info_bitmap); + status_code =le16_to_cpu (assoc_rsp->status_code); + aid =le16_to_cpu (assoc_rsp->a_id); + +if ((aid & (BIT (15 ) |BIT (14 ))) != (BIT (15 ) |BIT (14 ))) +dev_err (priv->adapter->dev, +"invalid AID value 0x%x; bits 15:14 not set\n" , + aid); + + aid &= ~(BIT (15 ) |BIT (14 )); + + priv->assoc_rsp_size =min (le16_to_cpu (resp->size) -S_DS_GEN , +sizeof (priv->assoc_rsp_buf)); + + assoc_rsp->a_id =cpu_to_le16 (aid); +memcpy (priv->assoc_rsp_buf, &resp->params, priv->assoc_rsp_size); + +if (status_code) { + priv->adapter->dbg.num_cmd_assoc_failure++; +nxpwifi_dbg (priv->adapter,ERROR , +"ASSOC_RESP: failed,\t" +"status code=%d err=%#x a_id=%#x\n" , + status_code, cap_info, +le16_to_cpu (assoc_rsp->a_id)); + +nxpwifi_dbg (priv->adapter,ERROR ,"assoc failure: reason %s\n" , +assoc_failure_reason_to_str (cap_info)); +if (cap_info ==CONNECT_ERR_ASSOC_ERR_TIMEOUT ) { +if (status_code ==NXPWIFI_ASSOC_CMD_FAILURE_AUTH ) { + ret =WLAN_STATUS_AUTH_TIMEOUT ; +nxpwifi_dbg (priv->adapter,ERROR , +"ASSOC_RESP: AUTH timeout\n" ); + }else { + ret =WLAN_STATUS_UNSPECIFIED_FAILURE ; +nxpwifi_dbg (priv->adapter,ERROR , +"ASSOC_RESP: UNSPECIFIED failure\n" ); + } + + priv->assoc_rsp_size =0 ; + }else { + ret = status_code; + } + + goto done; + } + +/* Send a Media Connected event, according to the Spec */ + priv->media_connected = true; + + priv->adapter->ps_state =PS_STATE_AWAKE ; + priv->adapter->pps_uapsd_mode = false; + priv->adapter->tx_lock_flag = false; + +/* Set the attempted BSSID Index to current */ + bss_desc = priv->attempted_bss_desc; + +nxpwifi_dbg (priv->adapter,INFO ,"info: ASSOC_RESP: %s\n" , + bss_desc->ssid.ssid); + +/* Make a copy of current BSSID descriptor */ +memcpy (&priv->curr_bss_params.bss_descriptor, + bss_desc,sizeof (struct nxpwifi_bssdescriptor )); + +/* Update curr_bss_params */ + priv->curr_bss_params.bss_descriptor.channel = + bss_desc->phy_param_set.ds_param_set.current_chan; + + priv->curr_bss_params.band = (u8 )bss_desc->bss_band; + +if (bss_desc->wmm_ie.element_id ==WLAN_EID_VENDOR_SPECIFIC ) + priv->curr_bss_params.wmm_enabled = true; +else + priv->curr_bss_params.wmm_enabled = false; + +if ((priv->wmm_required || bss_desc->bcn_ht_cap) && + priv->curr_bss_params.wmm_enabled) + priv->wmm_enabled = true; +else + priv->wmm_enabled = false; + + priv->curr_bss_params.wmm_uapsd_enabled = false; + +if (priv->wmm_enabled) + priv->curr_bss_params.wmm_uapsd_enabled = + ((bss_desc->wmm_ie.qos_info & +IEEE80211_WMM_IE_AP_QOSINFO_UAPSD ) ?1 :0 ); + +/* Store the bandwidth information from assoc response */ + ie_ptr =cfg80211_find_ie (WLAN_EID_HT_OPERATION , assoc_rsp->ie_buffer, + priv->assoc_rsp_size + -sizeof (struct ieee_types_assoc_rsp )); +if (ie_ptr) { + assoc_resp_ht_oper = (struct ieee80211_ht_operation *)(ie_ptr + +sizeof (struct element )); + priv->assoc_resp_ht_param = assoc_resp_ht_oper->ht_param; + priv->ht_param_present = true; + }else { + priv->ht_param_present = false; + } + +nxpwifi_dbg (priv->adapter,INFO , +"info: ASSOC_RESP: curr_pkt_filter is %#x\n" , + priv->curr_pkt_filter); +if (priv->sec_info.wpa_enabled || priv->sec_info.wpa2_enabled) + priv->wpa_is_gtk_set = false; + +if (priv->wmm_enabled) { +/* Don't re-enable carrier until we get the WMM_GET_STATUS +* event +*/ + enable_data = false; + }else { +/* Since WMM is not enabled, setup the queues with the +* defaults +*/ +nxpwifi_wmm_setup_queue_priorities (priv,NULL ); +nxpwifi_wmm_setup_ac_downgrade (priv); + } + +if (enable_data) +nxpwifi_dbg (priv->adapter,INFO , +"info: post association, re-enabling data flow\n" ); + +/* Reset SNR/NF/RSSI values */ + priv->data_rssi_last =0 ; + priv->data_nf_last =0 ; + priv->data_rssi_avg =0 ; + priv->data_nf_avg =0 ; + priv->bcn_rssi_last =0 ; + priv->bcn_nf_last =0 ; + priv->bcn_rssi_avg =0 ; + priv->bcn_nf_avg =0 ; + priv->rxpd_rate =0 ; + priv->rxpd_htinfo =0 ; + +nxpwifi_save_curr_bcn (priv); + + priv->adapter->dbg.num_cmd_assoc_success++; + +nxpwifi_dbg (priv->adapter,MSG ,"assoc: associated with %pM\n" , + priv->attempted_bss_desc->mac_address); + +/* Add the ra_list here for infra mode as there will be only 1 ra +* always +*/ +nxpwifi_ralist_add (priv, + priv->curr_bss_params.bss_descriptor.mac_address); + +if (!netif_carrier_ok (priv->netdev)) +netif_carrier_on (priv->netdev); +nxpwifi_wake_up_net_dev_queue (priv->netdev, adapter); + +if (priv->sec_info.wpa_enabled || priv->sec_info.wpa2_enabled) + priv->scan_block = true; +else + priv->port_open = true; + +done: +/* Need to indicate IOCTL complete */ +if (adapter->curr_cmd->wait_q_enabled) { +if (ret) + adapter->cmd_wait_q.status =-1 ; +else + adapter->cmd_wait_q.status =0 ; + } + +return ret; +} + +/* This function associates to a specific BSS discovered in a scan. +* +* It clears any past association response stored for application +* retrieval and calls the command preparation routine to send the +* command to firmware. +*/ +int nxpwifi_associate (struct nxpwifi_private *priv, +struct nxpwifi_bssdescriptor *bss_desc) +{ +/* Return error if the adapter is not STA role or table entry +* is not marked as infra. +*/ +if ((GET_BSS_ROLE (priv) !=NXPWIFI_BSS_ROLE_STA ) || + bss_desc->bss_mode !=NL80211_IFTYPE_STATION ) +return -EINVAL ; + +if (ISSUPP_11ACENABLED (priv->adapter->fw_cap_info) && + !bss_desc->disable_11n && !bss_desc->disable_11ac && + priv->adapter->config_bands &BAND_AAC ) +nxpwifi_set_11ac_ba_params (priv); +else +nxpwifi_set_ba_params (priv); + +/* Clear any past association response stored for application +* retrieval +*/ + priv->assoc_rsp_size =0 ; + +return nxpwifi_send_cmd (priv,HOST_CMD_802_11_ASSOCIATE , +HOST_ACT_GEN_SET ,0 , bss_desc, true); +} + +/* This function deauthenticates/disconnects from infra network by sending +* deauthentication request. +*/ +static int nxpwifi_deauthenticate_infra (struct nxpwifi_private *priv,u8 *mac) +{ +u8 mac_address[ETH_ALEN ]; +int ret; + +if (!mac ||is_zero_ether_addr (mac)) +memcpy (mac_address, + priv->curr_bss_params.bss_descriptor.mac_address, +ETH_ALEN ); +else +memcpy (mac_address, mac,ETH_ALEN ); + + ret =nxpwifi_send_cmd (priv,HOST_CMD_802_11_DEAUTHENTICATE , +HOST_ACT_GEN_SET ,0 , mac_address, true); + +return ret; +} + +/* This function deauthenticates/disconnects from a BSS. +* +* In case of infra made, it sends deauthentication request, and +* in case of ad-hoc mode, a stop network request is sent to the firmware. +* In AP mode, a command to stop bss is sent to firmware. +*/ +int nxpwifi_deauthenticate (struct nxpwifi_private *priv,u8 *mac) +{ +int ret =0 ; + +if (!priv->media_connected) +return 0 ; + + priv->auth_flag =0 ; + priv->auth_alg =WLAN_AUTH_NONE ; + priv->host_mlme_reg = false; + priv->mgmt_frame_mask =0 ; + + ret =nxpwifi_send_cmd (priv,HOST_CMD_MGMT_FRAME_REG , +HOST_ACT_GEN_SET ,0 , + &priv->mgmt_frame_mask, false); +if (ret) { +nxpwifi_dbg (priv->adapter,ERROR , +"could not unregister mgmt frame rx\n" ); +return ret; + } + +switch (priv->bss_mode) { +case NL80211_IFTYPE_STATION : + ret =nxpwifi_deauthenticate_infra (priv, mac); +if (ret) +cfg80211_disconnected (priv->netdev,0 ,NULL ,0 , + true,GFP_KERNEL ); +break ; +case NL80211_IFTYPE_AP : + ret =nxpwifi_send_cmd (priv,HOST_CMD_UAP_BSS_STOP , +HOST_ACT_GEN_SET ,0 ,NULL , true); +default : +break ; + } + +return ret; +} + +/* This function deauthenticates/disconnects from all BSS. */ +void nxpwifi_deauthenticate_all (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +int i; + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv) +nxpwifi_deauthenticate (priv,NULL ); + } +} +EXPORT_SYMBOL_GPL (nxpwifi_deauthenticate_all); + +/* This function converts band to radio type used in channel TLV. +*/ +u8 +nxpwifi_band_to_radio_type (u8 band) +{ +switch (band) { +case BAND_A : +case BAND_AN : +case BAND_A |BAND_AN : +case BAND_A |BAND_AN |BAND_AAC : +return HOST_SCAN_RADIO_TYPE_A ; +case BAND_B : +case BAND_G : +case BAND_B |BAND_G : +default : +return HOST_SCAN_RADIO_TYPE_BG ; + } +}
Signature · 1 line
2.34.1
PATCH v2 23/43 wifi: nxpwifi: add main.c
In reply to David Lin--- drivers/net/wireless/nxp/nxpwifi/main.c | 1666 +++++++++++++++++++++++ 1 file changed, 1666 insertions(+) create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.c
drivers/net/wireless/nxp/nxpwifi/main.c new file +1666 -0
@@ -0,0 +1,1666 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* NXP Wireless LAN device driver: major functions +* +* Copyright 2011-2024 NXP +*/ + +#include <linux/suspend.h> + +#include "main.h" +#include "cmdevt.h" +#include "wmm.h" +#include "cfg80211.h" +#include "11n.h" + +#define VERSION "1.0" + +static unsigned int debug_mask =NXPWIFI_DEFAULT_DEBUG_MASK ; + +char driver_version[] ="nxpwifi " VERSION " (%s) " ; + +const u16 nxpwifi_1d_to_wmm_queue[8 ] = {1 ,0 ,0 ,1 ,2 ,2 ,3 ,3 }; + +/* This function registers the device and performs all the necessary +* initializations. +* +* The following initialization operations are performed - +* - Allocate adapter structure +* - Save interface specific operations table in adapter +* - Call interface specific initialization routine +* - Allocate private structures +* - Set default adapter structure parameters +* - Initialize locks +* +* In case of any errors during initialization, this function also ensures +* proper cleanup before exiting. +*/ +static struct nxpwifi_adapter *nxpwifi_register (void *card,struct device *dev, +struct nxpwifi_if_ops *if_ops) +{ +struct nxpwifi_adapter *adapter; +int ret =0 ; +int i; + + adapter =kzalloc (sizeof (*adapter),GFP_KERNEL ); +if (!adapter) +return ERR_PTR (-ENOMEM ); + + adapter->dev = dev; + adapter->card = card; + +/* Save interface specific operations in adapter */ +memmove (&adapter->if_ops, if_ops,sizeof (struct nxpwifi_if_ops )); + adapter->debug_mask = debug_mask; + +/* card specific initialization has been deferred until now .. */ +if (adapter->if_ops.init_if) { + ret = adapter->if_ops.init_if (adapter); +if (ret) + goto error; + } + + adapter->priv_num =0 ; + +for (i =0 ; i <NXPWIFI_MAX_BSS_NUM ; i++) { +/* Allocate memory for private structure */ + adapter->priv[i] = +kzalloc (sizeof (struct nxpwifi_private ),GFP_KERNEL ); +if (!adapter->priv[i]) { + ret = -ENOMEM ; + goto error; + } + + adapter->priv[i]->adapter = adapter; + adapter->priv_num++; + } +nxpwifi_init_lock_list (adapter); + +timer_setup (&adapter->cmd_timer, nxpwifi_cmd_timeout_func,0 ); + +if (ret) +return ERR_PTR (ret); +else +return adapter; + +error: +nxpwifi_dbg (adapter,ERROR , +"info: leave %s with error\n" , __func__); + +for (i =0 ; i < adapter->priv_num; i++) +kfree (adapter->priv[i]); + +kfree (adapter); + +return ERR_PTR (ret); +} + +/* This function unregisters the device and performs all the necessary +* cleanups. +* +* The following cleanup operations are performed - +* - Free the timers +* - Free beacon buffers +* - Free private structures +* - Free adapter structure +*/ +static void nxpwifi_unregister (struct nxpwifi_adapter *adapter) +{ +s32 i; + +if (adapter->if_ops.cleanup_if) + adapter->if_ops.cleanup_if (adapter); + +del_timer_sync (&adapter->cmd_timer); + +/* Free private structures */ +for (i =0 ; i < adapter->priv_num; i++) { +if (adapter->priv[i]) { +nxpwifi_free_curr_bcn (adapter->priv[i]); +kfree (adapter->priv[i]); + } + } + +if (adapter->nd_info) { +for (i =0 ; i < adapter->nd_info->n_matches ; i++) +kfree (adapter->nd_info->matches[i]); +kfree (adapter->nd_info); + adapter->nd_info =NULL ; + } + +kfree (adapter->regd); + +kfree (adapter); +} + +static void nxpwifi_process_rx (struct nxpwifi_adapter *adapter) +{ +struct sk_buff *skb; +struct nxpwifi_rxinfo *rx_info; + +/* Check for Rx data */ +while ((skb =skb_dequeue (&adapter->rx_data_q))) { + rx_info =NXPWIFI_SKB_RXCB (skb); +if (rx_info->buf_type ==NXPWIFI_TYPE_AGGR_DATA ) { +if (adapter->if_ops.deaggr_pkt) + adapter->if_ops.deaggr_pkt (adapter, skb); +dev_kfree_skb_any (skb); + }else { +nxpwifi_handle_rx_packet (adapter, skb); + } + } +} + +static void maybe_quirk_fw_disable_ds (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ); +struct nxpwifi_ver_ext ver_ext; + +if (test_and_set_bit (NXPWIFI_IS_REQUESTING_FW_VEREXT , &adapter->work_flags)) +return ; + +memset (&ver_ext,0 ,sizeof (ver_ext)); + ver_ext.version_str_sel =1 ; +if (nxpwifi_send_cmd (priv,HOST_CMD_VERSION_EXT , +HOST_ACT_GEN_GET ,0 , &ver_ext, false)) { +nxpwifi_dbg (priv->adapter,MSG , +"Checking hardware revision failed.\n" ); + } +} + +/* The main process. +* +* This function is the main procedure of the driver and handles various driver +* operations. It runs in a loop and provides the core functionalities. +* +* The main responsibilities of this function are - +* - Ensure concurrency control +* - Handle pending interrupts and call interrupt handlers +* - Wake up the card if required +* - Handle command responses and call response handlers +* - Handle events and call event handlers +* - Execute pending commands +* - Transmit pending data packets +*/ +void nxpwifi_main_process (struct nxpwifi_adapter *adapter) +{ +unsigned long flags; + +spin_lock_irqsave (&adapter->main_proc_lock, flags); + +/* Check if already processing */ +if (adapter->nxpwifi_processing || adapter->main_locked) { + adapter->more_task_flag = true; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); +return ; + } + + adapter->nxpwifi_processing = true; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + +process_start: +do { +if (adapter->hw_status ==NXPWIFI_HW_STATUS_NOT_READY ) +break ; + +/* Handle pending interrupt if any */ +if (adapter->int_status) { +if (adapter->hs_activated) +nxpwifi_process_hs_config (adapter); +if (adapter->if_ops.process_int_status) + adapter->if_ops.process_int_status (adapter); + } + +/* Need to wake up the card ? */ +if (adapter->ps_state ==PS_STATE_SLEEP && + (adapter->pm_wakeup_card_req && + !adapter->pm_wakeup_fw_try) && + (is_command_pending (adapter) || + !skb_queue_empty (&adapter->tx_data_q) || + !nxpwifi_bypass_txlist_empty (adapter) || + !nxpwifi_wmm_lists_empty (adapter))) { + adapter->pm_wakeup_fw_try = true; +mod_timer (&adapter->wakeup_timer, jiffies + (HZ *3 )); + adapter->if_ops.wakeup (adapter); +continue ; + } + +if (IS_CARD_RX_RCVD (adapter)) { + adapter->data_received = false; + adapter->pm_wakeup_fw_try = false; +del_timer (&adapter->wakeup_timer); +if (adapter->ps_state ==PS_STATE_SLEEP ) + adapter->ps_state =PS_STATE_AWAKE ; + }else { +/* We have tried to wakeup the card already */ +if (adapter->pm_wakeup_fw_try) +break ; +if (adapter->ps_state ==PS_STATE_PRE_SLEEP ) +nxpwifi_check_ps_cond (adapter); + +if (adapter->ps_state !=PS_STATE_AWAKE ) +break ; +if (adapter->tx_lock_flag) +break ; + +if ((!adapter->scan_chan_gap_enabled && + adapter->scan_processing) || adapter->data_sent || + (nxpwifi_wmm_lists_empty (adapter) && +nxpwifi_bypass_txlist_empty (adapter) && +skb_queue_empty (&adapter->tx_data_q))) { +if (adapter->cmd_sent || adapter->curr_cmd || + (!is_command_pending (adapter))) +break ; + } + } + +/* Check for event */ +if (adapter->event_received) { + adapter->event_received = false; +nxpwifi_process_event (adapter); + } + +/* Check for Cmd Resp */ +if (adapter->cmd_resp_received) { + adapter->cmd_resp_received = false; +nxpwifi_process_cmdresp (adapter); + +/* call nxpwifi back when init_fw is done */ +if (adapter->hw_status ==NXPWIFI_HW_STATUS_INIT_DONE ) { + adapter->hw_status =NXPWIFI_HW_STATUS_READY ; +nxpwifi_init_fw_complete (adapter); +maybe_quirk_fw_disable_ds (adapter); + } + } + +/* Check if we need to confirm Sleep Request +* received previously +*/ +if (adapter->ps_state ==PS_STATE_PRE_SLEEP ) +nxpwifi_check_ps_cond (adapter); + +/* * The ps_state may have been changed during processing of +* Sleep Request event. +*/ +if (adapter->ps_state ==PS_STATE_SLEEP || + adapter->ps_state ==PS_STATE_PRE_SLEEP || + adapter->ps_state ==PS_STATE_SLEEP_CFM ) { +continue ; + } + +if (adapter->tx_lock_flag) +continue ; + +if (!adapter->cmd_sent && + adapter->vdll_ctrl.pending_block) { +struct vdll_dnld_ctrl *ctrl = &adapter->vdll_ctrl; + +nxpwifi_download_vdll_block (adapter, ctrl->pending_block, + ctrl->pending_block_len); + ctrl->pending_block =NULL ; + } + +if (!adapter->cmd_sent && !adapter->curr_cmd) { +if (nxpwifi_exec_next_cmd (adapter)) +break ; + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && + !skb_queue_empty (&adapter->tx_data_q)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_process_tx_queue (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && + !nxpwifi_bypass_txlist_empty (adapter)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_process_bypass_tx (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if ((adapter->scan_chan_gap_enabled || + !adapter->scan_processing) && + !adapter->data_sent && !nxpwifi_wmm_lists_empty (adapter)) { +if (adapter->hs_activated_manually) { +nxpwifi_cancel_hs (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ), +NXPWIFI_ASYNC_CMD ); + adapter->hs_activated_manually = false; + } + +nxpwifi_wmm_process_tx (adapter); +if (adapter->hs_activated) { +clear_bit (NXPWIFI_IS_HS_CONFIGURED , + &adapter->work_flags); +nxpwifi_hs_activated_event + (nxpwifi_get_priv + (adapter,NXPWIFI_BSS_ROLE_ANY ), + false); + } + } + +if (adapter->delay_null_pkt && !adapter->cmd_sent && + !adapter->curr_cmd && !is_command_pending (adapter) && + (nxpwifi_wmm_lists_empty (adapter) && +nxpwifi_bypass_txlist_empty (adapter) && +skb_queue_empty (&adapter->tx_data_q))) { +if (!nxpwifi_send_null_packet + (nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_STA ), + NXPWIFI_TxPD_POWER_MGMT_NULL_PACKET | + NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET)) { + adapter->delay_null_pkt = false; + adapter->ps_state =PS_STATE_SLEEP ; + } +break ; + } + }while (true); + +spin_lock_irqsave (&adapter->main_proc_lock, flags); +if (adapter->more_task_flag) { + adapter->more_task_flag = false; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); + goto process_start; + } + adapter->nxpwifi_processing = false; +spin_unlock_irqrestore (&adapter->main_proc_lock, flags); +} +EXPORT_SYMBOL_GPL (nxpwifi_main_process); + +/* This function frees the adapter structure. +* +* Additionally, this closes the netlink socket, frees the timers +* and private structures. +*/ +static void nxpwifi_free_adapter (struct nxpwifi_adapter *adapter) +{ +if (!adapter) { +pr_err ("%s: adapter is NULL\n" , __func__); +return ; + } + +nxpwifi_unregister (adapter); +pr_debug ("info: %s: free adapter\n" , __func__); +} + +/* This function cancels all works in the queue and destroys +* the main workqueue. +*/ +static void nxpwifi_terminate_workqueue (struct nxpwifi_adapter *adapter) +{ +if (adapter->workqueue) { +destroy_workqueue (adapter->workqueue); + adapter->workqueue =NULL ; + } +} + +/* This function gets firmware and initializes it. +* +* The main initialization steps followed are - +* - Download the correct firmware to card +* - Issue the init commands to firmware +*/ +static int _nxpwifi_fw_dpc (const struct firmware *firmware,void *context) +{ +int ret =0 ; +char fmt[64 ]; +struct nxpwifi_adapter *adapter = context; +struct nxpwifi_fw_image fw; +bool init_failed = false; +struct wireless_dev *wdev; +struct completion *fw_done = adapter->fw_done; + +if (!firmware) { +nxpwifi_dbg (adapter,ERROR , +"Failed to get firmware %s\n" , adapter->fw_name); + ret = -EINVAL ; + goto err_dnld_fw; + } + +memset (&fw,0 ,sizeof (struct nxpwifi_fw_image )); + adapter->firmware = firmware; + fw.fw_buf = (u8 *)adapter->firmware->data; + fw.fw_len = adapter->firmware->size; + +if (adapter->if_ops.dnld_fw) + ret = adapter->if_ops.dnld_fw (adapter, &fw); +else + ret =nxpwifi_dnld_fw (adapter, &fw); + +if (ret) + goto err_dnld_fw; + +nxpwifi_dbg (adapter,MSG ,"WLAN FW is active\n" ); + +/* enable host interrupt after fw dnld is successful */ +if (adapter->if_ops.enable_int) { + ret = adapter->if_ops.enable_int (adapter); +if (ret) + goto err_dnld_fw; + } + + adapter->init_wait_q_woken = false; + ret =nxpwifi_init_fw (adapter); +if (ret != -EINPROGRESS ) { + goto err_init_fw; + }else if (!ret) { + adapter->hw_status =NXPWIFI_HW_STATUS_READY ; + goto done; + } +/* Wait for nxpwifi_init to complete */ +wait_event_interruptible (adapter->init_wait_q, + adapter->init_wait_q_woken); +if (adapter->hw_status !=NXPWIFI_HW_STATUS_READY ) + goto err_init_fw; + +if (!adapter->wiphy) { +if (nxpwifi_register_cfg80211 (adapter)) { +nxpwifi_dbg (adapter,ERROR , +"cannot register with cfg80211\n" ); + goto err_init_fw; + } + } + +if (nxpwifi_init_channel_scan_gap (adapter)) { +nxpwifi_dbg (adapter,ERROR , +"could not init channel stats table\n" ); + goto err_init_chan_scan; + } + +rtnl_lock (); +wiphy_lock (adapter->wiphy); +/* Create station interface by default */ + wdev =nxpwifi_add_virtual_intf (adapter->wiphy,"mlan%d" ,NET_NAME_ENUM , +NL80211_IFTYPE_STATION ,NULL ); +if (IS_ERR (wdev)) { +nxpwifi_dbg (adapter,ERROR , +"cannot create default STA interface\n" ); +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + goto err_add_intf; + } + + wdev =nxpwifi_add_virtual_intf (adapter->wiphy,"uap%d" ,NET_NAME_ENUM , +NL80211_IFTYPE_AP ,NULL ); +if (IS_ERR (wdev)) { +nxpwifi_dbg (adapter,ERROR , +"cannot create AP interface\n" ); +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + goto err_add_intf; + } + +wiphy_unlock (adapter->wiphy); +rtnl_unlock (); + +nxpwifi_drv_get_driver_version (adapter, fmt,sizeof (fmt) -1 ); +nxpwifi_dbg (adapter,MSG ,"driver_version = %s\n" , fmt); + adapter->is_up = true; + goto done; + +err_add_intf: +vfree (adapter->chan_stats); +err_init_chan_scan: +wiphy_unregister (adapter->wiphy); +wiphy_free (adapter->wiphy); +err_init_fw: +if (adapter->if_ops.disable_int) + adapter->if_ops.disable_int (adapter); +err_dnld_fw: +nxpwifi_dbg (adapter,ERROR , +"info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); + +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +tasklet_kill (&adapter->rx_task); +nxpwifi_terminate_workqueue (adapter); + +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +pr_debug ("info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } + + init_failed = true; +done: +if (adapter->cal_data) { +release_firmware (adapter->cal_data); + adapter->cal_data =NULL ; + } +if (adapter->firmware) { +release_firmware (adapter->firmware); + adapter->firmware =NULL ; + } +if (init_failed) { +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); +nxpwifi_free_adapter (adapter); + } +/* Tell all current and future waiters we're finished */ +complete_all (fw_done); + +return ret; +} + +static void nxpwifi_fw_dpc (const struct firmware *firmware,void *context) +{ +_nxpwifi_fw_dpc (firmware, context); +} + +/* This function gets the firmware and (if called asynchronously) kicks off the +* HW init when done. +*/ +static int nxpwifi_init_hw_fw (struct nxpwifi_adapter *adapter, +bool req_fw_nowait) +{ +int ret; + +if (req_fw_nowait) { + ret =request_firmware_nowait (THIS_MODULE ,1 , adapter->fw_name, + adapter->dev,GFP_KERNEL , adapter, + nxpwifi_fw_dpc); + }else { + ret =request_firmware (&adapter->firmware, + adapter->fw_name, + adapter->dev); + } + +if (ret <0 ) +nxpwifi_dbg (adapter,ERROR ,"request_firmware%s error %d\n" , + req_fw_nowait ?"_nowait" :"" , ret); +return ret; +} + +/* CFG802.11 network device handler for open. +* +* Starts the data queue. +*/ +static int +nxpwifi_open (struct net_device *dev) +{ +netif_carrier_off (dev); + +return 0 ; +} + +/* CFG802.11 network device handler for close. +*/ +static int +nxpwifi_close (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +if (priv->scan_request) { +struct cfg80211_scan_info info = { + .aborted = true, + }; + +nxpwifi_dbg (priv->adapter,INFO , +"aborting scan on ndo_stop\n" ); +cfg80211_scan_done (priv->scan_request, &info); + priv->scan_request =NULL ; + priv->scan_aborting = true; + } + +if (priv->sched_scanning) { +nxpwifi_dbg (priv->adapter,INFO , +"aborting bgscan on ndo_stop\n" ); +nxpwifi_stop_bg_scan (priv); +cfg80211_sched_scan_stopped (priv->wdev.wiphy,0 ); + } + +return 0 ; +} + +static bool +nxpwifi_bypass_tx_queue (struct nxpwifi_private *priv, +struct sk_buff *skb) +{ +struct ethhdr *eth_hdr = (struct ethhdr *)skb->data; + +if (eth_hdr->h_proto ==htons (ETH_P_PAE ) || +nxpwifi_is_skb_mgmt_frame (skb)) { +nxpwifi_dbg (priv->adapter,DATA , +"bypass txqueue; eth type %#x, mgmt %d\n" , +ntohs (eth_hdr->h_proto), +nxpwifi_is_skb_mgmt_frame (skb)); +if (eth_hdr->h_proto ==htons (ETH_P_PAE )) +nxpwifi_dbg (priv->adapter,MSG , +"key: send EAPOL to %pM\n" , + eth_hdr->h_dest); +return true; + } + +return false; +} + +/* Add buffer into wmm tx queue and queue work to transmit it. +*/ +void nxpwifi_queue_tx_pkt (struct nxpwifi_private *priv,struct sk_buff *skb) +{ +struct nxpwifi_adapter *adapter = priv->adapter; +struct netdev_queue *txq; +int index = nxpwifi_1d_to_wmm_queue[skb->priority]; + +if (atomic_inc_return (&priv->wmm_tx_pending[index]) >=MAX_TX_PENDING ) { + txq =netdev_get_tx_queue (priv->netdev, index); +if (!netif_tx_queue_stopped (txq)) { +netif_tx_stop_queue (txq); +nxpwifi_dbg (adapter,DATA , +"stop queue: %d\n" , index); + } + } + +if (nxpwifi_bypass_tx_queue (priv, skb)) { +atomic_inc (&adapter->tx_pending); +atomic_inc (&adapter->bypass_tx_pending); +nxpwifi_wmm_add_buf_bypass_txqueue (priv, skb); + }else { +atomic_inc (&adapter->tx_pending); +nxpwifi_wmm_add_buf_txqueue (priv, skb); + } + +nxpwifi_queue_work (adapter, &adapter->main_work); +} + +struct sk_buff * +nxpwifi_clone_skb_for_tx_status (struct nxpwifi_private *priv, +struct sk_buff *skb,u8 flag,u64 *cookie) +{ +struct sk_buff *orig_skb = skb; +struct nxpwifi_txinfo *tx_info, *orig_tx_info; + + skb =skb_clone (skb,GFP_ATOMIC ); +if (skb) { +int id; + +spin_lock_bh (&priv->ack_status_lock); + id =idr_alloc (&priv->ack_status_frames, orig_skb, +1 ,0x10 ,GFP_ATOMIC ); +spin_unlock_bh (&priv->ack_status_lock); + +if (id >=0 ) { + tx_info =NXPWIFI_SKB_TXCB (skb); + tx_info->ack_frame_id = id; + tx_info->flags |= flag; + orig_tx_info =NXPWIFI_SKB_TXCB (orig_skb); + orig_tx_info->ack_frame_id = id; + orig_tx_info->flags |= flag; + +if (flag ==NXPWIFI_BUF_FLAG_ACTION_TX_STATUS && cookie) + orig_tx_info->cookie = *cookie; + + }else if (skb_shared (skb)) { +kfree_skb (orig_skb); + }else { +kfree_skb (skb); + skb = orig_skb; + } + }else { +/* couldn't clone -- lose tx status ... */ + skb = orig_skb; + } + +return skb; +} + +/* CFG802.11 network device handler for data transmission. +*/ +static netdev_tx_t +nxpwifi_hard_start_xmit (struct sk_buff *skb,struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct sk_buff *new_skb; +struct nxpwifi_txinfo *tx_info; +bool multicast; + +nxpwifi_dbg (priv->adapter,DATA , +"data: %lu BSS(%d-%d): Data <= kernel\n" , + jiffies, priv->bss_type, priv->bss_num); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &priv->adapter->work_flags)) { +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +if (!skb->len || skb->len >ETH_FRAME_LEN ) { +nxpwifi_dbg (priv->adapter,ERROR , +"Tx: bad skb len %d\n" , skb->len); +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +if (skb_headroom (skb) <NXPWIFI_MIN_DATA_HEADER_LEN ) { +nxpwifi_dbg (priv->adapter,DATA , +"data: Tx: insufficient skb headroom %d\n" , +skb_headroom (skb)); +/* Insufficient skb headroom - allocate a new skb */ + new_skb = +skb_realloc_headroom (skb,NXPWIFI_MIN_DATA_HEADER_LEN ); +if (unlikely (!new_skb)) { +nxpwifi_dbg (priv->adapter,ERROR , +"Tx: cannot alloca new_skb\n" ); +kfree_skb (skb); + priv->stats.tx_dropped++; +return 0 ; + } +kfree_skb (skb); + skb = new_skb; +nxpwifi_dbg (priv->adapter,INFO , +"info: new skb headroomd %d\n" , +skb_headroom (skb)); + } + + tx_info =NXPWIFI_SKB_TXCB (skb); +memset (tx_info,0 ,sizeof (*tx_info)); + tx_info->bss_num = priv->bss_num; + tx_info->bss_type = priv->bss_type; + tx_info->pkt_len = skb->len; + + multicast =is_multicast_ether_addr (skb->data); + +if (unlikely (!multicast && skb->sk && +skb_shinfo (skb)->tx_flags &SKBTX_WIFI_STATUS && + priv->adapter->fw_api_ver ==NXPWIFI_FW_V15 )) + skb =nxpwifi_clone_skb_for_tx_status (priv, + skb, +NXPWIFI_BUF_FLAG_EAPOL_TX_STATUS ,NULL ); + +/* Record the current time the packet was queued; used to +* determine the amount of time the packet was queued in +* the driver before it was sent to the firmware. +* The delay is then sent along with the packet to the +* firmware for aggregate delay calculation for stats and +* MSDU lifetime expiry. +*/ +__net_timestamp (skb); + +nxpwifi_queue_tx_pkt (priv, skb); + +return 0 ; +} + +int nxpwifi_set_mac_address (struct nxpwifi_private *priv, +struct net_device *dev,bool external, +u8 *new_mac) +{ +int ret; +u64 mac_addr, old_mac_addr; + + old_mac_addr =ether_addr_to_u64 (priv->curr_addr); + +if (external) { + mac_addr =ether_addr_to_u64 (new_mac); + }else { +/* Internal mac address change */ +if (priv->bss_type ==NXPWIFI_BSS_TYPE_ANY ) +return -EOPNOTSUPP ; + + mac_addr = old_mac_addr; + +if (priv->adapter->priv[0 ] != priv) { +/* Set mac address based on bss_type/bss_num */ + mac_addr ^=BIT_ULL (priv->bss_type +8 ); + mac_addr += priv->bss_num; + } + } + +u64_to_ether_addr (mac_addr, priv->curr_addr); + +/* Send request to firmware */ + ret =nxpwifi_send_cmd (priv,HOST_CMD_802_11_MAC_ADDRESS , +HOST_ACT_GEN_SET ,0 ,NULL , true); + +if (ret) { +u64_to_ether_addr (old_mac_addr, priv->curr_addr); +nxpwifi_dbg (priv->adapter,ERROR , +"set mac address failed: ret=%d\n" , ret); +return ret; + } + +eth_hw_addr_set (dev, priv->curr_addr); +return 0 ; +} + +/* CFG802.11 network device handler for setting MAC address. +*/ +static int +nxpwifi_ndo_set_mac_address (struct net_device *dev,void *addr) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct sockaddr *hw_addr = addr; + +return nxpwifi_set_mac_address (priv, dev, true, hw_addr->sa_data); +} + +/* CFG802.11 network device handler for setting multicast list. +*/ +static void nxpwifi_set_multicast_list (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); +struct nxpwifi_multicast_list mcast_list; + +if (dev->flags &IFF_PROMISC ) { + mcast_list.mode =NXPWIFI_PROMISC_MODE ; + }else if (dev->flags &IFF_ALLMULTI || +netdev_mc_count (dev) >NXPWIFI_MAX_MULTICAST_LIST_SIZE ) { + mcast_list.mode =NXPWIFI_ALL_MULTI_MODE ; + }else { + mcast_list.mode =NXPWIFI_MULTICAST_MODE ; + mcast_list.num_multicast_addr = +nxpwifi_copy_mcast_addr (&mcast_list, dev); + } +nxpwifi_request_set_multicast_list (priv, &mcast_list); +} + +/* CFG802.11 network device handler for transmission timeout. +*/ +static void +nxpwifi_tx_timeout (struct net_device *dev,unsigned int txqueue) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + + priv->num_tx_timeout++; + priv->tx_timeout_cnt++; +nxpwifi_dbg (priv->adapter,ERROR , +"%lu : Tx timeout(#%d), bss_type-num = %d-%d\n" , + jiffies, priv->tx_timeout_cnt, priv->bss_type, + priv->bss_num); +nxpwifi_set_trans_start (dev); + +if (priv->tx_timeout_cnt >TX_TIMEOUT_THRESHOLD && + priv->adapter->if_ops.card_reset) { +nxpwifi_dbg (priv->adapter,ERROR , +"tx_timeout_cnt exceeds threshold.\t" +"Triggering card reset!\n" ); + priv->adapter->if_ops.card_reset (priv->adapter); + } +} + +void nxpwifi_upload_device_dump (struct nxpwifi_adapter *adapter) +{ +/* Dump all the memory data into single file, a userspace script will +* be used to split all the memory data to multiple files +*/ +nxpwifi_dbg (adapter,MSG , +"== nxpwifi dump information to /sys/class/devcoredump start\n" ); +dev_coredumpv (adapter->dev, adapter->devdump_data, adapter->devdump_len, +GFP_KERNEL ); +nxpwifi_dbg (adapter,MSG , +"== nxpwifi dump information to /sys/class/devcoredump end\n" ); + +/* Device dump data will be freed in device coredump release function +* after 5 min. Here reset adapter->devdump_data and ->devdump_len +* to avoid it been accidentally reused. +*/ + adapter->devdump_data =NULL ; + adapter->devdump_len =0 ; +} +EXPORT_SYMBOL_GPL (nxpwifi_upload_device_dump); + +void nxpwifi_drv_info_dump (struct nxpwifi_adapter *adapter) +{ +char *p; +char drv_version[64 ]; +struct sdio_mmc_card *sdio_card; +struct nxpwifi_private *priv; +int i, idx; +struct netdev_queue *txq; +struct nxpwifi_debug_info *debug_info; + +nxpwifi_dbg (adapter,MSG ,"===nxpwifi driverinfo dump start===\n" ); + + p = adapter->devdump_data; +strscpy (p,"========Start dump driverinfo========\n" ,NXPWIFI_FW_DUMP_SIZE ); + p +=strlen ("========Start dump driverinfo========\n" ); + p +=sprintf (p,"driver_name = " ); + p +=sprintf (p,"\"nxpwifi\"\n" ); + +nxpwifi_drv_get_driver_version (adapter, drv_version, +sizeof (drv_version) -1 ); + p +=sprintf (p,"driver_version = %s\n" , drv_version); + + p +=sprintf (p,"tx_pending = %d\n" , +atomic_read (&adapter->tx_pending)); + +if (adapter->iface_type ==NXPWIFI_SDIO ) { + sdio_card = (struct sdio_mmc_card *)adapter->card; + p +=sprintf (p,"\nmp_rd_bitmap=0x%x curr_rd_port=0x%x\n" , + sdio_card->mp_rd_bitmap, sdio_card->curr_rd_port); + p +=sprintf (p,"mp_wr_bitmap=0x%x curr_wr_port=0x%x\n" , + sdio_card->mp_wr_bitmap, sdio_card->curr_wr_port); + } + +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i] || !adapter->priv[i]->netdev) +continue ; + priv = adapter->priv[i]; + p +=sprintf (p,"\n[interface : \"%s\"]\n" , + priv->netdev->name); + p +=sprintf (p,"wmm_tx_pending[0] = %d\n" , +atomic_read (&priv->wmm_tx_pending[0 ])); + p +=sprintf (p,"wmm_tx_pending[1] = %d\n" , +atomic_read (&priv->wmm_tx_pending[1 ])); + p +=sprintf (p,"wmm_tx_pending[2] = %d\n" , +atomic_read (&priv->wmm_tx_pending[2 ])); + p +=sprintf (p,"wmm_tx_pending[3] = %d\n" , +atomic_read (&priv->wmm_tx_pending[3 ])); + p +=sprintf (p,"media_state=\"%s\"\n" , !priv->media_connected ? +"Disconnected" :"Connected" ); + p +=sprintf (p,"carrier %s\n" , (netif_carrier_ok (priv->netdev) + ?"on" :"off" )); +for (idx =0 ; idx < priv->netdev->num_tx_queues; idx++) { + txq =netdev_get_tx_queue (priv->netdev, idx); + p +=sprintf (p,"tx queue %d:%s " , idx, +netif_tx_queue_stopped (txq) ? +"stopped" :"started" ); + } + p +=sprintf (p,"\n%s: num_tx_timeout = %d\n" , + priv->netdev->name, priv->num_tx_timeout); + } + +if (adapter->iface_type ==NXPWIFI_SDIO ) { + p +=sprintf (p,"\n=== %s register dump===\n" ,"SDIO" ); +if (adapter->if_ops.reg_dump) + p += adapter->if_ops.reg_dump (adapter, p); + } + p +=sprintf (p,"\n=== more debug information\n" ); + debug_info =kzalloc (sizeof (*debug_info),GFP_KERNEL ); +if (debug_info) { +for (i =0 ; i < adapter->priv_num; i++) { +if (!adapter->priv[i] || !adapter->priv[i]->netdev) +continue ; + priv = adapter->priv[i]; +nxpwifi_get_debug_info (priv, debug_info); + p +=nxpwifi_debug_info_to_buffer (priv, p, debug_info); +break ; + } +kfree (debug_info); + } + + p +=sprintf (p,"\n========End dump========\n" ); +nxpwifi_dbg (adapter,MSG ,"===nxpwifi driverinfo dump end===\n" ); + adapter->devdump_len = p - (char *)adapter->devdump_data; +} +EXPORT_SYMBOL_GPL (nxpwifi_drv_info_dump); + +void nxpwifi_prepare_fw_dump_info (struct nxpwifi_adapter *adapter) +{ +u8 idx; +char *fw_dump_ptr; +u32 dump_len =0 ; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +if (entry->mem_ptr) { + dump_len += (strlen ("========Start dump " ) + +strlen (entry->mem_name) + +strlen ("========\n" ) + + (entry->mem_size +1 ) + +strlen ("\n========End dump========\n" )); + } + } + +if (dump_len +1 + adapter->devdump_len >NXPWIFI_FW_DUMP_SIZE ) { +/* Realloc in case buffer overflow */ + fw_dump_ptr =vzalloc (dump_len +1 + adapter->devdump_len); +nxpwifi_dbg (adapter,MSG ,"Realloc device dump data.\n" ); +if (!fw_dump_ptr) { +vfree (adapter->devdump_data); +nxpwifi_dbg (adapter,ERROR , +"vzalloc devdump data failure!\n" ); +return ; + } + +memmove (fw_dump_ptr, adapter->devdump_data, + adapter->devdump_len); +vfree (adapter->devdump_data); + adapter->devdump_data = fw_dump_ptr; + } + + fw_dump_ptr = (char *)adapter->devdump_data + adapter->devdump_len; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +if (entry->mem_ptr) { + fw_dump_ptr +=sprintf (fw_dump_ptr,"========Start dump " ); + fw_dump_ptr +=sprintf (fw_dump_ptr,"%s" , entry->mem_name); + fw_dump_ptr +=sprintf (fw_dump_ptr,"========\n" ); +memcpy (fw_dump_ptr, entry->mem_ptr, entry->mem_size); + fw_dump_ptr += entry->mem_size; + fw_dump_ptr +=sprintf (fw_dump_ptr,"\n========End dump========\n" ); + } + } + + adapter->devdump_len = fw_dump_ptr - (char *)adapter->devdump_data; + +for (idx =0 ; idx < adapter->num_mem_types; idx++) { +struct memory_type_mapping *entry = + &adapter->mem_type_mapping_tbl[idx]; + +vfree (entry->mem_ptr); + entry->mem_ptr =NULL ; + entry->mem_size =0 ; + } +} +EXPORT_SYMBOL_GPL (nxpwifi_prepare_fw_dump_info); + +/* CFG802.11 network device handler for statistics retrieval. +*/ +static struct net_device_stats *nxpwifi_get_stats (struct net_device *dev) +{ +struct nxpwifi_private *priv =nxpwifi_netdev_get_priv (dev); + +return &priv->stats; +} + +static u16 +nxpwifi_netdev_select_wmm_queue (struct net_device *dev,struct sk_buff *skb, +struct net_device *sb_dev) +{ + skb->priority =cfg80211_classify8021d (skb,NULL ); +return nxpwifi_1d_to_wmm_queue[skb->priority]; +} + +/* Network device handlers */ +static const struct net_device_ops nxpwifi_netdev_ops = { + .ndo_open = nxpwifi_open, + .ndo_stop = nxpwifi_close, + .ndo_start_xmit = nxpwifi_hard_start_xmit, + .ndo_set_mac_address = nxpwifi_ndo_set_mac_address, + .ndo_validate_addr = eth_validate_addr, + .ndo_tx_timeout = nxpwifi_tx_timeout, + .ndo_get_stats = nxpwifi_get_stats, + .ndo_set_rx_mode = nxpwifi_set_multicast_list, + .ndo_select_queue = nxpwifi_netdev_select_wmm_queue, +}; + +/* This function initializes the private structure parameters. +* +* The following wait queues are initialized - +* - IOCTL wait queue +* - Command wait queue +* - Statistics wait queue +* +* ...and the following default parameters are set - +* - Current key index : Set to 0 +* - Rate index : Set to auto +* - Media connected : Set to disconnected +* - Nick name : Set to null +* - Number of Tx timeout : Set to 0 +* - Device address : Set to current address +* - Rx histogram statistc : Set to 0 +* +* In addition, the CFG80211 work queue is also created. +*/ +void nxpwifi_init_priv_params (struct nxpwifi_private *priv, +struct net_device *dev) +{ + dev->netdev_ops = &nxpwifi_netdev_ops; + dev->needs_free_netdev = true; +/* Initialize private structure */ + priv->current_key_index =0 ; + priv->media_connected = false; +memset (priv->mgmt_ie,0 , +sizeof (struct nxpwifi_ie ) *MAX_MGMT_IE_INDEX ); + priv->beacon_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->proberesp_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->assocresp_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->gen_idx =NXPWIFI_AUTO_IDX_MASK ; + priv->num_tx_timeout =0 ; +if (is_valid_ether_addr (dev->dev_addr)) +ether_addr_copy (priv->curr_addr, dev->dev_addr); +else +ether_addr_copy (priv->curr_addr, priv->adapter->perm_addr); + +if (GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_STA || +GET_BSS_ROLE (priv) ==NXPWIFI_BSS_ROLE_UAP ) { + priv->hist_data =kmalloc (sizeof (*priv->hist_data),GFP_KERNEL ); +if (priv->hist_data) +nxpwifi_hist_data_reset (priv); + } +} + +/* This function check if command is pending. +*/ +int is_command_pending (struct nxpwifi_adapter *adapter) +{ +int is_cmd_pend_q_empty; + +spin_lock_bh (&adapter->cmd_pending_q_lock); + is_cmd_pend_q_empty =list_empty (&adapter->cmd_pending_q); +spin_unlock_bh (&adapter->cmd_pending_q_lock); + +return !is_cmd_pend_q_empty; +} + +/* This is the RX tasklet function. +* +* It handles the RX operations. +*/ +static void nxpwifi_rx_recv (unsigned long data) +{ +struct nxpwifi_adapter *adapter = (struct nxpwifi_adapter *)data; + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; + +nxpwifi_process_rx (adapter); +} + +/* This is the main work function. +* +* It handles the main process, which in turn handles the complete +* driver operations. +*/ +static void nxpwifi_main_work (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, main_work); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; + +nxpwifi_main_process (adapter); +} + +/* This is the host mlme work function. +* It handles the host mlme operations. +*/ +static void nxpwifi_host_mlme_work (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, host_mlme_work); + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; + +/* Check for host mlme disconnection */ +if (adapter->host_mlme_link_lost) { +if (adapter->priv_link_lost) { +nxpwifi_reset_connect_state (adapter->priv_link_lost, +WLAN_REASON_DEAUTH_LEAVING , + true); + adapter->priv_link_lost =NULL ; + } + adapter->host_mlme_link_lost = false; + } + +/* Check for host mlme Assoc Resp */ +if (adapter->assoc_resp_received) { +nxpwifi_process_assoc_resp (adapter); + adapter->assoc_resp_received = false; + } +} + +/* This is the rx mlme work function. +* It handles rx mlme packets. +*/ +static void nxpwifi_rx_mlme_work (struct work_struct *work) +{ +struct nxpwifi_adapter *adapter = + container_of(work, struct nxpwifi_adapter, rx_mlme_work); +struct sk_buff *skb; +struct nxpwifi_rxinfo *rx_info; +struct nxpwifi_private *priv; + +if (test_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags)) +return ; + +while ((skb =skb_dequeue (&adapter->rx_mlme_q))) { + rx_info =NXPWIFI_SKB_RXCB (skb); + priv = adapter->priv[rx_info->bss_num]; +cfg80211_rx_mlme_mgmt (priv->netdev, + skb->data, + rx_info->pkt_len); + } +} + +/* Common teardown code used for both device removal and reset */ +static void nxpwifi_uninit_sw (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; +int i; + +/* We can no longer handle interrupts once we start doing the teardown +* below. +*/ +if (adapter->if_ops.disable_int) + adapter->if_ops.disable_int (adapter); + +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +tasklet_kill (&adapter->rx_task); +nxpwifi_terminate_workqueue (adapter); + adapter->int_status =0 ; + +/* Stop data */ +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (priv && priv->netdev) { +nxpwifi_stop_net_dev_queue (priv->netdev, adapter); +if (netif_carrier_ok (priv->netdev)) +netif_carrier_off (priv->netdev); +netif_device_detach (priv->netdev); + } + } + +nxpwifi_dbg (adapter,CMD ,"cmd: calling nxpwifi_shutdown_drv...\n" ); +nxpwifi_shutdown_drv (adapter); +nxpwifi_dbg (adapter,CMD ,"cmd: nxpwifi_shutdown_drv done\n" ); + +if (atomic_read (&adapter->tx_pending) || +atomic_read (&adapter->cmd_pending)) { +nxpwifi_dbg (adapter,ERROR , +"tx_pending=%d,cmd_pending=%d\n" , +atomic_read (&adapter->tx_pending), +atomic_read (&adapter->cmd_pending)); + } + +for (i =0 ; i < adapter->priv_num; i++) { + priv = adapter->priv[i]; +if (!priv) +continue ; +rtnl_lock (); +if (priv->netdev && + priv->wdev.iftype !=NL80211_IFTYPE_UNSPECIFIED ) { +/* Close the netdev now, because if we do it later, the +* netdev notifiers will need to acquire the wiphy lock +* again --> deadlock. +*/ +dev_close (priv->wdev.netdev); +wiphy_lock (adapter->wiphy); +nxpwifi_del_virtual_intf (adapter->wiphy, &priv->wdev); +wiphy_unlock (adapter->wiphy); + } +rtnl_unlock (); + } + +wiphy_unregister (adapter->wiphy); +wiphy_free (adapter->wiphy); + adapter->wiphy =NULL ; + +vfree (adapter->chan_stats); +nxpwifi_free_cmd_buffers (adapter); +} + +/* This function can be used for shutting down the adapter SW. +*/ +void nxpwifi_shutdown_sw (struct nxpwifi_adapter *adapter) +{ +struct nxpwifi_private *priv; + +if (!adapter) +return ; + +wait_for_completion (adapter->fw_done); +/* Caller should ensure we aren't suspending while this happens */ +reinit_completion (adapter->fw_done); + + priv =nxpwifi_get_priv (adapter,NXPWIFI_BSS_ROLE_ANY ); +nxpwifi_deauthenticate (priv,NULL ); + +nxpwifi_init_shutdown_fw (priv,NXPWIFI_FUNC_SHUTDOWN ); + +nxpwifi_uninit_sw (adapter); + adapter->is_up = false; +} +EXPORT_SYMBOL_GPL (nxpwifi_shutdown_sw); + +/* This function can be used for reinitting the adapter SW. Required +* code is extracted from nxpwifi_add_card() +*/ +int +nxpwifi_reinit_sw (struct nxpwifi_adapter *adapter) +{ +int ret =0 ; + +nxpwifi_init_lock_list (adapter); +if (adapter->if_ops.up_dev) + adapter->if_ops.up_dev (adapter); + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; +clear_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +init_waitqueue_head (&adapter->init_wait_q); +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); + adapter->hs_activated = false; +clear_bit (NXPWIFI_IS_CMD_TIMEDOUT , &adapter->work_flags); +init_waitqueue_head (&adapter->hs_activate_wait_q); +init_waitqueue_head (&adapter->cmd_wait_q.wait); + adapter->cmd_wait_q.status =0 ; + adapter->scan_wait_q_woken = false; + +tasklet_init (&adapter->rx_task, + (void *)nxpwifi_rx_recv, (unsigned long )adapter); +tasklet_disable (&adapter->rx_task); + + adapter->workqueue = +alloc_workqueue ("NXPWIFI_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->workqueue) { + ret = -ENOMEM ; + goto err_kmalloc; + } + +INIT_WORK (&adapter->main_work, nxpwifi_main_work); +INIT_WORK (&adapter->host_mlme_work, nxpwifi_host_mlme_work); +INIT_WORK (&adapter->rx_mlme_work, nxpwifi_rx_mlme_work); + +/* Register the device. Fill up the private data structure with +* relevant information from the card. Some code extracted from +* nxpwifi_register_dev() +*/ +nxpwifi_dbg (adapter,INFO ,"%s, nxpwifi_init_hw_fw()...\n" , __func__); + + ret =nxpwifi_init_hw_fw (adapter, false); +if (ret) { +nxpwifi_dbg (adapter,ERROR , +"%s: firmware init failed\n" , __func__); + goto err_init_fw; + } + +/* _nxpwifi_fw_dpc() does its own cleanup */ + ret =_nxpwifi_fw_dpc (adapter->firmware, adapter); +if (ret) { +pr_err ("Failed to bring up adapter: %d\n" , ret); +return ret; + } +nxpwifi_dbg (adapter,INFO ,"%s, successful\n" , __func__); + +tasklet_enable (&adapter->rx_task); + +return ret; + +err_init_fw: +nxpwifi_dbg (adapter,ERROR ,"info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); + +err_kmalloc: +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +tasklet_kill (&adapter->rx_task); +nxpwifi_terminate_workqueue (adapter); +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +nxpwifi_dbg (adapter,ERROR , +"info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } + +complete_all (adapter->fw_done); +nxpwifi_dbg (adapter,INFO ,"%s, error\n" , __func__); + +return ret; +} +EXPORT_SYMBOL_GPL (nxpwifi_reinit_sw); + +static irqreturn_t nxpwifi_irq_wakeup_handler (int irq,void *priv) +{ +struct nxpwifi_adapter *adapter = priv; + +dev_dbg (adapter->dev,"%s: wake by wifi" , __func__); + adapter->wake_by_wifi = true; +disable_irq_nosync (irq); + +/* Notify PM core we are wakeup source */ +pm_wakeup_event (adapter->dev,0 ); +pm_system_wakeup (); + +return IRQ_HANDLED ; +} + +static void nxpwifi_probe_of (struct nxpwifi_adapter *adapter) +{ +int ret; +struct device *dev = adapter->dev; + +if (!dev->of_node) + goto err_exit; + + adapter->dt_node = dev->of_node; + adapter->irq_wakeup =irq_of_parse_and_map (adapter->dt_node,0 ); +if (!adapter->irq_wakeup) { +dev_dbg (dev,"fail to parse irq_wakeup from device tree\n" ); + goto err_exit; + } + + ret =devm_request_irq (dev, adapter->irq_wakeup, + nxpwifi_irq_wakeup_handler,IRQF_TRIGGER_LOW , +"wifi_wake" , adapter); +if (ret) { +dev_err (dev,"Failed to request irq_wakeup %d (%d)\n" , + adapter->irq_wakeup, ret); + goto err_exit; + } + +disable_irq (adapter->irq_wakeup); +if (device_init_wakeup (dev, true)) { +dev_err (dev,"fail to init wakeup for nxpwifi\n" ); + goto err_exit; + } +return ; + +err_exit: + adapter->irq_wakeup =-1 ; +} + +/* This function adds the card. +* +* This function follows the following major steps to set up the device - +* - Initialize software. This includes probing the card, registering +* the interface operations table, and allocating/initializing the +* adapter structure +* - Set up the netlink socket +* - Create and start the main work queue +* - Register the device +* - Initialize firmware and hardware +* - Add logical interfaces +*/ +int +nxpwifi_add_card (void *card,struct completion *fw_done, +struct nxpwifi_if_ops *if_ops,u8 iface_type, +struct device *dev) +{ +struct nxpwifi_adapter *adapter; +int ret =0 ; + + adapter =nxpwifi_register (card, dev, if_ops); +if (IS_ERR (adapter)) { + ret =PTR_ERR (adapter); +pr_err ("%s: adapter register failed %d\n" , __func__, ret); + goto err_init_sw; + } + +nxpwifi_probe_of (adapter); + + adapter->iface_type = iface_type; + adapter->fw_done = fw_done; + + adapter->hw_status =NXPWIFI_HW_STATUS_INITIALIZING ; +clear_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +init_waitqueue_head (&adapter->init_wait_q); +clear_bit (NXPWIFI_IS_SUSPENDED , &adapter->work_flags); + adapter->hs_activated = false; +init_waitqueue_head (&adapter->hs_activate_wait_q); +init_waitqueue_head (&adapter->cmd_wait_q.wait); + adapter->cmd_wait_q.status =0 ; + adapter->scan_wait_q_woken = false; + +tasklet_init (&adapter->rx_task, + (void *)nxpwifi_rx_recv, (unsigned long )adapter); +tasklet_disable (&adapter->rx_task); + + adapter->workqueue = +alloc_workqueue ("NXPWIFI_WORK_QUEUE" , +WQ_HIGHPRI |WQ_MEM_RECLAIM |WQ_UNBOUND ,0 ); +if (!adapter->workqueue) { + ret = -ENOMEM ; + goto err_kmalloc; + } + +INIT_WORK (&adapter->main_work, nxpwifi_main_work); +INIT_WORK (&adapter->host_mlme_work, nxpwifi_host_mlme_work); +INIT_WORK (&adapter->rx_mlme_work, nxpwifi_rx_mlme_work); + +/* Register the device. Fill up the private data structure with relevant +* information from the card. +*/ + ret = adapter->if_ops.register_dev (adapter); +if (ret) { +pr_err ("%s: failed to register nxpwifi device\n" , __func__); + goto err_registerdev; + } + + ret =nxpwifi_init_hw_fw (adapter, true); +if (ret) { +pr_err ("%s: firmware init failed\n" , __func__); + goto err_init_fw; + } + +tasklet_enable (&adapter->rx_task); + +return ret; + +err_init_fw: +pr_debug ("info: %s: unregister device\n" , __func__); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); +err_registerdev: +set_bit (NXPWIFI_SURPRISE_REMOVED , &adapter->work_flags); +tasklet_kill (&adapter->rx_task); +nxpwifi_terminate_workqueue (adapter); +if (adapter->hw_status ==NXPWIFI_HW_STATUS_READY ) { +pr_debug ("info: %s: shutdown nxpwifi\n" , __func__); +nxpwifi_shutdown_drv (adapter); +nxpwifi_free_cmd_buffers (adapter); + } +err_kmalloc: +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); +nxpwifi_free_adapter (adapter); + +err_init_sw: + +return ret; +} +EXPORT_SYMBOL_GPL (nxpwifi_add_card); + +/* This function removes the card. +* +* This function follows the following major steps to remove the device - +* - Stop data traffic +* - Shutdown firmware +* - Remove the logical interfaces +* - Terminate the work queue +* - Unregister the device +* - Free the adapter structure +*/ +void nxpwifi_remove_card (struct nxpwifi_adapter *adapter) +{ +if (!adapter) +return ; + +if (adapter->is_up) +nxpwifi_uninit_sw (adapter); + +if (adapter->irq_wakeup >=0 ) +device_init_wakeup (adapter->dev, false); + +/* Unregister device */ +nxpwifi_dbg (adapter,INFO , +"info: unregister device\n" ); +if (adapter->if_ops.unregister_dev) + adapter->if_ops.unregister_dev (adapter); +/* Free adapter structure */ +nxpwifi_dbg (adapter,INFO , +"info: free adapter\n" ); +nxpwifi_free_adapter (adapter); +} +EXPORT_SYMBOL_GPL (nxpwifi_remove_card); + +void _nxpwifi_dbg (const struct nxpwifi_adapter *adapter,int mask, +const char *fmt, ...) +{ +struct va_format vaf; +va_list args; + +if (!(adapter->debug_mask & mask)) +return ; + +va_start (args, fmt); + + vaf.fmt = fmt; + vaf.va = &args; + +if (adapter->dev) +dev_info (adapter->dev,"%pV" , &vaf); +else +pr_info ("%pV" , &vaf); + +va_end (args); +} +EXPORT_SYMBOL_GPL (_nxpwifi_dbg); + +/* This function initializes the module. +* +* The debug FS is also initialized if configured. +*/ +static int +nxpwifi_init_module (void ) +{ +#ifdef CONFIG_DEBUG_FS +nxpwifi_debugfs_init (); +#endif +return 0 ; +} + +/* This function cleans up the module. +* +* The debug FS is removed if available. +*/ +static void +nxpwifi_cleanup_module (void ) +{ +#ifdef CONFIG_DEBUG_FS +nxpwifi_debugfs_remove (); +#endif +} + +module_init (nxpwifi_init_module); +module_exit (nxpwifi_cleanup_module); + +MODULE_AUTHOR ("NXP International Ltd." ); +MODULE_DESCRIPTION ("NXP WiFi Driver version " VERSION ); +MODULE_VERSION (VERSION ); +MODULE_LICENSE ("GPL" );
Signature · 1 line
2.34.1