wcn36xx: mac80211 driver for Qualcomm WCN3660/WCN3680 hardware
v2 cover wcn36xx: mac80211 driver for Qualcomm WCN3660/WCN3680 hardware
This is a mac80211 driver for Qualcomm WCN3660/WCN3680 devices. So far WCN3660/WCN3680 is available only on MSM platform.
We got a lot of useful comments from Joe and Johannes. Hopefully the second round will be the same productive.
To make review easier the driver sent in several patches, one patch per file, but after review it will be sent as one big file.
Firmware can be found here:
https://github.com/AOKP/vendor_sony/find/jb-mr1
Wiki page is available here:
http://wireless.kernel.org/en/users/Drivers/wcn36xx
A lot people made a contribution to this driver. Her is the list in alphabetical order:
Eugene Krasnikov <[email protected]>
Kalle Valo <[email protected]>
Olof Johansson <[email protected]>
Pontus Fuchs <[email protected]>
Yanbo Li <[email protected]>
---
Eugene Krasnikov (16):
wcn36xx: Add main.c
wcn36xx: add debug.c
wcn36xx: add debug.h
wcn36xx: add dxe.c
wcn36xx: add dxe.h
wcn36xx: add hal.h
wcn36xx: add pmc.c
wcn36xx: add pmc.h
wcn36xx: add smd.c
wcn36xx: add smd.h
wcn36xx: add txrx.c
wcn36xx: add txrx.h
wcn36xx: add wcn36xx.h
wcn36xx: add Makefile
wcn36xx: add Kconfig
wcn36xx: Add wcn36xx to ath Makefile and Kconfig
drivers/net/wireless/ath/Kconfig | 1 + drivers/net/wireless/ath/Makefile | 1 + drivers/net/wireless/ath/wcn36xx/Kconfig | 16 + drivers/net/wireless/ath/wcn36xx/Makefile | 9 + drivers/net/wireless/ath/wcn36xx/debug.c | 166 + drivers/net/wireless/ath/wcn36xx/debug.h | 49 + drivers/net/wireless/ath/wcn36xx/dxe.c | 804 +++++ drivers/net/wireless/ath/wcn36xx/dxe.h | 281 ++ drivers/net/wireless/ath/wcn36xx/hal.h | 4657 ++++++++++++++++++++++++++++ drivers/net/wireless/ath/wcn36xx/main.c | 1047 +++++++ drivers/net/wireless/ath/wcn36xx/pmc.c | 46 + drivers/net/wireless/ath/wcn36xx/pmc.h | 32 + drivers/net/wireless/ath/wcn36xx/smd.c | 1530 +++++++++ drivers/net/wireless/ath/wcn36xx/smd.h | 121 + drivers/net/wireless/ath/wcn36xx/txrx.c | 256 ++ drivers/net/wireless/ath/wcn36xx/txrx.h | 160 + drivers/net/wireless/ath/wcn36xx/wcn36xx.h | 236 ++ 17 files changed, 9412 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/Kconfig create mode 100644 drivers/net/wireless/ath/wcn36xx/Makefile create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.c create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.h create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.c create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.h create mode 100644 drivers/net/wireless/ath/wcn36xx/hal.h create mode 100644 drivers/net/wireless/ath/wcn36xx/main.c create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.c create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.h create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.c create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.h create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.c create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.h create mode 100644 drivers/net/wireless/ath/wcn36xx/wcn36xx.h
Signature · 1 line
1.8.2.2
PATCH v2 1/16 wcn36xx: Add main.c
Main file.
--- drivers/net/wireless/ath/wcn36xx/main.c | 1047 +++++++++++++++++++++++++++++++ 1 file changed, 1047 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/main.c
drivers/net/wireless/ath/wcn36xx/main.c new file +1047 -0
@@ -0,0 +1,1047 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include <linux/module.h> +#include <linux/platform_device.h> +#include "wcn36xx.h" + +unsigned int debug_mask; +module_param (debug_mask, uint,0644 ); +MODULE_PARM_DESC (debug_mask,"Debugging mask" ); + +#define CHAN2G (_freq, _idx) { \ + .band = IEEE80211_BAND_2GHZ, \ + .center_freq = (_freq), \ + .hw_value = (_idx), \ + .max_power = 25, \ +} + +#define CHAN5G (_freq, _idx) { \ + .band = IEEE80211_BAND_5GHZ, \ + .center_freq = (_freq), \ + .hw_value = (_idx), \ + .max_power = 25, \ +} + +/* The wcn firmware expects channel values to matching +* their mnemonic values. So use these for .hw_value. */ +static struct ieee80211_channel wcn_2ghz_channels[] = { +CHAN2G (2412 ,1 ),/* Channel 1 */ +CHAN2G (2417 ,2 ),/* Channel 2 */ +CHAN2G (2422 ,3 ),/* Channel 3 */ +CHAN2G (2427 ,4 ),/* Channel 4 */ +CHAN2G (2432 ,5 ),/* Channel 5 */ +CHAN2G (2437 ,6 ),/* Channel 6 */ +CHAN2G (2442 ,7 ),/* Channel 7 */ +CHAN2G (2447 ,8 ),/* Channel 8 */ +CHAN2G (2452 ,9 ),/* Channel 9 */ +CHAN2G (2457 ,10 ),/* Channel 10 */ +CHAN2G (2462 ,11 ),/* Channel 11 */ +CHAN2G (2467 ,12 ),/* Channel 12 */ +CHAN2G (2472 ,13 ),/* Channel 13 */ +CHAN2G (2484 ,14 )/* Channel 14 */ + +}; + +static struct ieee80211_channel wcn_5ghz_channels[] = { +CHAN5G (5180 ,36 ), +CHAN5G (5200 ,40 ), +CHAN5G (5220 ,44 ), +CHAN5G (5240 ,48 ), +CHAN5G (5260 ,52 ), +CHAN5G (5280 ,56 ), +CHAN5G (5300 ,60 ), +CHAN5G (5320 ,64 ), +CHAN5G (5500 ,100 ), +CHAN5G (5520 ,104 ), +CHAN5G (5540 ,108 ), +CHAN5G (5560 ,112 ), +CHAN5G (5580 ,116 ), +CHAN5G (5600 ,120 ), +CHAN5G (5620 ,124 ), +CHAN5G (5640 ,128 ), +CHAN5G (5660 ,132 ), +CHAN5G (5700 ,140 ), +CHAN5G (5745 ,149 ), +CHAN5G (5765 ,153 ), +CHAN5G (5785 ,157 ), +CHAN5G (5805 ,161 ), +CHAN5G (5825 ,165 ) +}; + +#define RATE (_bitrate, _hw_rate, _flags) { \ + .bitrate = (_bitrate), \ + .flags = (_flags), \ + .hw_value = (_hw_rate), \ + .hw_value_short = (_hw_rate) \ +} + +static struct ieee80211_rate wcn_2ghz_rates[] = { +RATE (10 ,HW_RATE_INDEX_1MBPS ,0 ), +RATE (20 ,HW_RATE_INDEX_2MBPS ,IEEE80211_RATE_SHORT_PREAMBLE ), +RATE (55 ,HW_RATE_INDEX_5_5MBPS ,IEEE80211_RATE_SHORT_PREAMBLE ), +RATE (110 ,HW_RATE_INDEX_11MBPS ,IEEE80211_RATE_SHORT_PREAMBLE ), +RATE (60 ,HW_RATE_INDEX_6MBPS ,0 ), +RATE (90 ,HW_RATE_INDEX_9MBPS ,0 ), +RATE (120 ,HW_RATE_INDEX_12MBPS ,0 ), +RATE (180 ,HW_RATE_INDEX_18MBPS ,0 ), +RATE (240 ,HW_RATE_INDEX_24MBPS ,0 ), +RATE (360 ,HW_RATE_INDEX_36MBPS ,0 ), +RATE (480 ,HW_RATE_INDEX_48MBPS ,0 ), +RATE (540 ,HW_RATE_INDEX_54MBPS ,0 ) +}; + +static struct ieee80211_rate wcn_5ghz_rates[] = { +RATE (60 ,HW_RATE_INDEX_6MBPS ,0 ), +RATE (90 ,HW_RATE_INDEX_9MBPS ,0 ), +RATE (120 ,HW_RATE_INDEX_12MBPS ,0 ), +RATE (180 ,HW_RATE_INDEX_18MBPS ,0 ), +RATE (240 ,HW_RATE_INDEX_24MBPS ,0 ), +RATE (360 ,HW_RATE_INDEX_36MBPS ,0 ), +RATE (480 ,HW_RATE_INDEX_48MBPS ,0 ), +RATE (540 ,HW_RATE_INDEX_54MBPS ,0 ) +}; + +static struct ieee80211_supported_band wcn_band_2ghz = { + .channels = wcn_2ghz_channels, + .n_channels =ARRAY_SIZE (wcn_2ghz_channels), + .bitrates = wcn_2ghz_rates, + .n_bitrates =ARRAY_SIZE (wcn_2ghz_rates), + .ht_cap = { + .cap =IEEE80211_HT_CAP_GRN_FLD | +IEEE80211_HT_CAP_SGI_20 | +IEEE80211_HT_CAP_DSSSCCK40 | +IEEE80211_HT_CAP_LSIG_TXOP_PROT , + .ht_supported = true, + .ampdu_factor =IEEE80211_HT_MAX_AMPDU_64K , + .ampdu_density =IEEE80211_HT_MPDU_DENSITY_16 , + .mcs = { + .rx_mask = {0xff ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 , }, + .rx_highest =cpu_to_le16 (72 ), + .tx_params =IEEE80211_HT_MCS_TX_DEFINED , + } + } +}; + +static struct ieee80211_supported_band wcn_band_5ghz = { + .channels = wcn_5ghz_channels, + .n_channels =ARRAY_SIZE (wcn_5ghz_channels), + .bitrates = wcn_5ghz_rates, + .n_bitrates =ARRAY_SIZE (wcn_5ghz_rates), + .ht_cap = { + .cap =IEEE80211_HT_CAP_GRN_FLD | +IEEE80211_HT_CAP_SGI_20 | +IEEE80211_HT_CAP_DSSSCCK40 | +IEEE80211_HT_CAP_LSIG_TXOP_PROT | +IEEE80211_HT_CAP_SGI_40 | +IEEE80211_HT_CAP_SUP_WIDTH_20_40 , + .ht_supported = true, + .ampdu_factor =IEEE80211_HT_MAX_AMPDU_64K , + .ampdu_density =IEEE80211_HT_MPDU_DENSITY_16 , + .mcs = { + .rx_mask = {0xff ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 , }, + .rx_highest =cpu_to_le16 (72 ), + .tx_params =IEEE80211_HT_MCS_TX_DEFINED , + } + } +}; + +static const struct ieee80211_iface_limit if_limits[] = { + { .max =2 , .types =BIT (NL80211_IFTYPE_STATION ) }, + { .max =1 , .types =BIT (NL80211_IFTYPE_AP ) }, +}; + +static const struct ieee80211_iface_combination if_comb = { + .limits = if_limits, + .n_limits =ARRAY_SIZE (if_limits), + .max_interfaces =2 , + .num_different_channels =1 , +}; + +#ifdef CONFIG_PM + +static const struct wiphy_wowlan_support wowlan_support = { + .flags =WIPHY_WOWLAN_ANY +}; + +#endif + +static inline u8 get_sta_index (struct ieee80211_vif *vif, +struct wcn36xx_sta *sta_priv) +{ +return NL80211_IFTYPE_STATION == vif->type ? + sta_priv->bss_sta_index : + sta_priv->sta_index; +} + +static int wcn36xx_start (struct ieee80211_hw *hw) +{ +struct wcn36xx *wcn = hw->priv; +int ret; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac start\n" ); + +/* SMD initialization */ + ret =wcn36xx_smd_open (wcn); +if (ret) { +wcn36xx_err ("Failed to open smd channel: %d\n" , ret); + goto out_err; + } + +/* Allocate memory pools for Mgmt BD headers and Data BD headers */ + ret =wcn36xx_dxe_allocate_mem_pools (wcn); +if (ret) { +wcn36xx_err ("Failed to alloc DXE mempool: %d\n" , ret); + goto out_smd_close; + } + + ret =wcn36xx_dxe_alloc_ctl_blks (wcn); +if (ret) { +wcn36xx_err ("Failed to alloc DXE ctl blocks: %d\n" , ret); + goto out_free_dxe_pool; + } + +/* Maximum SMD message size is 4k */ + wcn->smd_buf =kmalloc (WCN36XX_SMD_BUF_SIZE ,GFP_KERNEL ); +if (!wcn->smd_buf) { +wcn36xx_err ("Failed to allocate smd buf\n" ); + ret = -ENOMEM ; + goto out_free_dxe_ctl; + } + + ret =wcn36xx_smd_load_nv (wcn); +if (ret) { +wcn36xx_err ("Failed to push NV to chip\n" ); + goto out_free_smd_buf; + } + + ret =wcn36xx_smd_start (wcn); +if (ret) { +wcn36xx_err ("Failed to start chip\n" ); + goto out_free_smd_buf; + } + +/* DMA channel initialization */ + ret =wcn36xx_dxe_init (wcn); +if (ret) { +wcn36xx_err ("DXE init failed\n" ); + goto out_smd_stop; + } + +wcn36xx_pmc_init (wcn); +wcn36xx_debugfs_init (wcn); + +if (!wcn36xx_is_fw_version (wcn,1 ,2 ,2 ,24 )) { + ret =wcn36xx_smd_feature_caps_exchange (wcn); +if (ret) +wcn36xx_warn ("Exchange feature caps failed\n" ); + } + +return 0 ; + +out_smd_stop: +wcn36xx_smd_stop (wcn); +out_free_smd_buf: +kfree (wcn->smd_buf); +out_free_dxe_pool: +wcn36xx_dxe_free_mem_pools (wcn); +out_free_dxe_ctl: +wcn36xx_dxe_free_ctl_blks (wcn); +out_smd_close: +wcn36xx_smd_close (wcn); +out_err: +return ret; +} + +static void wcn36xx_stop (struct ieee80211_hw *hw) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac stop\n" ); + +wcn36xx_debugfs_exit (wcn); +wcn36xx_smd_stop (wcn); +wcn36xx_dxe_deinit (wcn); +wcn36xx_smd_close (wcn); + +wcn36xx_dxe_free_mem_pools (wcn); +wcn36xx_dxe_free_ctl_blks (wcn); + +kfree (wcn->smd_buf); +} + +static int wcn36xx_config (struct ieee80211_hw *hw,u32 changed) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac config changed 0x%08x\n" , changed); + +if (changed &IEEE80211_CONF_CHANGE_CHANNEL ) { +int ch =WCN36XX_HW_CHANNEL (wcn); +wcn36xx_dbg (WCN36XX_DBG_MAC ,"wcn36xx_config channel switch=%d\n" , + ch); +wcn36xx_smd_switch_channel (wcn, ch); + } + +return 0 ; +} + +#define WCN36XX_SUPPORTED_FILTERS (0) + +static void wcn36xx_configure_filter (struct ieee80211_hw *hw, +unsigned int changed, +unsigned int *total,u64 multicast) +{ +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac configure filter\n" ); + + *total &=WCN36XX_SUPPORTED_FILTERS ; +} + +static void wcn36xx_tx (struct ieee80211_hw *hw, +struct ieee80211_tx_control *control, +struct sk_buff *skb) +{ +struct wcn36xx *wcn = hw->priv; +struct wcn36xx_sta *sta_priv =NULL ; + +if (control->sta) + sta_priv = (struct wcn36xx_sta *)control->sta->drv_priv; + +if (wcn36xx_start_tx (wcn, sta_priv, skb)) +ieee80211_free_txskb (wcn->hw, skb); +} + +static int wcn36xx_set_key (struct ieee80211_hw *hw,enum set_key_cmd cmd, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ieee80211_key_conf *key_conf) +{ +struct wcn36xx *wcn = hw->priv; +struct wcn36xx_sta *sta_priv =NULL ; +int ret =0 ; +u8 key[WLAN_MAX_KEY_LEN ]; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac80211 set key\n" ); +wcn36xx_dbg (WCN36XX_DBG_MAC ,"Key: cmd=0x%x algo:0x%x, id:%d, len:%d flags 0x%x\n" , + cmd, key_conf->cipher, key_conf->keyidx, + key_conf->keylen, key_conf->flags); +wcn36xx_dbg_dump (WCN36XX_DBG_MAC ,"KEY: " , + key_conf->key, + key_conf->keylen); + sta_priv = sta ? (struct wcn36xx_sta *)sta->drv_priv : wcn->sta; + +switch (key_conf->cipher) { +case WLAN_CIPHER_SUITE_WEP40 : + wcn->encrypt_type =WCN36XX_HAL_ED_WEP40 ; +break ; +case WLAN_CIPHER_SUITE_WEP104 : + wcn->encrypt_type =WCN36XX_HAL_ED_WEP40 ; +break ; +case WLAN_CIPHER_SUITE_CCMP : + wcn->encrypt_type =WCN36XX_HAL_ED_CCMP ; +break ; +case WLAN_CIPHER_SUITE_TKIP : + wcn->encrypt_type =WCN36XX_HAL_ED_TKIP ; +break ; +default : +wcn36xx_err ("Unsupported key type 0x%x\n" , + key_conf->cipher); + ret = -EOPNOTSUPP ; + goto out; + } + +switch (cmd) { +case SET_KEY : +if (WCN36XX_HAL_ED_TKIP == wcn->encrypt_type) { +/* +* Supplicant is sending key in the wrong order: +* Temporal Key (16 b) - TX MIC (8 b) - RX MIC (8 b) +* but HW expects it to be in the order as described in +* IEEE 802.11 spec (see chapter 11.7) like this: +* Temporal Key (16 b) - RX MIC (8 b) - TX MIC (8 b) +*/ +memcpy (key, key_conf->key,16 ); +memcpy (key +16 , key_conf->key +24 ,8 ); +memcpy (key +24 , key_conf->key +16 ,8 ); + }else { +memcpy (key, key_conf->key, key_conf->keylen); + } + +if (IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags) { + sta_priv->is_data_encrypted = true; +/* Reconfigure bss with encrypt_type */ +if (NL80211_IFTYPE_STATION == vif->type) +wcn36xx_smd_config_bss (wcn, + vif, + sta, + sta->addr, + true); + +wcn36xx_smd_set_stakey (wcn, + wcn->encrypt_type, + key_conf->keyidx, + key_conf->keylen, + key, +get_sta_index (vif, sta_priv)); + }else { +wcn36xx_smd_set_bsskey (wcn, + wcn->encrypt_type, + key_conf->keyidx, + key_conf->keylen, + key); +if ((WLAN_CIPHER_SUITE_WEP40 == key_conf->cipher) || + (WLAN_CIPHER_SUITE_WEP104 == key_conf->cipher)) { + sta_priv->is_data_encrypted = true; +wcn36xx_smd_set_stakey (wcn, + wcn->encrypt_type, + key_conf->keyidx, + key_conf->keylen, + key, +get_sta_index (vif, sta_priv)); + } + } +break ; +case DISABLE_KEY : +if (!(IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags)) { +wcn36xx_smd_remove_bsskey (wcn, + wcn->encrypt_type, + key_conf->keyidx); + }else { + sta_priv->is_data_encrypted = false; +/* do not remove key if disassociated */ +if (wcn->aid) +wcn36xx_smd_remove_stakey (wcn, + wcn->encrypt_type, + key_conf->keyidx, +get_sta_index (vif, sta_priv)); + } +break ; +default : +wcn36xx_err ("Unsupported key cmd 0x%x\n" , cmd); + ret = -EOPNOTSUPP ; + goto out; +break ; + } + +out: +return ret; +} + +static void wcn36xx_sw_scan_start (struct ieee80211_hw *hw) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_smd_init_scan (wcn); +wcn36xx_smd_start_scan (wcn); +} + +static void wcn36xx_sw_scan_complete (struct ieee80211_hw *hw) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_smd_end_scan (wcn); +wcn36xx_smd_finish_scan (wcn); +} + +static void wcn36xx_update_allowed_rates (struct wcn36xx *wcn, +struct ieee80211_sta *sta) +{ +int i, size; +u16 *rates_table; +u32 rates = sta->supp_rates[wcn->hw->conf.chandef.chan->band]; + +memset (&wcn->supported_rates,0 ,sizeof (wcn->supported_rates)); + wcn->supported_rates.op_rate_mode = STA_11n; + + size =ARRAY_SIZE (wcn->supported_rates.dsss_rates); + rates_table = wcn->supported_rates.dsss_rates; +if (wcn->hw->conf.chandef.chan->band ==IEEE80211_BAND_2GHZ ) { +for (i =0 ; i < size; i++) { +if (rates &0x01 ) { + rates_table[i] = wcn_2ghz_rates[i].hw_value; + rates = rates >>1 ; + } + } + } + + size =ARRAY_SIZE (wcn->supported_rates.ofdm_rates); + rates_table = wcn->supported_rates.ofdm_rates; +for (i =0 ; i < size; i++) { +if (rates &0x01 ) { + rates_table[i] = wcn_5ghz_rates[i].hw_value; + rates = rates >>1 ; + } + } + +if (sta->ht_cap.ht_supported) { +memcpy (wcn->supported_rates.supported_mcs_set, + sta->ht_cap.mcs.rx_mask, +sizeof (sta->ht_cap.mcs.rx_mask)); +BUILD_BUG_ON (sizeof (sta->ht_cap.mcs.rx_mask) > +sizeof (wcn->supported_rates.supported_mcs_set)); + } +} + +static void wcn36xx_bss_info_changed (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +struct ieee80211_bss_conf *bss_conf, +u32 changed) +{ +struct wcn36xx *wcn = hw->priv; +struct sk_buff *skb =NULL ; +u16 tim_off, tim_len; +enum wcn36xx_hal_link_state link_state; + + wcn->current_vif = (struct wcn36xx_vif *)vif->drv_priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac bss info changed vif %p changed 0x%08x\n" , + vif, changed); + +if (changed &BSS_CHANGED_BEACON_INFO ) { +wcn36xx_dbg (WCN36XX_DBG_MAC , +"mac bss changed dtim period %d\n" , + bss_conf->dtim_period); + + wcn->dtim_period = bss_conf->dtim_period; + } + +if (changed &BSS_CHANGED_BSSID ) { +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac bss changed_bssid %pM\n" , + bss_conf->bssid); + +if (!is_zero_ether_addr (bss_conf->bssid)) { + wcn->is_joining = true; + wcn->current_vif->bss_index =0xff ; +wcn36xx_smd_join (wcn, bss_conf->bssid, + vif->addr,WCN36XX_HW_CHANNEL (wcn)); +wcn36xx_smd_config_bss (wcn, vif,NULL , + bss_conf->bssid, false); + }else { + wcn->is_joining = false; +wcn36xx_smd_delete_bss (wcn); + } + } + +if (changed &BSS_CHANGED_SSID ) { +wcn36xx_dbg (WCN36XX_DBG_MAC , +"mac bss changed ssid\n" ); +wcn36xx_dbg_dump (WCN36XX_DBG_MAC ,"ssid " , + bss_conf->ssid, bss_conf->ssid_len); + + wcn->ssid.length = bss_conf->ssid_len; +memcpy (&wcn->ssid.ssid, bss_conf->ssid, bss_conf->ssid_len); + } + +if (changed &BSS_CHANGED_ASSOC ) { + wcn->is_joining = false; +if (bss_conf->assoc) { +struct ieee80211_sta *sta; +struct wcn36xx_sta *sta_priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC , +"mac assoc bss %pM vif %pM AID=%d\n" , + bss_conf->bssid, + vif->addr, + bss_conf->aid); + + wcn->aid = bss_conf->aid; + +rcu_read_lock (); + sta =ieee80211_find_sta (vif, bss_conf->bssid); +if (!sta) { +wcn36xx_err ("sta %pM is not found\n" , + bss_conf->bssid); +rcu_read_unlock (); + goto out; + } + sta_priv = (struct wcn36xx_sta *)sta->drv_priv; + +wcn36xx_update_allowed_rates (wcn, sta); + +wcn36xx_smd_set_link_st (wcn, bss_conf->bssid, + vif->addr, +WCN36XX_HAL_LINK_POSTASSOC_STATE ); + wcn->sta = sta_priv; +wcn36xx_smd_config_bss (wcn, vif, sta, + bss_conf->bssid, + true); +rcu_read_unlock (); + }else { +wcn36xx_dbg (WCN36XX_DBG_MAC , +"disassociated bss %pM vif %pM AID=%d\n" , + bss_conf->bssid, + vif->addr, + bss_conf->aid); + wcn->aid =0 ; +wcn36xx_smd_set_link_st (wcn, + bss_conf->bssid, + vif->addr, +WCN36XX_HAL_LINK_IDLE_STATE ); + } + } + +if (changed &BSS_CHANGED_AP_PROBE_RESP ) { +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac bss changed ap probe resp\n" ); + skb =ieee80211_proberesp_get (hw, vif); +if (!skb) { +wcn36xx_err ("failed to alloc probereq skb\n" ); + goto out; + } + +wcn36xx_smd_update_proberesp_tmpl (wcn, skb); +dev_kfree_skb (skb); + } + +if (changed &BSS_CHANGED_BEACON_ENABLED ) { +wcn36xx_dbg (WCN36XX_DBG_MAC , +"mac bss changed beacon enabled %d\n" , + bss_conf->enable_beacon); + +if (bss_conf->enable_beacon) { + wcn->current_vif->bss_index =0xff ; +wcn36xx_smd_config_bss (wcn, vif,NULL , + wcn->addresses.addr, false); + skb =ieee80211_beacon_get_tim (hw, vif, &tim_off, + &tim_len); +if (!skb) { +wcn36xx_err ("failed to alloc beacon skb\n" ); + goto out; + } +wcn36xx_smd_send_beacon (wcn, skb, tim_off,0 ); +dev_kfree_skb (skb); + +if (vif->type ==NL80211_IFTYPE_ADHOC || + vif->type ==NL80211_IFTYPE_MESH_POINT ) + link_state =WCN36XX_HAL_LINK_IBSS_STATE ; +else + link_state =WCN36XX_HAL_LINK_AP_STATE ; + +wcn36xx_smd_set_link_st (wcn, vif->addr, vif->addr, + link_state); + }else { +wcn36xx_smd_set_link_st (wcn, vif->addr, vif->addr, +WCN36XX_HAL_LINK_IDLE_STATE ); +wcn36xx_smd_delete_bss (wcn); + } + } +out: +return ; +} + +/* this is required when using IEEE80211_HW_HAS_RATE_CONTROL */ +static int wcn36xx_set_rts_threshold (struct ieee80211_hw *hw,u32 value) +{ +struct wcn36xx *wcn = hw->priv; +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac set RTS threshold %d\n" , value); + +wcn36xx_smd_update_cfg (wcn,WCN36XX_HAL_CFG_RTS_THRESHOLD , value); +return 0 ; +} + +static void wcn36xx_remove_interface (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct wcn36xx *wcn = hw->priv; +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac remove interface vif %p\n" , vif); +wcn36xx_smd_delete_sta_self (wcn, vif->addr); +} + +static int wcn36xx_add_interface (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac add interface vif %p type %d\n" , + vif, vif->type); + + wcn->current_vif = (struct wcn36xx_vif *)vif->drv_priv; + +switch (vif->type) { +case NL80211_IFTYPE_STATION : +wcn36xx_smd_add_sta_self (wcn, vif->addr,0 ); +break ; +case NL80211_IFTYPE_AP : +wcn36xx_smd_add_sta_self (wcn, vif->addr,0 ); +break ; +case NL80211_IFTYPE_ADHOC : +case NL80211_IFTYPE_MESH_POINT : +wcn36xx_smd_add_sta_self (wcn, vif->addr,0 ); +break ; +default : +wcn36xx_warn ("Unsupported interface type requested: %d\n" , + vif->type); +return -EOPNOTSUPP ; + } + +return 0 ; +} + +static int wcn36xx_sta_add (struct ieee80211_hw *hw,struct ieee80211_vif *vif, +struct ieee80211_sta *sta) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac sta add vif %p sta %pM\n" , + vif, sta->addr); + + wcn->sta = (struct wcn36xx_sta *)sta->drv_priv; + wcn->aid = sta->aid; +wcn36xx_smd_config_sta (wcn, vif, sta); + +return 0 ; +} + +static int wcn36xx_sta_remove (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta) +{ +struct wcn36xx *wcn = hw->priv; +struct wcn36xx_sta *sta_priv = (struct wcn36xx_sta *)sta->drv_priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac sta remove vif %p sta %pM index %d\n" , + vif, sta->addr, sta_priv->sta_index); + +wcn36xx_smd_delete_sta (wcn, sta_priv->sta_index); + +return 0 ; +} + +#ifdef CONFIG_PM + +static int wcn36xx_suspend (struct ieee80211_hw *hw,struct cfg80211_wowlan *wow) +{ +struct wcn36xx *wcn = hw->priv; +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac suspend\n" ); + +mutex_lock (&wcn->pm_mutex); + +/* Enter BMPS only in connected state */ +if ((wcn->aid >0 ) && + (wcn->pw_state !=WCN36XX_BMPS ) && + (NL80211_IFTYPE_STATION == vif->type)) +wcn36xx_pmc_enter_bmps_state (wcn, vif->bss_conf.sync_tsf); + + wcn->is_suspended = true; + wcn->is_con_lost_pending = false; + +mutex_unlock (&wcn->pm_mutex); + +return 0 ; +} + +static int wcn36xx_resume (struct ieee80211_hw *hw) +{ +struct wcn36xx *wcn = hw->priv; +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac resume\n" ); + + wcn->is_suspended = false; + +if (wcn->pw_state ==WCN36XX_BMPS ) +wcn36xx_pmc_exit_bmps_state (wcn); + +if (wcn->is_con_lost_pending) { +wcn36xx_dbg (WCN36XX_DBG_MAC ,"report connection lost\n" ); +ieee80211_connection_loss (vif); + } + +return 0 ; +} + +#endif + +static int wcn36xx_ampdu_action (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +enum ieee80211_ampdu_mlme_action action, +struct ieee80211_sta *sta,u16 tid,u16 *ssn, +u8 buf_size) +{ +struct wcn36xx *wcn = hw->priv; +struct wcn36xx_sta *sta_priv =NULL ; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac ampdu action action %d tid %d\n" , + action, tid); + + sta_priv = (struct wcn36xx_sta *)sta->drv_priv; + +switch (action) { +case IEEE80211_AMPDU_RX_START : + sta_priv->tid = tid; +wcn36xx_smd_add_ba_session (wcn, sta, tid, ssn,0 , +get_sta_index (vif, sta_priv)); +wcn36xx_smd_add_ba (wcn); +wcn36xx_smd_trigger_ba (wcn,get_sta_index (vif, sta_priv)); +ieee80211_start_tx_ba_session (sta, tid,0 ); +break ; +case IEEE80211_AMPDU_RX_STOP : +wcn36xx_smd_del_ba (wcn, tid,get_sta_index (vif, sta_priv)); +break ; +case IEEE80211_AMPDU_TX_START : +ieee80211_start_tx_ba_cb_irqsafe (vif, sta->addr, tid); +break ; +case IEEE80211_AMPDU_TX_OPERATIONAL : +wcn36xx_smd_add_ba_session (wcn, sta, tid, ssn,1 , +get_sta_index (vif, sta_priv)); +break ; +case IEEE80211_AMPDU_TX_STOP_FLUSH : +case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT : +case IEEE80211_AMPDU_TX_STOP_CONT : +ieee80211_stop_tx_ba_cb_irqsafe (vif, sta->addr, tid); +break ; +default : +wcn36xx_err ("Unknown AMPDU action\n" ); + } + +return 0 ; +} + +static const struct ieee80211_ops wcn36xx_ops = { + .start = wcn36xx_start, + .stop = wcn36xx_stop, + .add_interface = wcn36xx_add_interface, + .remove_interface = wcn36xx_remove_interface, +#ifdef CONFIG_PM + .suspend = wcn36xx_suspend, + .resume = wcn36xx_resume, +#endif + .config = wcn36xx_config, + .configure_filter = wcn36xx_configure_filter, + .tx = wcn36xx_tx, + .set_key = wcn36xx_set_key, + .sw_scan_start = wcn36xx_sw_scan_start, + .sw_scan_complete = wcn36xx_sw_scan_complete, + .bss_info_changed = wcn36xx_bss_info_changed, + .set_rts_threshold = wcn36xx_set_rts_threshold, + .sta_add = wcn36xx_sta_add, + .sta_remove = wcn36xx_sta_remove, + .ampdu_action = wcn36xx_ampdu_action, +}; + +static int wcn36xx_init_ieee80211 (struct wcn36xx *wcn) +{ +int ret =0 ; + +static const u32 cipher_suites[] = { +WLAN_CIPHER_SUITE_WEP40 , +WLAN_CIPHER_SUITE_WEP104 , +WLAN_CIPHER_SUITE_TKIP , +WLAN_CIPHER_SUITE_CCMP , + }; + + wcn->hw->flags =IEEE80211_HW_SIGNAL_DBM | +IEEE80211_HW_HAS_RATE_CONTROL | +IEEE80211_HW_SUPPORTS_PS | +IEEE80211_HW_CONNECTION_MONITOR | +IEEE80211_HW_AMPDU_AGGREGATION | +IEEE80211_HW_TIMING_BEACON_ONLY ; + + wcn->hw->wiphy->interface_modes =BIT (NL80211_IFTYPE_STATION ) | +BIT (NL80211_IFTYPE_AP ) | +BIT (NL80211_IFTYPE_ADHOC ) | +BIT (NL80211_IFTYPE_MESH_POINT ); + + wcn->hw->wiphy->bands[IEEE80211_BAND_2GHZ ] = &wcn_band_2ghz; + wcn->hw->wiphy->bands[IEEE80211_BAND_5GHZ ] = &wcn_band_5ghz; + + wcn->hw->wiphy->cipher_suites = cipher_suites; + wcn->hw->wiphy->n_cipher_suites =ARRAY_SIZE (cipher_suites); + + wcn->hw->wiphy->flags |=WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD ; + +#ifdef CONFIG_PM + wcn->hw->wiphy->wowlan = &wowlan_support; +#endif + + wcn->hw->wiphy->n_addresses =1 ; + wcn->hw->wiphy->addresses = &wcn->addresses; + + wcn->hw->max_listen_interval =200 ; + + wcn->hw->queues =4 ; + +SET_IEEE80211_DEV (wcn->hw, wcn->dev); + + wcn->hw->sta_data_size =sizeof (struct wcn36xx_sta ); + wcn->hw->vif_data_size =sizeof (struct wcn36xx_vif ); + +return ret; +} + +static int wcn36xx_platform_get_resources (struct wcn36xx *wcn, +struct platform_device *pdev) +{ +struct resource *res; +/* Set TX IRQ */ + res =platform_get_resource_byname (pdev,IORESOURCE_IRQ , +"wcnss_wlantx_irq" ); +if (!res) { +wcn36xx_err ("failed to get tx_irq\n" ); +return -ENOENT ; + } + wcn->tx_irq = res->start; + +/* Set RX IRQ */ + res =platform_get_resource_byname (pdev,IORESOURCE_IRQ , +"wcnss_wlanrx_irq" ); +if (!res) { +wcn36xx_err ("failed to get rx_irq\n" ); +return -ENOENT ; + } + wcn->rx_irq = res->start; + +/* Map the memory */ + res =platform_get_resource_byname (pdev,IORESOURCE_MEM , +"wcnss_mmio" ); +if (!res) { +wcn36xx_err ("failed to get mmio\n" ); +return -ENOENT ; + } + wcn->mmio =ioremap (res->start,resource_size (res)); +if (!wcn->mmio) { +wcn36xx_err ("failed to map io memory\n" ); +return -ENOMEM ; + } +return 0 ; +} + +static int wcn36xx_probe (struct platform_device *pdev) +{ +struct ieee80211_hw *hw; +struct wcn36xx *wcn; +int ret; +u16 ofdm_rates[WCN36XX_HAL_NUM_OFDM_RATES ] = { +HW_RATE_INDEX_6MBPS , +HW_RATE_INDEX_9MBPS , +HW_RATE_INDEX_12MBPS , +HW_RATE_INDEX_18MBPS , +HW_RATE_INDEX_24MBPS , +HW_RATE_INDEX_36MBPS , +HW_RATE_INDEX_48MBPS , +HW_RATE_INDEX_54MBPS + }; +u16 dsss_rates[WCN36XX_HAL_NUM_DSSS_RATES ] = { +HW_RATE_INDEX_1MBPS , +HW_RATE_INDEX_2MBPS , +HW_RATE_INDEX_5_5MBPS , +HW_RATE_INDEX_11MBPS + }; +wcn36xx_dbg (WCN36XX_DBG_MAC ,"platform probe\n" ); + + hw =ieee80211_alloc_hw (sizeof (struct wcn36xx ), &wcn36xx_ops); +if (!hw) { +wcn36xx_err ("failed to alloc hw\n" ); + ret = -ENOMEM ; + goto out_err; + } +platform_set_drvdata (pdev, hw); + wcn = hw->priv; + wcn->hw = hw; + wcn->dev = &pdev->dev; + wcn->ctrl_ops = pdev->dev.platform_data; + +mutex_init (&wcn->pm_mutex); +mutex_init (&wcn->smd_mutex); + +/* Configuring supported rates */ + wcn->supported_rates.op_rate_mode = STA_11n; +memcpy (wcn->supported_rates.dsss_rates, dsss_rates, +sizeof (*dsss_rates) *WCN36XX_HAL_NUM_DSSS_RATES ); +memcpy (wcn->supported_rates.ofdm_rates, ofdm_rates, +sizeof (*ofdm_rates) *WCN36XX_HAL_NUM_OFDM_RATES ); + wcn->supported_rates.supported_mcs_set[0 ] =0xFF ; + +if (!wcn->ctrl_ops->get_hw_mac (wcn->addresses.addr)) { +wcn36xx_info ("mac address: %pM\n" , wcn->addresses.addr); +SET_IEEE80211_PERM_ADDR (wcn->hw, wcn->addresses.addr); + } + + ret =wcn36xx_platform_get_resources (wcn, pdev); +if (ret) + goto out_wq; + +wcn36xx_init_ieee80211 (wcn); + ret =ieee80211_register_hw (wcn->hw); +if (ret) + goto out_unmap; + +return 0 ; + +out_unmap: +iounmap (wcn->mmio); +out_wq: +ieee80211_free_hw (hw); +out_err: +return ret; +} +static int wcn36xx_remove (struct platform_device *pdev) +{ +struct ieee80211_hw *hw =platform_get_drvdata (pdev); +struct wcn36xx *wcn = hw->priv; +wcn36xx_dbg (WCN36XX_DBG_MAC ,"platform remove\n" ); + +mutex_destroy (&wcn->pm_mutex); +mutex_destroy (&wcn->smd_mutex); + +ieee80211_unregister_hw (hw); +iounmap (wcn->mmio); +ieee80211_free_hw (hw); + +return 0 ; +} +static const struct platform_device_id wcn36xx_platform_id_table[] = { + { + .name ="wcn36xx" , + .driver_data =0 + }, + {} +}; +MODULE_DEVICE_TABLE (platform, wcn36xx_platform_id_table); + +static struct platform_driver wcn36xx_driver = { + .probe = wcn36xx_probe, + .remove = wcn36xx_remove, + .driver = { + .name ="wcn36xx" , + .owner =THIS_MODULE , + }, + .id_table = wcn36xx_platform_id_table, +}; + +static int __init wcn36xx_init (void ) +{ +platform_driver_register (&wcn36xx_driver); +return 0 ; +} +module_init (wcn36xx_init); + +static void __exit wcn36xx_exit(void) +{ +platform_driver_unregister (&wcn36xx_driver); +} +module_exit (wcn36xx_exit); + +MODULE_LICENSE ("Dual BSD/GPL" ); +MODULE_AUTHOR ("Eugene Krasnikov [email protected]" ); +MODULE_FIRMWARE (WLAN_NV_FILE );
Signature · 1 line
1.8.2.2
Re: [PATCH v2 01/16] wcn36xx: Add main.c
Quoted 11 lines · Eugene Krasnikov
drivers/net/wireless/ath/wcn36xx/main.c new file +11
-0+static const struct ieee80211_iface_limit if_limits[] = { + { .max =2 , .types =BIT (NL80211_IFTYPE_STATION ) }, + { .max =1 , .types =BIT (NL80211_IFTYPE_AP ) }, +}; + +static const struct ieee80211_iface_combination if_comb = { + .limits = if_limits, + .n_limits =ARRAY_SIZE (if_limits), + .max_interfaces =2 , + .num_different_channels =1 , +};
drivers/net/wireless/ath/wcn36xx/main.c
Quoted 10 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +9
-0+static int wcn36xx_add_interface (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac add interface vif %p type %d\n" , + vif, vif->type); + + wcn->current_vif = (struct wcn36xx_vif *)vif->drv_priv;
If you actually support two interfaces (and that looks more likely now) I don't think this "current_vif" makes any sense at all, it'll be randomly pointing to one or the other depending on which one was added last.
drivers/net/wireless/ath/wcn36xx/main.c line 703
Quoted 10 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +10
-0+static int wcn36xx_sta_add (struct ieee80211_hw *hw,struct ieee80211_vif *vif, +struct ieee80211_sta *sta) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac sta add vif %p sta %pM\n" , + vif, sta->addr); + + wcn->sta = (struct wcn36xx_sta *)sta->drv_priv; + wcn->aid = sta->aid;
You support more than one interface and AP, but there's no way this code can then be correct. It seems to me that you're really only supporting a single client interface correctly right now.
johannes
Re: [PATCH v2 01/16] wcn36xx: Add main.c
Quoted 27 lines
Quoted 11 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +11
-0+static const struct ieee80211_iface_limit if_limits[] = { + { .max =2 , .types =BIT (NL80211_IFTYPE_STATION ) }, + { .max =1 , .types =BIT (NL80211_IFTYPE_AP ) }, +}; + +static const struct ieee80211_iface_combination if_comb = { + .limits = if_limits, + .n_limits =ARRAY_SIZE (if_limits), + .max_interfaces =2 , + .num_different_channels =1 , +};drivers/net/wireless/ath/wcn36xx/main.c
Quoted 10 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +9
-0+static int wcn36xx_add_interface (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac add interface vif %p type %d\n" , + vif, vif->type); + + wcn->current_vif = (struct wcn36xx_vif *)vif->drv_priv;If you actually support two interfaces (and that looks more likely now) I don't think this "
current_vif" makes any sense at all, it'll be randomly pointing to one or the other depending on which one was added last.
Quoted 14 lines
drivers/net/wireless/ath/wcn36xx/main.c line 703
Quoted 10 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +10
-0+static int wcn36xx_sta_add (struct ieee80211_hw *hw,struct ieee80211_vif *vif, +struct ieee80211_sta *sta) +{ +struct wcn36xx *wcn = hw->priv; + +wcn36xx_dbg (WCN36XX_DBG_MAC ,"mac sta add vif %p sta %pM\n" , + vif, sta->addr); + + wcn->sta = (struct wcn36xx_sta *)sta->drv_priv; + wcn->aid = sta->aid;You support more than one interface and AP, but there's no way this code can then be correct. It seems to me that you're really only supporting a single client interface correctly right now.
Exactly. So far wcn36xx supports only one interface.
Signature · 2 lines
Best regards, Eugene
Re: [PATCH v2 01/16] wcn36xx: Add main.c
Quoted 5 lines · Eugene Krasnikov
Quoted 5 lines
Quoted 5 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +5
-0+static const struct ieee80211_iface_limit if_limits[] = { + { .max =2 , .types =BIT (NL80211_IFTYPE_STATION ) }, + { .max =1 , .types =BIT (NL80211_IFTYPE_AP ) }, +}; +
Quoted 8 lines
Quoted 6 lines
drivers/net/wireless/ath/wcn36xx/main.c line 174
Quoted 6 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +6
-0+static const struct ieee80211_iface_combination if_comb = { + .limits = if_limits, + .n_limits =ARRAY_SIZE (if_limits), + .max_interfaces =2 , + .num_different_channels =1 , +};Exactly. So far wcn36xx supports only one interface.
But you're still advertising two.
johannes
Re: [PATCH v2 01/16] wcn36xx: Add main.c
My bad. Did not clean up it completely. if_comb is a dead code and is not used anywhere. Will fix it.
2013/8/23 Johannes Berg <[email protected]>:
Quoted 20 lines · Eugene Krasnikov
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +5
-0+static const struct ieee80211_iface_limit if_limits[] = { + { .max =2 , .types =BIT (NL80211_IFTYPE_STATION ) }, + { .max =1 , .types =BIT (NL80211_IFTYPE_AP ) }, +}; +Quoted 8 lines
Quoted 6 lines
drivers/net/wireless/ath/wcn36xx/main.c line 174
Quoted 6 lines
drivers/net/wireless/ath/wcn36xx/main.c new file +6
-0+static const struct ieee80211_iface_combination if_comb = { + .limits = if_limits, + .n_limits =ARRAY_SIZE (if_limits), + .max_interfaces =2 , + .num_different_channels =1 , +};Exactly. So far wcn36xx supports only one interface.
But you're still advertising two.
johannes
Signature · 2 lines
Best regards, Eugene
PATCH v2 2/16 wcn36xx: add debug.c
In reply to Eugene Krasnikovadding debug.c file
--- drivers/net/wireless/ath/wcn36xx/debug.c | 166 +++++++++++++++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.c
drivers/net/wireless/ath/wcn36xx/debug.c new file +166 -0
@@ -0,0 +1,166 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include <linux/debugfs.h> +#include <linux/uaccess.h> +#include "wcn36xx.h" +#include "debug.h" +#include "pmc.h" + +#ifdef CONFIG_WCN36XX_DEBUGFS + +static int wcn36xx_debugfs_open (struct inode *inode,struct file *file) +{ + file->private_data = inode->i_private; + +return 0 ; +} + +static ssize_t read_file_bool_bmps (struct file *file,char __user *user_buf, +size_t count,loff_t *ppos) +{ +struct wcn36xx *wcn = file->private_data; +char buf[3 ]; + +if (wcn->pw_state ==WCN36XX_BMPS ) + buf[0 ] ='1' ; +else + buf[0 ] ='0' ; + + buf[1 ] ='\n' ; + buf[2 ] =0x00 ; + +return simple_read_from_buffer (user_buf, count, ppos, buf,2 ); +} + +static ssize_t write_file_bool_bmps (struct file *file, +const char __user *user_buf, +size_t count,loff_t *ppos) +{ +struct wcn36xx *wcn = file->private_data; +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); +char buf[32 ]; +int buf_size; + + buf_size =min (count, (sizeof (buf)-1 )); +if (copy_from_user (buf, user_buf, buf_size)) +return -EFAULT ; + +switch (buf[0 ]) { +case 'y' : +case 'Y' : +case '1' : +wcn36xx_enable_keep_alive_null_packet (wcn); +wcn36xx_pmc_enter_bmps_state (wcn, vif->bss_conf.sync_tsf); +break ; +case 'n' : +case 'N' : +case '0' : +wcn36xx_pmc_exit_bmps_state (wcn); +break ; + } + +return count; +} + +static const struct file_operations fops_wcn36xx_bmps = { + .open = wcn36xx_debugfs_open, + .read = read_file_bool_bmps, + .write = write_file_bool_bmps, +}; + +static ssize_t write_file_dump (struct file *file, +const char __user *user_buf, +size_t count,loff_t *ppos) +{ +struct wcn36xx *wcn = file->private_data; +char buf[255 ], *tmp; +int buf_size; +u32 arg[WCN36xx_MAX_DUMP_ARGS]; +int i; + +memset (buf,0 ,sizeof (buf)); +memset (arg,0 ,sizeof (arg)); + + buf_size =min (count, (sizeof (buf) -1 )); +if (copy_from_user (buf, user_buf, buf_size)) +return -EFAULT ; + + tmp = buf; + +for (i =0 ; i < WCN36xx_MAX_DUMP_ARGS; i++) { +char *begin; + begin =strsep (&tmp," " ); +if (begin ==NULL ) +break ; + +if (kstrtoul (begin,0 , (unsigned long *)(arg + i)) !=0 ) +break ; + } + +wcn36xx_info ("DUMP args is %d %d %d %d %d\n" , arg[0 ], arg[1 ], arg[2 ], + arg[3 ], arg[4 ]); +wcn36xx_smd_dump_cmd_req (wcn, arg[0 ], arg[1 ], arg[2 ], arg[3 ], arg[4 ]); + +return count; +} + +static const struct file_operations fops_wcn36xx_dump = { + .open = wcn36xx_debugfs_open, + .write = write_file_dump, +}; + +#define ADD_FILE (name, mode, fop, priv_data) \ + do { \ + struct dentry *d; \ + d = debugfs_create_file(__stringify(name), \ + mode, dfs->rootdir, \ + priv_data, fop); \ + dfs->file_##name.dentry = d; \ + if (IS_ERR(d)) { \ + wcn36xx_warn("Create the debugfs entry failed");\ + dfs->file_##name.dentry = NULL; \ + } \ + } while (0) + + +void wcn36xx_debugfs_init (struct wcn36xx *wcn) +{ +struct wcn36xx_dfs_entry *dfs = &wcn->dfs; + + dfs->rootdir =debugfs_create_dir (KBUILD_MODNAME , + wcn->hw->wiphy->debugfsdir); +if (IS_ERR (dfs->rootdir)) { +wcn36xx_warn ("Create the debugfs failed\n" ); + dfs->rootdir =NULL ; + } + +ADD_FILE (bmps_switcher,S_IRUSR |S_IWUSR , + &fops_wcn36xx_bmps, wcn); +ADD_FILE (dump,S_IWUSR , &fops_wcn36xx_dump, wcn); +} + +void wcn36xx_debugfs_exit (struct wcn36xx *wcn) +{ +struct wcn36xx_dfs_entry *dfs = &wcn->dfs; +debugfs_remove_recursive (dfs->rootdir); +} + +#endif /* CONFIG_WCN36XX_DEBUGFS */
Signature · 1 line
1.8.2.2
PATCH v2 3/16 wcn36xx: add debug.h
In reply to Eugene KrasnikovAdding debug.h
--- drivers/net/wireless/ath/wcn36xx/debug.h | 49 ++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/debug.h
drivers/net/wireless/ath/wcn36xx/debug.h new file +49 -0
@@ -0,0 +1,49 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _WCN36XX_DEBUG_H_ +#define _WCN36XX_DEBUG_H_ + +#include <linux/kernel.h> + +#define WCN36xx_MAX_DUMP_ARGS 5 + +#ifdef CONFIG_WCN36XX_DEBUGFS +struct wcn36xx_dfs_file { +struct dentry *dentry; +u32 value; +}; + +struct wcn36xx_dfs_entry { +struct dentry *rootdir; +struct wcn36xx_dfs_file file_bmps_switcher; +struct wcn36xx_dfs_file file_dump; +}; + +void wcn36xx_debugfs_init (struct wcn36xx *wcn); +void wcn36xx_debugfs_exit (struct wcn36xx *wcn); + +#else +static inline void wcn36xx_debugfs_init (struct wcn36xx *wcn) +{ +} +static inline void wcn36xx_debugfs_exit (struct wcn36xx *wcn) +{ +} + +#endif /* CONFIG_WCN36XX_DEBUGFS */ + +#endif /* _WCN36XX_DEBUG_H_ */
Signature · 1 line
1.8.2.2
PATCH v2 4/16 wcn36xx: add dxe.c
In reply to Eugene KrasnikovAdding dxe.c
--- drivers/net/wireless/ath/wcn36xx/dxe.c | 804 +++++++++++++++++++++++++++++++++ 1 file changed, 804 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.c
drivers/net/wireless/ath/wcn36xx/dxe.c new file +804 -0
@@ -0,0 +1,804 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/* DXE - DMA transfer engine +* we have 2 channels(High prio and Low prio) for TX and 2 channels for RX. +* through low channels data packets are transfered +* through high channels managment packets are transfered +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include <linux/interrupt.h> +#include "wcn36xx.h" +#include "txrx.h" + +void *wcn36xx_dxe_get_next_bd (struct wcn36xx *wcn,bool is_low) +{ +struct wcn36xx_dxe_ch *ch = is_low ? + &wcn->dxe_tx_l_ch : + &wcn->dxe_tx_h_ch; + +return ch->head_blk_ctl->bd_cpu_addr; +} + +static void wcn36xx_dxe_write_register (struct wcn36xx *wcn,int addr,int data) +{ +wcn36xx_dbg (WCN36XX_DBG_DXE , +"wcn36xx_dxe_write_register: addr=%x, data=%x\n" , + addr, data); + +writel (data, wcn->mmio + addr); +} + +static void wcn36xx_dxe_read_register (struct wcn36xx *wcn,int addr,int *data) +{ + *data =readl (wcn->mmio + addr); + +wcn36xx_dbg (WCN36XX_DBG_DXE , +"wcn36xx_dxe_read_register: addr=%x, data=%x\n" , + addr, *data); +} + +static void wcn36xx_dxe_free_ctl_block (struct wcn36xx_dxe_ch *ch) +{ +struct wcn36xx_dxe_ctl *ctl = ch->head_blk_ctl, *next; +int i; + +for (i =0 ; i < ch->desc_num && ctl; i++) { + next = ctl->next; +kfree (ctl); + ctl = next; + } +} + +static int wcn36xx_dxe_allocate_ctl_block (struct wcn36xx_dxe_ch *ch) +{ +struct wcn36xx_dxe_ctl *prev_ctl =NULL ; +struct wcn36xx_dxe_ctl *cur_ctl =NULL ; +int i; + +for (i =0 ; i < ch->desc_num; i++) { + cur_ctl =kzalloc (sizeof (*cur_ctl),GFP_KERNEL ); +if (!cur_ctl) + goto out_fail; + + cur_ctl->ctl_blk_order = i; +if (i ==0 ) { + ch->head_blk_ctl = cur_ctl; + ch->tail_blk_ctl = cur_ctl; + }else if (ch->desc_num -1 == i) { + prev_ctl->next = cur_ctl; + cur_ctl->next = ch->head_blk_ctl; + }else { + prev_ctl->next = cur_ctl; + } + prev_ctl = cur_ctl; + } + +return 0 ; + +out_fail: +wcn36xx_dxe_free_ctl_block (ch); +return -ENOMEM ; +} + +int wcn36xx_dxe_alloc_ctl_blks (struct wcn36xx *wcn) +{ +int ret; + + wcn->dxe_tx_l_ch.ch_type =WCN36XX_DXE_CH_TX_L ; + wcn->dxe_tx_h_ch.ch_type =WCN36XX_DXE_CH_TX_H ; + wcn->dxe_rx_l_ch.ch_type =WCN36XX_DXE_CH_RX_L ; + wcn->dxe_rx_h_ch.ch_type =WCN36XX_DXE_CH_RX_H ; + + wcn->dxe_tx_l_ch.desc_num =WCN36XX_DXE_CH_DESC_NUMB_TX_L ; + wcn->dxe_tx_h_ch.desc_num =WCN36XX_DXE_CH_DESC_NUMB_TX_H ; + wcn->dxe_rx_l_ch.desc_num =WCN36XX_DXE_CH_DESC_NUMB_RX_L ; + wcn->dxe_rx_h_ch.desc_num =WCN36XX_DXE_CH_DESC_NUMB_RX_H ; + + wcn->dxe_tx_l_ch.dxe_wq =WCN36XX_DXE_WQ_TX_L ; + wcn->dxe_tx_h_ch.dxe_wq =WCN36XX_DXE_WQ_TX_H ; + + wcn->dxe_tx_l_ch.ctrl_bd =WCN36XX_DXE_CTRL_TX_L_BD ; + wcn->dxe_tx_h_ch.ctrl_bd =WCN36XX_DXE_CTRL_TX_H_BD ; + + wcn->dxe_tx_l_ch.ctrl_skb =WCN36XX_DXE_CTRL_TX_L_SKB ; + wcn->dxe_tx_h_ch.ctrl_skb =WCN36XX_DXE_CTRL_TX_H_SKB ; + + wcn->dxe_tx_l_ch.reg_ctrl =WCN36XX_DXE_REG_CTL_TX_L ; + wcn->dxe_tx_h_ch.reg_ctrl =WCN36XX_DXE_REG_CTL_TX_H ; + + wcn->dxe_tx_l_ch.def_ctrl =WCN36XX_DXE_CH_DEFAULT_CTL_TX_L ; + wcn->dxe_tx_h_ch.def_ctrl =WCN36XX_DXE_CH_DEFAULT_CTL_TX_H ; + +/* DXE control block allocation */ + ret =wcn36xx_dxe_allocate_ctl_block (&wcn->dxe_tx_l_ch); +if (ret) + goto out_err; + ret =wcn36xx_dxe_allocate_ctl_block (&wcn->dxe_tx_h_ch); +if (ret) + goto out_err; + ret =wcn36xx_dxe_allocate_ctl_block (&wcn->dxe_rx_l_ch); +if (ret) + goto out_err; + ret =wcn36xx_dxe_allocate_ctl_block (&wcn->dxe_rx_h_ch); +if (ret) + goto out_err; + +/* Initialize SMSM state Clear TX Enable RING EMPTY STATE */ + ret = wcn->ctrl_ops->smsm_change_state ( +WCN36XX_SMSM_WLAN_TX_ENABLE , +WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY ); + +return 0 ; + +out_err: +wcn36xx_err ("Failed to allocate DXE control blocks\n" ); +wcn36xx_dxe_free_ctl_blks (wcn); +return -ENOMEM ; +} + +void wcn36xx_dxe_free_ctl_blks (struct wcn36xx *wcn) +{ +wcn36xx_dxe_free_ctl_block (&wcn->dxe_tx_l_ch); +wcn36xx_dxe_free_ctl_block (&wcn->dxe_tx_h_ch); +wcn36xx_dxe_free_ctl_block (&wcn->dxe_rx_l_ch); +wcn36xx_dxe_free_ctl_block (&wcn->dxe_rx_h_ch); +} + +static int wcn36xx_dxe_init_descs (struct wcn36xx_dxe_ch *wcn_ch) +{ +struct wcn36xx_dxe_desc *cur_dxe =NULL ; +struct wcn36xx_dxe_desc *prev_dxe =NULL ; +struct wcn36xx_dxe_ctl *cur_ctl =NULL ; +size_t size; +int i; + + size = wcn_ch->desc_num *sizeof (struct wcn36xx_dxe_desc ); + wcn_ch->cpu_addr =dma_alloc_coherent (NULL , size, &wcn_ch->dma_addr, +GFP_KERNEL ); +if (!wcn_ch->cpu_addr) +return -ENOMEM ; + +memset (wcn_ch->cpu_addr,0 , size); + + cur_dxe = (struct wcn36xx_dxe_desc *)wcn_ch->cpu_addr; + cur_ctl = wcn_ch->head_blk_ctl; + +for (i =0 ; i < wcn_ch->desc_num; i++) { + cur_ctl->desc = cur_dxe; + cur_ctl->desc_phy_addr = wcn_ch->dma_addr + + i *sizeof (struct wcn36xx_dxe_desc ); + +switch (wcn_ch->ch_type) { +case WCN36XX_DXE_CH_TX_L : + cur_dxe->ctrl =WCN36XX_DXE_CTRL_TX_L ; + cur_dxe->dst_addr_l =WCN36XX_DXE_WQ_TX_L ; +break ; +case WCN36XX_DXE_CH_TX_H : + cur_dxe->ctrl =WCN36XX_DXE_CTRL_TX_H ; + cur_dxe->dst_addr_l =WCN36XX_DXE_WQ_TX_H ; +break ; +case WCN36XX_DXE_CH_RX_L : + cur_dxe->ctrl =WCN36XX_DXE_CTRL_RX_L ; + cur_dxe->src_addr_l =WCN36XX_DXE_WQ_RX_L ; +break ; +case WCN36XX_DXE_CH_RX_H : + cur_dxe->ctrl =WCN36XX_DXE_CTRL_RX_H ; + cur_dxe->src_addr_l =WCN36XX_DXE_WQ_RX_H ; +break ; + } +if (0 == i) { + cur_dxe->phy_next_l =0 ; + }else if ((0 < i) && (i < wcn_ch->desc_num -1 )) { + prev_dxe->phy_next_l = + cur_ctl->desc_phy_addr; + }else if (i == (wcn_ch->desc_num -1 )) { + prev_dxe->phy_next_l = + cur_ctl->desc_phy_addr; + cur_dxe->phy_next_l = + wcn_ch->head_blk_ctl->desc_phy_addr; + } + cur_ctl = cur_ctl->next; + prev_dxe = cur_dxe; + cur_dxe++; + } + +return 0 ; +} + +static void wcn36xx_dxe_init_tx_bd (struct wcn36xx_dxe_ch *ch, +struct wcn36xx_dxe_mem_pool *pool) +{ +int i, chunk_size = pool->chunk_size; +dma_addr_t bd_phy_addr = pool->phy_addr; +void *bd_cpu_addr = pool->virt_addr; +struct wcn36xx_dxe_ctl *cur = ch->head_blk_ctl; + +for (i =0 ; i < ch->desc_num; i++) { +/* Only every second dxe needs a bd pointer, +the other will point to the skb data */ +if (!(i &1 )) { + cur->bd_phy_addr = bd_phy_addr; + cur->bd_cpu_addr = bd_cpu_addr; + bd_phy_addr += chunk_size; + bd_cpu_addr += chunk_size; + }else { + cur->bd_phy_addr =0 ; + cur->bd_cpu_addr =NULL ; + } + cur = cur->next; + } +} + +static int wcn36xx_dxe_enable_ch_int (struct wcn36xx *wcn,u16 wcn_ch) +{ +int reg_data =0 ; + +wcn36xx_dxe_read_register (wcn, +WCN36XX_DXE_INT_MASK_REG , + ®_data); + + reg_data |= wcn_ch; + +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_INT_MASK_REG , + (int )reg_data); +return 0 ; +} + +static int wcn36xx_dxe_fill_skb (struct wcn36xx_dxe_ctl *ctl) +{ +struct wcn36xx_dxe_desc *dxe = ctl->desc; +struct sk_buff *skb; + + skb =alloc_skb (WCN36XX_PKT_SIZE ,GFP_ATOMIC ); +if (skb ==NULL ) +return -ENOMEM ; + + dxe->dst_addr_l =dma_map_single (NULL , +skb_tail_pointer (skb), +WCN36XX_PKT_SIZE , +DMA_FROM_DEVICE ); + ctl->skb = skb; + +return 0 ; +} + +static int wcn36xx_dxe_ch_alloc_skb (struct wcn36xx *wcn, +struct wcn36xx_dxe_ch *wcn_ch) +{ +int i; +struct wcn36xx_dxe_ctl *cur_ctl =NULL ; + + cur_ctl = wcn_ch->head_blk_ctl; + +for (i =0 ; i < wcn_ch->desc_num; i++) { +wcn36xx_dxe_fill_skb (cur_ctl); + cur_ctl = cur_ctl->next; + } + +return 0 ; +} + +static void wcn36xx_dxe_ch_free_skbs (struct wcn36xx *wcn, +struct wcn36xx_dxe_ch *wcn_ch) +{ +struct wcn36xx_dxe_ctl *cur = wcn_ch->head_blk_ctl; +int i; + +for (i =0 ; i < wcn_ch->desc_num; i++) { +kfree_skb (cur->skb); + cur = cur->next; + } +} + +void wcn36xx_dxe_tx_ack_ind (struct wcn36xx *wcn,u32 status) +{ +struct ieee80211_tx_info *info; +struct sk_buff *skb; +unsigned long flags; + +spin_lock_irqsave (&wcn->dxe_lock, flags); + skb = wcn->tx_ack_skb; + wcn->tx_ack_skb =NULL ; +spin_unlock_irqrestore (&wcn->dxe_lock, flags); + +if (!skb) { +wcn36xx_warn ("Spurious TX complete indication\n" ); +return ; + } + + info =IEEE80211_SKB_CB (skb); + +if (status ==1 ) + info->flags |=IEEE80211_TX_STAT_ACK ; + +wcn36xx_dbg (WCN36XX_DBG_DXE ,"dxe tx ack status: %d\n" , status); + +ieee80211_tx_status_irqsafe (wcn->hw, skb); +ieee80211_wake_queues (wcn->hw); +} + +static void reap_tx_dxes (struct wcn36xx *wcn,struct wcn36xx_dxe_ch *ch) +{ +struct wcn36xx_dxe_ctl *ctl = ch->tail_blk_ctl; +struct ieee80211_tx_info *info; +unsigned long flags; + +/* +* Make at least one loop of do-while because in case ring is +* completely full head and tail are pointing to the same element +* and while-do will not make any cycles. +*/ +do { +if (ctl->skb) { +dma_unmap_single (NULL , ctl->desc->src_addr_l, + ctl->skb->len,DMA_TO_DEVICE ); + info =IEEE80211_SKB_CB (ctl->skb); +if (!(info->flags &IEEE80211_TX_CTL_REQ_TX_STATUS )) { +/* Keep frame until TX status comes */ +ieee80211_free_txskb (wcn->hw, ctl->skb); + } +spin_lock_irqsave (&ctl->skb_lock, flags); +if (wcn->queues_stopped) { + wcn->queues_stopped = false; +ieee80211_wake_queues (wcn->hw); + } +spin_unlock_irqrestore (&ctl->skb_lock, flags); + + ctl->skb =NULL ; + } + ctl = ctl->next; + }while (ctl != ch->head_blk_ctl && + !(ctl->desc->ctrl &WCN36XX_DXE_CTRL_VALID_MASK )); + + ch->tail_blk_ctl = ctl; +} + +static irqreturn_t wcn36xx_irq_tx_complete (int irq,void *dev) +{ +struct wcn36xx *wcn = (struct wcn36xx *)dev; +int int_src, int_reason; + +wcn36xx_dxe_read_register (wcn,WCN36XX_DXE_INT_SRC_RAW_REG , &int_src); + +if (int_src &WCN36XX_INT_MASK_CHAN_TX_H ) { +wcn36xx_dxe_read_register (wcn, +WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_H , + &int_reason); + +/* TODO: Check int_reason */ + +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_0_INT_CLR , +WCN36XX_INT_MASK_CHAN_TX_H ); + +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_0_INT_ED_CLR , +WCN36XX_INT_MASK_CHAN_TX_H ); +wcn36xx_dbg (WCN36XX_DBG_DXE ,"dxe tx ready high\n" ); +reap_tx_dxes (wcn, &wcn->dxe_tx_h_ch); + } + +if (int_src &WCN36XX_INT_MASK_CHAN_TX_L ) { +wcn36xx_dxe_read_register (wcn, +WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_L , + &int_reason); +/* TODO: Check int_reason */ + +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_0_INT_CLR , +WCN36XX_INT_MASK_CHAN_TX_L ); + +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_0_INT_ED_CLR , +WCN36XX_INT_MASK_CHAN_TX_L ); +wcn36xx_dbg (WCN36XX_DBG_DXE ,"dxe tx ready low\n" ); +reap_tx_dxes (wcn, &wcn->dxe_tx_l_ch); + } + +return IRQ_HANDLED ; +} + +static irqreturn_t wcn36xx_irq_rx_ready (int irq,void *dev) +{ +struct wcn36xx *wcn = (struct wcn36xx *)dev; + +disable_irq_nosync (wcn->rx_irq); +wcn36xx_dxe_rx_frame (wcn); +enable_irq (wcn->rx_irq); +return IRQ_HANDLED ; +} + +static int wcn36xx_dxe_request_irqs (struct wcn36xx *wcn) +{ +int ret; + + ret =request_irq (wcn->tx_irq, wcn36xx_irq_tx_complete, +IRQF_TRIGGER_HIGH ,"wcn36xx_tx" , wcn); +if (ret) { +wcn36xx_err ("failed to alloc tx irq\n" ); + goto out_err; + } + + ret =request_irq (wcn->rx_irq, wcn36xx_irq_rx_ready,IRQF_TRIGGER_HIGH , +"wcn36xx_rx" , wcn); +if (ret) { +wcn36xx_err ("failed to alloc rx irq\n" ); + goto out_txirq; + } + +enable_irq_wake (wcn->rx_irq); + +return 0 ; + +out_txirq: +free_irq (wcn->tx_irq, wcn); +out_err: +return ret; + +} + +static int wcn36xx_rx_handle_packets (struct wcn36xx *wcn, +struct wcn36xx_dxe_ch *ch) +{ +struct wcn36xx_dxe_ctl *ctl = ch->head_blk_ctl; +struct wcn36xx_dxe_desc *dxe = ctl->desc; +dma_addr_t dma_addr; +struct sk_buff *skb; + +while (!(dxe->ctrl &WCN36XX_DXE_CTRL_VALID_MASK )) { + skb = ctl->skb; + dma_addr = dxe->dst_addr_l; +wcn36xx_dxe_fill_skb (ctl); + +switch (ch->ch_type) { +case WCN36XX_DXE_CH_RX_L : + dxe->ctrl =WCN36XX_DXE_CTRL_RX_L ; +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_ENCH_ADDR , +WCN36XX_DXE_INT_CH1_MASK ); +break ; +case WCN36XX_DXE_CH_RX_H : + dxe->ctrl =WCN36XX_DXE_CTRL_RX_H ; +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_ENCH_ADDR , +WCN36XX_DXE_INT_CH3_MASK ); +break ; +default : +wcn36xx_warn ("Unknown channel\n" ); + } + +dma_unmap_single (NULL , dma_addr,WCN36XX_PKT_SIZE , +DMA_FROM_DEVICE ); +wcn36xx_rx_skb (wcn, skb); + ctl = ctl->next; + dxe = ctl->desc; + } + + ch->head_blk_ctl = ctl; + +return 0 ; +} + +void wcn36xx_dxe_rx_frame (struct wcn36xx *wcn) +{ +int int_src; + +wcn36xx_dxe_read_register (wcn,WCN36XX_DXE_INT_SRC_RAW_REG , &int_src); + +/* RX_LOW_PRI */ +if (int_src &WCN36XX_DXE_INT_CH1_MASK ) { +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_0_INT_CLR , +WCN36XX_DXE_INT_CH1_MASK ); +wcn36xx_rx_handle_packets (wcn, &(wcn->dxe_rx_l_ch)); + } + +/* RX_HIGH_PRI */ +if (int_src &WCN36XX_DXE_INT_CH3_MASK ) { +/* Clean up all the INT within this channel */ +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_0_INT_CLR , +WCN36XX_DXE_INT_CH3_MASK ); +wcn36xx_rx_handle_packets (wcn, &(wcn->dxe_rx_h_ch)); + } + +if (!int_src) +wcn36xx_warn ("No DXE interrupt pending\n" ); +} + +int wcn36xx_dxe_allocate_mem_pools (struct wcn36xx *wcn) +{ +size_t s; +void *cpu_addr; + +/* Allocate BD headers for MGMT frames */ + +/* Where this come from ask QC */ + wcn->mgmt_mem_pool.chunk_size =WCN36XX_BD_CHUNK_SIZE + +16 - (WCN36XX_BD_CHUNK_SIZE %8 ); + + s = wcn->mgmt_mem_pool.chunk_size *WCN36XX_DXE_CH_DESC_NUMB_TX_H ; + cpu_addr =dma_alloc_coherent (NULL , s, &wcn->mgmt_mem_pool.phy_addr, +GFP_KERNEL ); +if (!cpu_addr) + goto out_err; + + wcn->mgmt_mem_pool.virt_addr = cpu_addr; +memset (cpu_addr,0 , s); + +/* Allocate BD headers for DATA frames */ + +/* Where this come from ask QC */ + wcn->data_mem_pool.chunk_size =WCN36XX_BD_CHUNK_SIZE + +16 - (WCN36XX_BD_CHUNK_SIZE %8 ); + + s = wcn->data_mem_pool.chunk_size *WCN36XX_DXE_CH_DESC_NUMB_TX_L ; + cpu_addr =dma_alloc_coherent (NULL , s, &wcn->data_mem_pool.phy_addr, +GFP_KERNEL ); +if (!cpu_addr) + goto out_err; + + wcn->data_mem_pool.virt_addr = cpu_addr; +memset (cpu_addr,0 , s); + +return 0 ; + +out_err: +wcn36xx_dxe_free_mem_pools (wcn); +wcn36xx_err ("Failed to allocate BD mempool\n" ); +return -ENOMEM ; +} + +void wcn36xx_dxe_free_mem_pools (struct wcn36xx *wcn) +{ +if (wcn->mgmt_mem_pool.virt_addr) +dma_free_coherent (NULL , wcn->mgmt_mem_pool.chunk_size * +WCN36XX_DXE_CH_DESC_NUMB_TX_H , + wcn->mgmt_mem_pool.virt_addr, + wcn->mgmt_mem_pool.phy_addr); + +if (wcn->data_mem_pool.virt_addr) { +dma_free_coherent (NULL , wcn->data_mem_pool.chunk_size * +WCN36XX_DXE_CH_DESC_NUMB_TX_L , + wcn->data_mem_pool.virt_addr, + wcn->data_mem_pool.phy_addr); + } +} + +int wcn36xx_dxe_tx_frame (struct wcn36xx *wcn, +struct sk_buff *skb, +bool is_low) +{ +struct wcn36xx_dxe_ctl *ctl =NULL ; +struct wcn36xx_dxe_desc *desc =NULL ; +struct wcn36xx_dxe_ch *ch =NULL ; +unsigned long flags; + + ch = is_low ? &wcn->dxe_tx_l_ch : &wcn->dxe_tx_h_ch; + + ctl = ch->head_blk_ctl; + +spin_lock_irqsave (&ctl->next->skb_lock, flags); + +/* +* If skb is not null that means that we reached the tail of the ring +* hence ring is full. Stop queues to let mac80211 back off until ring +* has an empty slot again. +*/ +if (NULL != ctl->next->skb) { +ieee80211_stop_queues (wcn->hw); + wcn->queues_stopped = true; +spin_unlock_irqrestore (&ctl->next->skb_lock, flags); +return -EBUSY ; + } +spin_unlock_irqrestore (&ctl->next->skb_lock, flags); + + ctl->skb =NULL ; + desc = ctl->desc; + +/* Set source address of the BD we send */ + desc->src_addr_l = ctl->bd_phy_addr; + + desc->dst_addr_l = ch->dxe_wq; + desc->fr_len =sizeof (struct wcn36xx_tx_bd ); + desc->ctrl = ch->ctrl_bd; + +wcn36xx_dbg (WCN36XX_DBG_DXE ,"DXE TX\n" ); + +wcn36xx_dbg_dump (WCN36XX_DBG_DXE_DUMP ,"DESC1 >>> " , + (char *)desc,sizeof (*desc)); +wcn36xx_dbg_dump (WCN36XX_DBG_DXE_DUMP , +"BD >>> " , (char *)ctl->bd_cpu_addr, +sizeof (struct wcn36xx_tx_bd )); + +/* Set source address of the SKB we send */ + ctl = ctl->next; + ctl->skb = skb; + desc = ctl->desc; +if (ctl->bd_cpu_addr) { +wcn36xx_err ("bd_cpu_addr cannot be NULL for skb DXE\n" ); +return -EINVAL ; + } + + desc->src_addr_l =dma_map_single (NULL , + ctl->skb->data, + ctl->skb->len, +DMA_TO_DEVICE ); + + desc->dst_addr_l = ch->dxe_wq; + desc->fr_len = ctl->skb->len; + +/* set dxe descriptor to VALID */ + desc->ctrl = ch->ctrl_skb; + +wcn36xx_dbg_dump (WCN36XX_DBG_DXE_DUMP ,"DESC2 >>> " , + (char *)desc,sizeof (*desc)); +wcn36xx_dbg_dump (WCN36XX_DBG_DXE_DUMP ,"SKB >>> " , + (char *)ctl->skb->data, ctl->skb->len); + +/* Move the head of the ring to the next empty descriptor */ + ch->head_blk_ctl = ctl->next; + +/* +* When connected and trying to send data frame chip can be in sleep +* mode and writing to the register will not wake up the chip. Instead +* notify chip about new frame through SMSM bus. +*/ +if (wcn->pw_state ==WCN36XX_BMPS ) { + wcn->ctrl_ops->smsm_change_state ( +0 , +WCN36XX_SMSM_WLAN_TX_ENABLE ); + }else { +/* indicate End Of Packet and generate interrupt on descriptor +* done. +*/ +wcn36xx_dxe_write_register (wcn, + ch->reg_ctrl, ch->def_ctrl); + } + +return 0 ; +} + +int wcn36xx_dxe_init (struct wcn36xx *wcn) +{ +int reg_data =0 , ret; + + reg_data =WCN36XX_DXE_REG_RESET ; +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_REG_CSR_RESET , reg_data); + +/* Setting interrupt path */ + reg_data =WCN36XX_DXE_CCU_INT ; +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_REG_CCU_INT , reg_data); + +/***************************************/ +/* Init descriptors for TX LOW channel */ +/***************************************/ +wcn36xx_dxe_init_descs (&wcn->dxe_tx_l_ch); +wcn36xx_dxe_init_tx_bd (&wcn->dxe_tx_l_ch, &wcn->data_mem_pool); + +/* Write channel head to a NEXT register */ +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_L , + wcn->dxe_tx_l_ch.head_blk_ctl->desc_phy_addr); + +/* Program DMA destination addr for TX LOW */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_DEST_ADDR_TX_L , +WCN36XX_DXE_WQ_TX_L ); + +wcn36xx_dxe_read_register (wcn,WCN36XX_DXE_REG_CH_EN , ®_data); +wcn36xx_dxe_enable_ch_int (wcn,WCN36XX_INT_MASK_CHAN_TX_L ); + +/***************************************/ +/* Init descriptors for TX HIGH channel */ +/***************************************/ +wcn36xx_dxe_init_descs (&wcn->dxe_tx_h_ch); +wcn36xx_dxe_init_tx_bd (&wcn->dxe_tx_h_ch, &wcn->mgmt_mem_pool); + +/* Write channel head to a NEXT register */ +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_H , + wcn->dxe_tx_h_ch.head_blk_ctl->desc_phy_addr); + +/* Program DMA destination addr for TX HIGH */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_DEST_ADDR_TX_H , +WCN36XX_DXE_WQ_TX_H ); + +wcn36xx_dxe_read_register (wcn,WCN36XX_DXE_REG_CH_EN , ®_data); + +/* Enable channel interrupts */ +wcn36xx_dxe_enable_ch_int (wcn,WCN36XX_INT_MASK_CHAN_TX_H ); + +/***************************************/ +/* Init descriptors for RX LOW channel */ +/***************************************/ +wcn36xx_dxe_init_descs (&wcn->dxe_rx_l_ch); + +/* For RX we need to preallocated buffers */ +wcn36xx_dxe_ch_alloc_skb (wcn, &wcn->dxe_rx_l_ch); + +/* Write channel head to a NEXT register */ +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_L , + wcn->dxe_rx_l_ch.head_blk_ctl->desc_phy_addr); + +/* Write DMA source address */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_SRC_ADDR_RX_L , +WCN36XX_DXE_WQ_RX_L ); + +/* Program preallocated destination address */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_DEST_ADDR_RX_L , + wcn->dxe_rx_l_ch.head_blk_ctl->desc->phy_next_l); + +/* Enable default control registers */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_REG_CTL_RX_L , +WCN36XX_DXE_CH_DEFAULT_CTL_RX_L ); + +/* Enable channel interrupts */ +wcn36xx_dxe_enable_ch_int (wcn,WCN36XX_INT_MASK_CHAN_RX_L ); + +/***************************************/ +/* Init descriptors for RX HIGH channel */ +/***************************************/ +wcn36xx_dxe_init_descs (&wcn->dxe_rx_h_ch); + +/* For RX we need to prealocat buffers */ +wcn36xx_dxe_ch_alloc_skb (wcn, &wcn->dxe_rx_h_ch); + +/* Write chanel head to a NEXT register */ +wcn36xx_dxe_write_register (wcn,WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_H , + wcn->dxe_rx_h_ch.head_blk_ctl->desc_phy_addr); + +/* Write DMA source address */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_SRC_ADDR_RX_H , +WCN36XX_DXE_WQ_RX_H ); + +/* Program preallocated destination address */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_CH_DEST_ADDR_RX_H , + wcn->dxe_rx_h_ch.head_blk_ctl->desc->phy_next_l); + +/* Enable default control registers */ +wcn36xx_dxe_write_register (wcn, +WCN36XX_DXE_REG_CTL_RX_H , +WCN36XX_DXE_CH_DEFAULT_CTL_RX_H ); + +/* Enable channel interrupts */ +wcn36xx_dxe_enable_ch_int (wcn,WCN36XX_INT_MASK_CHAN_RX_H ); + + ret =wcn36xx_dxe_request_irqs (wcn); +if (ret <0 ) + goto out_err; + +return 0 ; + +out_err: +return ret; +} + +void wcn36xx_dxe_deinit (struct wcn36xx *wcn) +{ +free_irq (wcn->tx_irq, wcn); +free_irq (wcn->rx_irq, wcn); + +if (wcn->tx_ack_skb) { +ieee80211_tx_status_irqsafe (wcn->hw, wcn->tx_ack_skb); + wcn->tx_ack_skb =NULL ; + } + +wcn36xx_dxe_ch_free_skbs (wcn, &wcn->dxe_rx_l_ch); +wcn36xx_dxe_ch_free_skbs (wcn, &wcn->dxe_rx_h_ch); +}
Signature · 1 line
1.8.2.2
PATCH v2 5/16 wcn36xx: add dxe.h
In reply to Eugene KrasnikovAdding dxe.h
--- drivers/net/wireless/ath/wcn36xx/dxe.h | 281 +++++++++++++++++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/dxe.h
drivers/net/wireless/ath/wcn36xx/dxe.h new file +281 -0
@@ -0,0 +1,281 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _DXE_H_ +#define _DXE_H_ + +#include "wcn36xx.h" + +/* +TX_LOW = DMA0 +TX_HIGH = DMA4 +RX_LOW = DMA1 +RX_HIGH = DMA3 +H2H_TEST_RX_TX = DMA2 +*/ + +/* DXE registers */ +#define WCN36XX_DXE_MEM_BASE 0x03000000 +#define WCN36XX_DXE_MEM_REG 0x202000 + +#define WCN36XX_DXE_CCU_INT 0xA0011 +#define WCN36XX_DXE_REG_CCU_INT 0x200b10 + +/* TODO This must calculated properly but not hardcoded */ +#define WCN36XX_DXE_CTRL_TX_L 0x328a44 +#define WCN36XX_DXE_CTRL_TX_H 0x32ce44 +#define WCN36XX_DXE_CTRL_RX_L 0x12ad2f +#define WCN36XX_DXE_CTRL_RX_H 0x12d12f +#define WCN36XX_DXE_CTRL_TX_H_BD 0x30ce45 +#define WCN36XX_DXE_CTRL_TX_H_SKB 0x32ce4d +#define WCN36XX_DXE_CTRL_TX_L_BD 0x308a45 +#define WCN36XX_DXE_CTRL_TX_L_SKB 0x328a4d + +/* TODO This must calculated properly but not hardcoded */ +#define WCN36XX_DXE_WQ_TX_L 0x17 +#define WCN36XX_DXE_WQ_TX_H 0x17 +#define WCN36XX_DXE_WQ_RX_L 0xB +#define WCN36XX_DXE_WQ_RX_H 0x4 + +/* DXE descriptor control filed */ +#define WCN36XX_DXE_CTRL_VALID_MASK (0x00000001) + +/* TODO This must calculated properly but not hardcoded */ +/* DXE default control register values */ +#define WCN36XX_DXE_CH_DEFAULT_CTL_RX_L 0x847EAD2F +#define WCN36XX_DXE_CH_DEFAULT_CTL_RX_H 0x84FED12F +#define WCN36XX_DXE_CH_DEFAULT_CTL_TX_H 0x853ECF4D +#define WCN36XX_DXE_CH_DEFAULT_CTL_TX_L 0x843e8b4d + +/* Common DXE registers */ +#define WCN36XX_DXE_MEM_CSR (WCN36XX_DXE_MEM_REG + 0x00) +#define WCN36XX_DXE_REG_CSR_RESET (WCN36XX_DXE_MEM_REG + 0x00) +#define WCN36XX_DXE_ENCH_ADDR (WCN36XX_DXE_MEM_REG + 0x04) +#define WCN36XX_DXE_REG_CH_EN (WCN36XX_DXE_MEM_REG + 0x08) +#define WCN36XX_DXE_REG_CH_DONE (WCN36XX_DXE_MEM_REG + 0x0C) +#define WCN36XX_DXE_REG_CH_ERR (WCN36XX_DXE_MEM_REG + 0x10) +#define WCN36XX_DXE_INT_MASK_REG (WCN36XX_DXE_MEM_REG + 0x18) +#define WCN36XX_DXE_INT_SRC_RAW_REG (WCN36XX_DXE_MEM_REG + 0x20) +/* #define WCN36XX_DXE_INT_CH6_MASK 0x00000040 */ +/* #define WCN36XX_DXE_INT_CH5_MASK 0x00000020 */ +#define WCN36XX_DXE_INT_CH4_MASK 0x00000010 +#define WCN36XX_DXE_INT_CH3_MASK 0x00000008 +/* #define WCN36XX_DXE_INT_CH2_MASK 0x00000004 */ +#define WCN36XX_DXE_INT_CH1_MASK 0x00000002 +#define WCN36XX_DXE_INT_CH0_MASK 0x00000001 +#define WCN36XX_DXE_0_INT_CLR (WCN36XX_DXE_MEM_REG + 0x30) +#define WCN36XX_DXE_0_INT_ED_CLR (WCN36XX_DXE_MEM_REG + 0x34) +#define WCN36XX_DXE_0_INT_DONE_CLR (WCN36XX_DXE_MEM_REG + 0x38) +#define WCN36XX_DXE_0_INT_ERR_CLR (WCN36XX_DXE_MEM_REG + 0x3C) + +#define WCN36XX_DXE_0_CH0_STATUS (WCN36XX_DXE_MEM_REG + 0x404) +#define WCN36XX_DXE_0_CH1_STATUS (WCN36XX_DXE_MEM_REG + 0x444) +#define WCN36XX_DXE_0_CH2_STATUS (WCN36XX_DXE_MEM_REG + 0x484) +#define WCN36XX_DXE_0_CH3_STATUS (WCN36XX_DXE_MEM_REG + 0x4C4) +#define WCN36XX_DXE_0_CH4_STATUS (WCN36XX_DXE_MEM_REG + 0x504) + +#define WCN36XX_DXE_REG_RESET 0x5c89 + +/* Temporary BMU Workqueue 4 */ +#define WCN36XX_DXE_BMU_WQ_RX_LOW 0xB +#define WCN36XX_DXE_BMU_WQ_RX_HIGH 0x4 +/* DMA channel offset */ +#define WCN36XX_DXE_TX_LOW_OFFSET 0x400 +#define WCN36XX_DXE_TX_HIGH_OFFSET 0x500 +#define WCN36XX_DXE_RX_LOW_OFFSET 0x440 +#define WCN36XX_DXE_RX_HIGH_OFFSET 0x4C0 + +/* Address of the next DXE descriptor */ +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR 0x001C +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_LOW_OFFSET + \ + WCN36XX_DXE_CH_NEXT_DESC_ADDR) +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_NEXT_DESC_ADDR) +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_LOW_OFFSET + \ + WCN36XX_DXE_CH_NEXT_DESC_ADDR) +#define WCN36XX_DXE_CH_NEXT_DESC_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_NEXT_DESC_ADDR) + +/* DXE Descriptor source address */ +#define WCN36XX_DXE_CH_SRC_ADDR 0x000C +#define WCN36XX_DXE_CH_SRC_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_LOW_OFFSET + \ + WCN36XX_DXE_CH_SRC_ADDR) +#define WCN36XX_DXE_CH_SRC_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_SRC_ADDR) + +/* DXE Descriptor address destination address */ +#define WCN36XX_DXE_CH_DEST_ADDR 0x0014 +#define WCN36XX_DXE_CH_DEST_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_LOW_OFFSET + \ + WCN36XX_DXE_CH_DEST_ADDR) +#define WCN36XX_DXE_CH_DEST_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_DEST_ADDR) +#define WCN36XX_DXE_CH_DEST_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_LOW_OFFSET + \ + WCN36XX_DXE_CH_DEST_ADDR) +#define WCN36XX_DXE_CH_DEST_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_DEST_ADDR) + +/* Interrupt status */ +#define WCN36XX_DXE_CH_STATUS_REG_ADDR 0x0004 +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_LOW_OFFSET + \ + WCN36XX_DXE_CH_STATUS_REG_ADDR) +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_TX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_STATUS_REG_ADDR) +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_RX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_LOW_OFFSET + \ + WCN36XX_DXE_CH_STATUS_REG_ADDR) +#define WCN36XX_DXE_CH_STATUS_REG_ADDR_RX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_HIGH_OFFSET + \ + WCN36XX_DXE_CH_STATUS_REG_ADDR) + + +/* DXE default control register */ +#define WCN36XX_DXE_REG_CTL_RX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_LOW_OFFSET) +#define WCN36XX_DXE_REG_CTL_RX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_RX_HIGH_OFFSET) +#define WCN36XX_DXE_REG_CTL_TX_H (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_HIGH_OFFSET) +#define WCN36XX_DXE_REG_CTL_TX_L (WCN36XX_DXE_MEM_REG + \ + WCN36XX_DXE_TX_LOW_OFFSET) + +#define WCN36XX_SMSM_WLAN_TX_ENABLE 0x00000400 +#define WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY 0x00000200 + + +/* Interrupt control channel mask */ +#define WCN36XX_INT_MASK_CHAN_TX_L 0x00000001 +#define WCN36XX_INT_MASK_CHAN_RX_L 0x00000002 +#define WCN36XX_INT_MASK_CHAN_RX_H 0x00000008 +#define WCN36XX_INT_MASK_CHAN_TX_H 0x00000010 + +#define WCN36XX_BD_CHUNK_SIZE 128 + +#define WCN36XX_PKT_SIZE 0xF20 +enum wcn36xx_dxe_ch_type { +WCN36XX_DXE_CH_TX_L , +WCN36XX_DXE_CH_TX_H , +WCN36XX_DXE_CH_RX_L , +WCN36XX_DXE_CH_RX_H +}; + +/* amount of descriptors per channel */ +enum wcn36xx_dxe_ch_desc_num { +WCN36XX_DXE_CH_DESC_NUMB_TX_L =128 , +WCN36XX_DXE_CH_DESC_NUMB_TX_H =10 , +WCN36XX_DXE_CH_DESC_NUMB_RX_L =512 , +WCN36XX_DXE_CH_DESC_NUMB_RX_H =40 +}; + +/** +* struct wcn36xx_dxe_desc - describes descriptor of one DXE buffer +* +* @ctrl: is a union that consists of following bits: +* union { +* u32 valid :1; //0 = DMA stop, 1 = DMA continue with this +* //descriptor +* u32 transfer_type :2; //0 = Host to Host space +* u32 eop :1; //End of Packet +* u32 bd_handling :1; //if transferType = Host to BMU, then 0 +* // means first 128 bytes contain BD, and 1 +* // means create new empty BD +* u32 siq :1; // SIQ +* u32 diq :1; // DIQ +* u32 pdu_rel :1; //0 = don't release BD and PDUs when done, +* // 1 = release them +* u32 bthld_sel :4; //BMU Threshold Select +* u32 prio :3; //Specifies the priority level to use for +* // the transfer +* u32 stop_channel :1; //1 = DMA stops processing further, channel +* //requires re-enabling after this +* u32 intr :1; //Interrupt on Descriptor Done +* u32 rsvd :1; //reserved +* u32 size :14;//14 bits used - ignored for BMU transfers, +* //only used for host to host transfers? +* } ctrl; +*/ +struct wcn36xx_dxe_desc { +u32 ctrl; +u32 fr_len; + +u32 src_addr_l; +u32 dst_addr_l; +u32 phy_next_l; +u32 src_addr_h; +u32 dst_addr_h; +u32 phy_next_h; +} __packed; + +/* DXE Control block */ +struct wcn36xx_dxe_ctl { +struct wcn36xx_dxe_ctl *next; +struct wcn36xx_dxe_desc *desc; +unsigned int desc_phy_addr; +int ctl_blk_order; +struct sk_buff *skb; +spinlock_t skb_lock; +void *bd_cpu_addr; +dma_addr_t bd_phy_addr; +}; + +struct wcn36xx_dxe_ch { +enum wcn36xx_dxe_ch_type ch_type; +void *cpu_addr; +dma_addr_t dma_addr; +enum wcn36xx_dxe_ch_desc_num desc_num; +/* DXE control block ring */ +struct wcn36xx_dxe_ctl *head_blk_ctl; +struct wcn36xx_dxe_ctl *tail_blk_ctl; + +/* DXE channel specific configs */ +u32 dxe_wq; +u32 ctrl_bd; +u32 ctrl_skb; +u32 reg_ctrl; +u32 def_ctrl; +}; + +/* Memory Pool for BD headers */ +struct wcn36xx_dxe_mem_pool { +int chunk_size; +void *virt_addr; +dma_addr_t phy_addr; +}; +int wcn36xx_dxe_allocate_mem_pools (struct wcn36xx *wcn); +void wcn36xx_dxe_free_mem_pools (struct wcn36xx *wcn); +void wcn36xx_dxe_rx_frame (struct wcn36xx *wcn); +int wcn36xx_dxe_alloc_ctl_blks (struct wcn36xx *wcn); +void wcn36xx_dxe_free_ctl_blks (struct wcn36xx *wcn); +int wcn36xx_dxe_init (struct wcn36xx *wcn); +void wcn36xx_dxe_deinit (struct wcn36xx *wcn); +int wcn36xx_dxe_init_channels (struct wcn36xx *wcn); +int wcn36xx_dxe_tx_frame (struct wcn36xx *wcn, +struct sk_buff *skb, +bool is_low); +void wcn36xx_dxe_tx_ack_ind (struct wcn36xx *wcn,u32 status); +void *wcn36xx_dxe_get_next_bd (struct wcn36xx *wcn,bool is_low); +#endif /* _DXE_H_ */
Signature · 1 line
1.8.2.2
PATCH v2 6/16 wcn36xx: add hal.h
In reply to Eugene KrasnikovAdding hal.h
--- drivers/net/wireless/ath/wcn36xx/hal.h | 4657 ++++++++++++++++++++++++++++++++ 1 file changed, 4657 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/hal.h
drivers/net/wireless/ath/wcn36xx/hal.h new file +4657 -0
@@ -0,0 +1,4657 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _HAL_H_ +#define _HAL_H_ + +/*--------------------------------------------------------------------------- + API VERSIONING INFORMATION + + The RIVA API is versioned as MAJOR.MINOR.VERSION.REVISION + The MAJOR is incremented for major product/architecture changes + (and then MINOR/VERSION/REVISION are zeroed) + The MINOR is incremented for minor product/architecture changes + (and then VERSION/REVISION are zeroed) + The VERSION is incremented if a significant API change occurs + (and then REVISION is zeroed) + The REVISION is incremented if an insignificant API change occurs + or if a new API is added + All values are in the range 0..255 (ie they are 8-bit values) + ---------------------------------------------------------------------------*/ +#define WCN36XX_HAL_VER_MAJOR 1 +#define WCN36XX_HAL_VER_MINOR 4 +#define WCN36XX_HAL_VER_VERSION 1 +#define WCN36XX_HAL_VER_REVISION 2 + +/* This is to force compiler to use the maximum of an int ( 4 bytes ) */ +#define WCN36XX_HAL_MAX_ENUM_SIZE 0x7FFFFFFF +#define WCN36XX_HAL_MSG_TYPE_MAX_ENUM_SIZE 0x7FFF + +/* Max no. of transmit categories */ +#define STACFG_MAX_TC 8 + +/* The maximum value of access category */ +#define WCN36XX_HAL_MAX_AC 4 + +#define WCN36XX_HAL_IPV4_ADDR_LEN 4 + +#define WALN_HAL_STA_INVALID_IDX 0xFF +#define WCN36XX_HAL_BSS_INVALID_IDX 0xFF + +/* Default Beacon template size */ +#define BEACON_TEMPLATE_SIZE 0x180 + +/* Param Change Bitmap sent to HAL */ +#define PARAM_BCN_INTERVAL_CHANGED (1 << 0) +#define PARAM_SHORT_PREAMBLE_CHANGED (1 << 1) +#define PARAM_SHORT_SLOT_TIME_CHANGED (1 << 2) +#define PARAM_llACOEXIST_CHANGED (1 << 3) +#define PARAM_llBCOEXIST_CHANGED (1 << 4) +#define PARAM_llGCOEXIST_CHANGED (1 << 5) +#define PARAM_HT20MHZCOEXIST_CHANGED (1<<6) +#define PARAM_NON_GF_DEVICES_PRESENT_CHANGED (1<<7) +#define PARAM_RIFS_MODE_CHANGED (1<<8) +#define PARAM_LSIG_TXOP_FULL_SUPPORT_CHANGED (1<<9) +#define PARAM_OBSS_MODE_CHANGED (1<<10) +#define PARAM_BEACON_UPDATE_MASK \ + (PARAM_BCN_INTERVAL_CHANGED | \ + PARAM_SHORT_PREAMBLE_CHANGED | \ + PARAM_SHORT_SLOT_TIME_CHANGED | \ + PARAM_llACOEXIST_CHANGED | \ + PARAM_llBCOEXIST_CHANGED | \ + PARAM_llGCOEXIST_CHANGED | \ + PARAM_HT20MHZCOEXIST_CHANGED | \ + PARAM_NON_GF_DEVICES_PRESENT_CHANGED | \ + PARAM_RIFS_MODE_CHANGED | \ + PARAM_LSIG_TXOP_FULL_SUPPORT_CHANGED | \ + PARAM_OBSS_MODE_CHANGED) + +/* dump command response Buffer size */ +#define DUMPCMD_RSP_BUFFER 100 + +/* version string max length (including NULL) */ +#define WCN36XX_HAL_VERSION_LENGTH 64 + +/* message types for messages exchanged between WDI and HAL */ +enum wcn36xx_hal_host_msg_type { + /* Init/De-Init */ + WCN36XX_HAL_START_REQ = 0, + WCN36XX_HAL_START_RSP = 1, + WCN36XX_HAL_STOP_REQ = 2, + WCN36XX_HAL_STOP_RSP = 3, + + /* Scan */ + WCN36XX_HAL_INIT_SCAN_REQ = 4, + WCN36XX_HAL_INIT_SCAN_RSP = 5, + WCN36XX_HAL_START_SCAN_REQ = 6, + WCN36XX_HAL_START_SCAN_RSP = 7, + WCN36XX_HAL_END_SCAN_REQ = 8, + WCN36XX_HAL_END_SCAN_RSP = 9, + WCN36XX_HAL_FINISH_SCAN_REQ = 10, + WCN36XX_HAL_FINISH_SCAN_RSP = 11, + + /* HW STA configuration/deconfiguration */ + WCN36XX_HAL_CONFIG_STA_REQ = 12, + WCN36XX_HAL_CONFIG_STA_RSP = 13, + WCN36XX_HAL_DELETE_STA_REQ = 14, + WCN36XX_HAL_DELETE_STA_RSP = 15, + WCN36XX_HAL_CONFIG_BSS_REQ = 16, + WCN36XX_HAL_CONFIG_BSS_RSP = 17, + WCN36XX_HAL_DELETE_BSS_REQ = 18, + WCN36XX_HAL_DELETE_BSS_RSP = 19, + + /* Infra STA asscoiation */ + WCN36XX_HAL_JOIN_REQ = 20, + WCN36XX_HAL_JOIN_RSP = 21, + WCN36XX_HAL_POST_ASSOC_REQ = 22, + WCN36XX_HAL_POST_ASSOC_RSP = 23, + + /* Security */ + WCN36XX_HAL_SET_BSSKEY_REQ = 24, + WCN36XX_HAL_SET_BSSKEY_RSP = 25, + WCN36XX_HAL_SET_STAKEY_REQ = 26, + WCN36XX_HAL_SET_STAKEY_RSP = 27, + WCN36XX_HAL_RMV_BSSKEY_REQ = 28, + WCN36XX_HAL_RMV_BSSKEY_RSP = 29, + WCN36XX_HAL_RMV_STAKEY_REQ = 30, + WCN36XX_HAL_RMV_STAKEY_RSP = 31, + + /* Qos Related */ + WCN36XX_HAL_ADD_TS_REQ = 32, + WCN36XX_HAL_ADD_TS_RSP = 33, + WCN36XX_HAL_DEL_TS_REQ = 34, + WCN36XX_HAL_DEL_TS_RSP = 35, + WCN36XX_HAL_UPD_EDCA_PARAMS_REQ = 36, + WCN36XX_HAL_UPD_EDCA_PARAMS_RSP = 37, + WCN36XX_HAL_ADD_BA_REQ = 38, + WCN36XX_HAL_ADD_BA_RSP = 39, + WCN36XX_HAL_DEL_BA_REQ = 40, + WCN36XX_HAL_DEL_BA_RSP = 41, + + WCN36XX_HAL_CH_SWITCH_REQ = 42, + WCN36XX_HAL_CH_SWITCH_RSP = 43, + WCN36XX_HAL_SET_LINK_ST_REQ = 44, + WCN36XX_HAL_SET_LINK_ST_RSP = 45, + WCN36XX_HAL_GET_STATS_REQ = 46, + WCN36XX_HAL_GET_STATS_RSP = 47, + WCN36XX_HAL_UPDATE_CFG_REQ = 48, + WCN36XX_HAL_UPDATE_CFG_RSP = 49, + + WCN36XX_HAL_MISSED_BEACON_IND = 50, + WCN36XX_HAL_UNKNOWN_ADDR2_FRAME_RX_IND = 51, + WCN36XX_HAL_MIC_FAILURE_IND = 52, + WCN36XX_HAL_FATAL_ERROR_IND = 53, + WCN36XX_HAL_SET_KEYDONE_MSG = 54, + + /* NV Interface */ + WCN36XX_HAL_DOWNLOAD_NV_REQ = 55, + WCN36XX_HAL_DOWNLOAD_NV_RSP = 56, + + WCN36XX_HAL_ADD_BA_SESSION_REQ = 57, + WCN36XX_HAL_ADD_BA_SESSION_RSP = 58, + WCN36XX_HAL_TRIGGER_BA_REQ = 59, + WCN36XX_HAL_TRIGGER_BA_RSP = 60, + WCN36XX_HAL_UPDATE_BEACON_REQ = 61, + WCN36XX_HAL_UPDATE_BEACON_RSP = 62, + WCN36XX_HAL_SEND_BEACON_REQ = 63, + WCN36XX_HAL_SEND_BEACON_RSP = 64, + + WCN36XX_HAL_SET_BCASTKEY_REQ = 65, + WCN36XX_HAL_SET_BCASTKEY_RSP = 66, + WCN36XX_HAL_DELETE_STA_CONTEXT_IND = 67, + WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ = 68, + WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP = 69, + + /* PTT interface support */ + WCN36XX_HAL_PROCESS_PTT_REQ = 70, + WCN36XX_HAL_PROCESS_PTT_RSP = 71, + + /* BTAMP related events */ + WCN36XX_HAL_SIGNAL_BTAMP_EVENT_REQ = 72, + WCN36XX_HAL_SIGNAL_BTAMP_EVENT_RSP = 73, + WCN36XX_HAL_TL_HAL_FLUSH_AC_REQ = 74, + WCN36XX_HAL_TL_HAL_FLUSH_AC_RSP = 75, + + WCN36XX_HAL_ENTER_IMPS_REQ = 76, + WCN36XX_HAL_EXIT_IMPS_REQ = 77, + WCN36XX_HAL_ENTER_BMPS_REQ = 78, + WCN36XX_HAL_EXIT_BMPS_REQ = 79, + WCN36XX_HAL_ENTER_UAPSD_REQ = 80, + WCN36XX_HAL_EXIT_UAPSD_REQ = 81, + WCN36XX_HAL_UPDATE_UAPSD_PARAM_REQ = 82, + WCN36XX_HAL_CONFIGURE_RXP_FILTER_REQ = 83, + WCN36XX_HAL_ADD_BCN_FILTER_REQ = 84, + WCN36XX_HAL_REM_BCN_FILTER_REQ = 85, + WCN36XX_HAL_ADD_WOWL_BCAST_PTRN = 86, + WCN36XX_HAL_DEL_WOWL_BCAST_PTRN = 87, + WCN36XX_HAL_ENTER_WOWL_REQ = 88, + WCN36XX_HAL_EXIT_WOWL_REQ = 89, + WCN36XX_HAL_HOST_OFFLOAD_REQ = 90, + WCN36XX_HAL_SET_RSSI_THRESH_REQ = 91, + WCN36XX_HAL_GET_RSSI_REQ = 92, + WCN36XX_HAL_SET_UAPSD_AC_PARAMS_REQ = 93, + WCN36XX_HAL_CONFIGURE_APPS_CPU_WAKEUP_STATE_REQ = 94, + + WCN36XX_HAL_ENTER_IMPS_RSP = 95, + WCN36XX_HAL_EXIT_IMPS_RSP = 96, + WCN36XX_HAL_ENTER_BMPS_RSP = 97, + WCN36XX_HAL_EXIT_BMPS_RSP = 98, + WCN36XX_HAL_ENTER_UAPSD_RSP = 99, + WCN36XX_HAL_EXIT_UAPSD_RSP = 100, + WCN36XX_HAL_SET_UAPSD_AC_PARAMS_RSP = 101, + WCN36XX_HAL_UPDATE_UAPSD_PARAM_RSP = 102, + WCN36XX_HAL_CONFIGURE_RXP_FILTER_RSP = 103, + WCN36XX_HAL_ADD_BCN_FILTER_RSP = 104, + WCN36XX_HAL_REM_BCN_FILTER_RSP = 105, + WCN36XX_HAL_SET_RSSI_THRESH_RSP = 106, + WCN36XX_HAL_HOST_OFFLOAD_RSP = 107, + WCN36XX_HAL_ADD_WOWL_BCAST_PTRN_RSP = 108, + WCN36XX_HAL_DEL_WOWL_BCAST_PTRN_RSP = 109, + WCN36XX_HAL_ENTER_WOWL_RSP = 110, + WCN36XX_HAL_EXIT_WOWL_RSP = 111, + WCN36XX_HAL_RSSI_NOTIFICATION_IND = 112, + WCN36XX_HAL_GET_RSSI_RSP = 113, + WCN36XX_HAL_CONFIGURE_APPS_CPU_WAKEUP_STATE_RSP = 114, + + /* 11k related events */ + WCN36XX_HAL_SET_MAX_TX_POWER_REQ = 115, + WCN36XX_HAL_SET_MAX_TX_POWER_RSP = 116, + + /* 11R related msgs */ + WCN36XX_HAL_AGGR_ADD_TS_REQ = 117, + WCN36XX_HAL_AGGR_ADD_TS_RSP = 118, + + /* P2P WLAN_FEATURE_P2P */ + WCN36XX_HAL_SET_P2P_GONOA_REQ = 119, + WCN36XX_HAL_SET_P2P_GONOA_RSP = 120, + + /* WLAN Dump commands */ + WCN36XX_HAL_DUMP_COMMAND_REQ = 121, + WCN36XX_HAL_DUMP_COMMAND_RSP = 122, + + /* OEM_DATA FEATURE SUPPORT */ + WCN36XX_HAL_START_OEM_DATA_REQ = 123, + WCN36XX_HAL_START_OEM_DATA_RSP = 124, + + /* ADD SELF STA REQ and RSP */ + WCN36XX_HAL_ADD_STA_SELF_REQ = 125, + WCN36XX_HAL_ADD_STA_SELF_RSP = 126, + + /* DEL SELF STA SUPPORT */ + WCN36XX_HAL_DEL_STA_SELF_REQ = 127, + WCN36XX_HAL_DEL_STA_SELF_RSP = 128, + + /* Coex Indication */ + WCN36XX_HAL_COEX_IND = 129, + + /* Tx Complete Indication */ + WCN36XX_HAL_OTA_TX_COMPL_IND = 130, + + /* Host Suspend/resume messages */ + WCN36XX_HAL_HOST_SUSPEND_IND = 131, + WCN36XX_HAL_HOST_RESUME_REQ = 132, + WCN36XX_HAL_HOST_RESUME_RSP = 133, + + WCN36XX_HAL_SET_TX_POWER_REQ = 134, + WCN36XX_HAL_SET_TX_POWER_RSP = 135, + WCN36XX_HAL_GET_TX_POWER_REQ = 136, + WCN36XX_HAL_GET_TX_POWER_RSP = 137, + + WCN36XX_HAL_P2P_NOA_ATTR_IND = 138, + + WCN36XX_HAL_ENABLE_RADAR_DETECT_REQ = 139, + WCN36XX_HAL_ENABLE_RADAR_DETECT_RSP = 140, + WCN36XX_HAL_GET_TPC_REPORT_REQ = 141, + WCN36XX_HAL_GET_TPC_REPORT_RSP = 142, + WCN36XX_HAL_RADAR_DETECT_IND = 143, + WCN36XX_HAL_RADAR_DETECT_INTR_IND = 144, + WCN36XX_HAL_KEEP_ALIVE_REQ = 145, + WCN36XX_HAL_KEEP_ALIVE_RSP = 146, + + /* PNO messages */ + WCN36XX_HAL_SET_PREF_NETWORK_REQ = 147, + WCN36XX_HAL_SET_PREF_NETWORK_RSP = 148, + WCN36XX_HAL_SET_RSSI_FILTER_REQ = 149, + WCN36XX_HAL_SET_RSSI_FILTER_RSP = 150, + WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ = 151, + WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP = 152, + WCN36XX_HAL_PREF_NETW_FOUND_IND = 153, + + WCN36XX_HAL_SET_TX_PER_TRACKING_REQ = 154, + WCN36XX_HAL_SET_TX_PER_TRACKING_RSP = 155, + WCN36XX_HAL_TX_PER_HIT_IND = 156, + + WCN36XX_HAL_8023_MULTICAST_LIST_REQ = 157, + WCN36XX_HAL_8023_MULTICAST_LIST_RSP = 158, + + WCN36XX_HAL_SET_PACKET_FILTER_REQ = 159, + WCN36XX_HAL_SET_PACKET_FILTER_RSP = 160, + WCN36XX_HAL_PACKET_FILTER_MATCH_COUNT_REQ = 161, + WCN36XX_HAL_PACKET_FILTER_MATCH_COUNT_RSP = 162, + WCN36XX_HAL_CLEAR_PACKET_FILTER_REQ = 163, + WCN36XX_HAL_CLEAR_PACKET_FILTER_RSP = 164, + + /* + * This is temp fix. Should be removed once Host and Riva code is + * in sync. + */ + WCN36XX_HAL_INIT_SCAN_CON_REQ = 165, + + WCN36XX_HAL_SET_POWER_PARAMS_REQ = 166, + WCN36XX_HAL_SET_POWER_PARAMS_RSP = 167, + + WCN36XX_HAL_TSM_STATS_REQ = 168, + WCN36XX_HAL_TSM_STATS_RSP = 169, + + /* wake reason indication (WOW) */ + WCN36XX_HAL_WAKE_REASON_IND = 170, + + /* GTK offload support */ + WCN36XX_HAL_GTK_OFFLOAD_REQ = 171, + WCN36XX_HAL_GTK_OFFLOAD_RSP = 172, + WCN36XX_HAL_GTK_OFFLOAD_GETINFO_REQ = 173, + WCN36XX_HAL_GTK_OFFLOAD_GETINFO_RSP = 174, + + WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ = 175, + WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP = 176, + WCN36XX_HAL_EXCLUDE_UNENCRYPTED_IND = 177, + + WCN36XX_HAL_SET_THERMAL_MITIGATION_REQ = 178, + WCN36XX_HAL_SET_THERMAL_MITIGATION_RSP = 179, + + WCN36XX_HAL_UPDATE_VHT_OP_MODE_REQ = 182, + WCN36XX_HAL_UPDATE_VHT_OP_MODE_RSP = 183, + + WCN36XX_HAL_P2P_NOA_START_IND = 184, + + WCN36XX_HAL_GET_ROAM_RSSI_REQ = 185, + WCN36XX_HAL_GET_ROAM_RSSI_RSP = 186, + + WCN36XX_HAL_CLASS_B_STATS_IND = 187, + WCN36XX_HAL_DEL_BA_IND = 188, + WCN36XX_HAL_DHCP_START_IND = 189, + WCN36XX_HAL_DHCP_STOP_IND = 190, + + WCN36XX_HAL_MSG_MAX = WCN36XX_HAL_MSG_TYPE_MAX_ENUM_SIZE +}; + +/* Enumeration for Version */ +enum wcn36xx_hal_host_msg_version { + WCN36XX_HAL_MSG_VERSION0 = 0, + WCN36XX_HAL_MSG_VERSION1 = 1, + /* define as 2 bytes data */ + WCN36XX_HAL_MSG_WCNSS_CTRL_VERSION = 0x7FFF, + WCN36XX_HAL_MSG_VERSION_MAX_FIELD = WCN36XX_HAL_MSG_WCNSS_CTRL_VERSION +}; + +enum driver_type { + DRIVER_TYPE_PRODUCTION = 0, + DRIVER_TYPE_MFG = 1, + DRIVER_TYPE_DVT = 2, + DRIVER_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum wcn36xx_hal_stop_type { + HAL_STOP_TYPE_SYS_RESET, + HAL_STOP_TYPE_SYS_DEEP_SLEEP, + HAL_STOP_TYPE_RF_KILL, + HAL_STOP_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum wcn36xx_hal_sys_mode { + HAL_SYS_MODE_NORMAL, + HAL_SYS_MODE_LEARN, + HAL_SYS_MODE_SCAN, + HAL_SYS_MODE_PROMISC, + HAL_SYS_MODE_SUSPEND_LINK, + HAL_SYS_MODE_ROAM_SCAN, + HAL_SYS_MODE_ROAM_SUSPEND_LINK, + HAL_SYS_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum phy_chan_bond_state { + /* 20MHz IF bandwidth centered on IF carrier */ + PHY_SINGLE_CHANNEL_CENTERED = 0, + + /* 40MHz IF bandwidth with lower 20MHz supporting the primary channel */ + PHY_DOUBLE_CHANNEL_LOW_PRIMARY = 1, + + /* 40MHz IF bandwidth centered on IF carrier */ + PHY_DOUBLE_CHANNEL_CENTERED = 2, + + /* 40MHz IF bandwidth with higher 20MHz supporting the primary ch */ + PHY_DOUBLE_CHANNEL_HIGH_PRIMARY = 3, + + /* 20/40MHZ offset LOW 40/80MHZ offset CENTERED */ + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_CENTERED = 4, + + /* 20/40MHZ offset CENTERED 40/80MHZ offset CENTERED */ + PHY_QUADRUPLE_CHANNEL_20MHZ_CENTERED_40MHZ_CENTERED = 5, + + /* 20/40MHZ offset HIGH 40/80MHZ offset CENTERED */ + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_CENTERED = 6, + + /* 20/40MHZ offset LOW 40/80MHZ offset LOW */ + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW = 7, + + /* 20/40MHZ offset HIGH 40/80MHZ offset LOW */ + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW = 8, + + /* 20/40MHZ offset LOW 40/80MHZ offset HIGH */ + PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH = 9, + + /* 20/40MHZ offset-HIGH 40/80MHZ offset HIGH */ + PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH = 10, + + PHY_CHANNEL_BONDING_STATE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +/* Spatial Multiplexing(SM) Power Save mode */ +enum wcn36xx_hal_ht_mimo_state { + /* Static SM Power Save mode */ + WCN36XX_HAL_HT_MIMO_PS_STATIC = 0, + + /* Dynamic SM Power Save mode */ + WCN36XX_HAL_HT_MIMO_PS_DYNAMIC = 1, + + /* reserved */ + WCN36XX_HAL_HT_MIMO_PS_NA = 2, + + /* SM Power Save disabled */ + WCN36XX_HAL_HT_MIMO_PS_NO_LIMIT = 3, + + WCN36XX_HAL_HT_MIMO_PS_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +/* each station added has a rate mode which specifies the sta attributes */ +enum sta_rate_mode { + STA_TAURUS = 0, + STA_TITAN, + STA_POLARIS, + STA_11b, + STA_11bg, + STA_11a, + STA_11n, + STA_11ac, + STA_INVALID_RATE_MODE = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +/* 1,2,5.5,11 */ +#define WCN36XX_HAL_NUM_DSSS_RATES 4 + +/* 6,9,12,18,24,36,48,54 */ +#define WCN36XX_HAL_NUM_OFDM_RATES 8 + +/* 72,96,108 */ +#define WCN36XX_HAL_NUM_POLARIS_RATES 3 + +#define WCN36XX_HAL_MAC_MAX_SUPPORTED_MCS_SET 16 + +enum wcn36xx_hal_bss_type { + WCN36XX_HAL_INFRASTRUCTURE_MODE, + + /* Added for softAP support */ + WCN36XX_HAL_INFRA_AP_MODE, + + WCN36XX_HAL_IBSS_MODE, + + /* Added for BT-AMP support */ + WCN36XX_HAL_BTAMP_STA_MODE, + + /* Added for BT-AMP support */ + WCN36XX_HAL_BTAMP_AP_MODE, + + WCN36XX_HAL_AUTO_MODE, + + WCN36XX_HAL_DONOT_USE_BSS_TYPE = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum wcn36xx_hal_nw_type { + WCN36XX_HAL_11A_NW_TYPE, + WCN36XX_HAL_11B_NW_TYPE, + WCN36XX_HAL_11G_NW_TYPE, + WCN36XX_HAL_11N_NW_TYPE, + WCN36XX_HAL_DONOT_USE_NW_TYPE = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +#define WCN36XX_HAL_MAC_RATESET_EID_MAX 12 + +enum wcn36xx_hal_ht_operating_mode { + /* No Protection */ + WCN36XX_HAL_HT_OP_MODE_PURE, + + /* Overlap Legacy device present, protection is optional */ + WCN36XX_HAL_HT_OP_MODE_OVERLAP_LEGACY, + + /* No legacy device, but 20 MHz HT present */ + WCN36XX_HAL_HT_OP_MODE_NO_LEGACY_20MHZ_HT, + + /* Protection is required */ + WCN36XX_HAL_HT_OP_MODE_MIXED, + + WCN36XX_HAL_HT_OP_MODE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +/* Encryption type enum used with peer */ +enum ani_ed_type { + WCN36XX_HAL_ED_NONE, + WCN36XX_HAL_ED_WEP40, + WCN36XX_HAL_ED_WEP104, + WCN36XX_HAL_ED_TKIP, + WCN36XX_HAL_ED_CCMP, + WCN36XX_HAL_ED_WPI, + WCN36XX_HAL_ED_AES_128_CMAC, + WCN36XX_HAL_ED_NOT_IMPLEMENTED = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +#define WLAN_MAX_KEY_RSC_LEN 16 +#define WLAN_WAPI_KEY_RSC_LEN 16 + +/* MAX key length when ULA is used */ +#define WCN36XX_HAL_MAC_MAX_KEY_LENGTH 32 +#define WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS 4 + +/* + * Enum to specify whether key is used for TX only, RX only or both. + */ +enum ani_key_direction { + WCN36XX_HAL_TX_ONLY, + WCN36XX_HAL_RX_ONLY, + WCN36XX_HAL_TX_RX, + WCN36XX_HAL_TX_DEFAULT, + WCN36XX_HAL_DONOT_USE_KEY_DIRECTION = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum ani_wep_type { + WCN36XX_HAL_WEP_STATIC, + WCN36XX_HAL_WEP_DYNAMIC, + WCN36XX_HAL_WEP_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum wcn36xx_hal_link_state { + + WCN36XX_HAL_LINK_IDLE_STATE = 0, + WCN36XX_HAL_LINK_PREASSOC_STATE = 1, + WCN36XX_HAL_LINK_POSTASSOC_STATE = 2, + WCN36XX_HAL_LINK_AP_STATE = 3, + WCN36XX_HAL_LINK_IBSS_STATE = 4, + + /* BT-AMP Case */ + WCN36XX_HAL_LINK_BTAMP_PREASSOC_STATE = 5, + WCN36XX_HAL_LINK_BTAMP_POSTASSOC_STATE = 6, + WCN36XX_HAL_LINK_BTAMP_AP_STATE = 7, + WCN36XX_HAL_LINK_BTAMP_STA_STATE = 8, + + /* Reserved for HAL Internal Use */ + WCN36XX_HAL_LINK_LEARN_STATE = 9, + WCN36XX_HAL_LINK_SCAN_STATE = 10, + WCN36XX_HAL_LINK_FINISH_SCAN_STATE = 11, + WCN36XX_HAL_LINK_INIT_CAL_STATE = 12, + WCN36XX_HAL_LINK_FINISH_CAL_STATE = 13, + WCN36XX_HAL_LINK_LISTEN_STATE = 14, + + WCN36XX_HAL_LINK_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +enum wcn36xx_hal_stats_mask { + HAL_SUMMARY_STATS_INFO = 0x00000001, + HAL_GLOBAL_CLASS_A_STATS_INFO = 0x00000002, + HAL_GLOBAL_CLASS_B_STATS_INFO = 0x00000004, + HAL_GLOBAL_CLASS_C_STATS_INFO = 0x00000008, + HAL_GLOBAL_CLASS_D_STATS_INFO = 0x00000010, + HAL_PER_STA_STATS_INFO = 0x00000020 +}; + +/* BT-AMP events type */ +enum bt_amp_event_type { + BTAMP_EVENT_CONNECTION_START, + BTAMP_EVENT_CONNECTION_STOP, + BTAMP_EVENT_CONNECTION_TERMINATED, + + /* This and beyond are invalid values */ + BTAMP_EVENT_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE, +}; + +/* PE Statistics */ +enum pe_stats_mask { + PE_SUMMARY_STATS_INFO = 0x00000001, + PE_GLOBAL_CLASS_A_STATS_INFO = 0x00000002, + PE_GLOBAL_CLASS_B_STATS_INFO = 0x00000004, + PE_GLOBAL_CLASS_C_STATS_INFO = 0x00000008, + PE_GLOBAL_CLASS_D_STATS_INFO = 0x00000010, + PE_PER_STA_STATS_INFO = 0x00000020, + + /* This and beyond are invalid values */ + PE_STATS_TYPE_MAX = WCN36XX_HAL_MAX_ENUM_SIZE +}; + +/* + * Configuration Parameter IDs + */ +#define WCN36XX_HAL_CFG_STA_ID 0 +#define WCN36XX_HAL_CFG_CURRENT_TX_ANTENNA 1 +#define WCN36XX_HAL_CFG_CURRENT_RX_ANTENNA 2 +#define WCN36XX_HAL_CFG_LOW_GAIN_OVERRIDE 3 +#define WCN36XX_HAL_CFG_POWER_STATE_PER_CHAIN 4 +#define WCN36XX_HAL_CFG_CAL_PERIOD 5 +#define WCN36XX_HAL_CFG_CAL_CONTROL 6 +#define WCN36XX_HAL_CFG_PROXIMITY 7 +#define WCN36XX_HAL_CFG_NETWORK_DENSITY 8 +#define WCN36XX_HAL_CFG_MAX_MEDIUM_TIME 9 +#define WCN36XX_HAL_CFG_MAX_MPDUS_IN_AMPDU 10 +#define WCN36XX_HAL_CFG_RTS_THRESHOLD 11 +#define WCN36XX_HAL_CFG_SHORT_RETRY_LIMIT 12 +#define WCN36XX_HAL_CFG_LONG_RETRY_LIMIT 13 +#define WCN36XX_HAL_CFG_FRAGMENTATION_THRESHOLD 14 +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_ZERO 15 +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_ONE 16 +#define WCN36XX_HAL_CFG_DYNAMIC_THRESHOLD_TWO 17 +#define WCN36XX_HAL_CFG_FIXED_RATE 18 +#define WCN36XX_HAL_CFG_RETRYRATE_POLICY 19 +#define WCN36XX_HAL_CFG_RETRYRATE_SECONDARY 20 +#define WCN36XX_HAL_CFG_RETRYRATE_TERTIARY 21 +#define WCN36XX_HAL_CFG_FORCE_POLICY_PROTECTION 22 +#define WCN36XX_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ 23 +#define WCN36XX_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ 24 +#define WCN36XX_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ 25 +#define WCN36XX_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ 26 +#define WCN36XX_HAL_CFG_MAX_BA_SESSIONS 27 +#define WCN36XX_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT 28 +#define WCN36XX_HAL_CFG_PS_ENABLE_BCN_FILTER 29 +#define WCN36XX_HAL_CFG_PS_ENABLE_RSSI_MONITOR 30 +#define WCN36XX_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE 31 +#define WCN36XX_HAL_CFG_STATS_PERIOD 32 +#define WCN36XX_HAL_CFG_CFP_MAX_DURATION 33 +#define WCN36XX_HAL_CFG_FRAME_TRANS_ENABLED 34 +#define WCN36XX_HAL_CFG_DTIM_PERIOD 35 +#define WCN36XX_HAL_CFG_EDCA_WMM_ACBK 36 +#define WCN36XX_HAL_CFG_EDCA_WMM_ACBE 37 +#define WCN36XX_HAL_CFG_EDCA_WMM_ACVO 38 +#define WCN36XX_HAL_CFG_EDCA_WMM_ACVI 39 +#define WCN36XX_HAL_CFG_BA_THRESHOLD_HIGH 40 +#define WCN36XX_HAL_CFG_MAX_BA_BUFFERS 41 +#define WCN36XX_HAL_CFG_RPE_POLLING_THRESHOLD 42 +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC0_REG 43 +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC1_REG 44 +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC2_REG 45 +#define WCN36XX_HAL_CFG_RPE_AGING_THRESHOLD_FOR_AC3_REG 46 +#define WCN36XX_HAL_CFG_NO_OF_ONCHIP_REORDER_SESSIONS 47 +#define WCN36XX_HAL_CFG_PS_LISTEN_INTERVAL 48 +#define WCN36XX_HAL_CFG_PS_HEART_BEAT_THRESHOLD 49 +#define WCN36XX_HAL_CFG_PS_NTH_BEACON_FILTER 50 +#define WCN36XX_HAL_CFG_PS_MAX_PS_POLL 51 +#define WCN36XX_HAL_CFG_PS_MIN_RSSI_THRESHOLD 52 +#define WCN36XX_HAL_CFG_PS_RSSI_FILTER_PERIOD 53 +#define WCN36XX_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE 54 +#define WCN36XX_HAL_CFG_PS_IGNORE_DTIM 55 +#define WCN36XX_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM 56 +#define WCN36XX_HAL_CFG_DYNAMIC_PS_POLL_VALUE 57 +#define WCN36XX_HAL_CFG_PS_NULLDATA_AP_RESP_TIMEOUT 58 +#define WCN36XX_HAL_CFG_TELE_BCN_WAKEUP_EN 59 +#define WCN36XX_HAL_CFG_TELE_BCN_TRANS_LI 60 +#define WCN36XX_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS 61 +#define WCN36XX_HAL_CFG_TELE_BCN_MAX_LI 62 +#define WCN36XX_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS 63 +#define WCN36XX_HAL_CFG_TX_PWR_CTRL_ENABLE 64 +#define WCN36XX_HAL_CFG_VALID_RADAR_CHANNEL_LIST 65 +#define WCN36XX_HAL_CFG_TX_POWER_24_20 66 +#define WCN36XX_HAL_CFG_TX_POWER_24_40 67 +#define WCN36XX_HAL_CFG_TX_POWER_50_20 68 +#define WCN36XX_HAL_CFG_TX_POWER_50_40 69 +#define WCN36XX_HAL_CFG_MCAST_BCAST_FILTER_SETTING 70 +#define WCN36XX_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL 71 +#define WCN36XX_HAL_CFG_MAX_TX_POWER_2_4 72 +#define WCN36XX_HAL_CFG_MAX_TX_POWER_5 73 +#define WCN36XX_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD 74 +#define WCN36XX_HAL_CFG_ENABLE_CLOSE_LOOP 75 +#define WCN36XX_HAL_CFG_BTC_EXECUTION_MODE 76 +#define WCN36XX_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK 77 +#define WCN36XX_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS 78 +#define WCN36XX_HAL_CFG_PS_TX_INACTIVITY_TIMEOUT 79 +#define WCN36XX_HAL_CFG_WCNSS_API_VERSION 80 +#define WCN36XX_HAL_CFG_AP_KEEPALIVE_TIMEOUT 81 +#define WCN36XX_HAL_CFG_GO_KEEPALIVE_TIMEOUT 82 +#define WCN36XX_HAL_CFG_ENABLE_MC_ADDR_LIST 83 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_INQ_BT 84 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_PAGE_BT 85 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_CONN_BT 86 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_LE_BT 87 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN 88 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN 89 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN 90 +#define WCN36XX_HAL_CFG_BTC_STATIC_LEN_LE_WLAN 91 +#define WCN36XX_HAL_CFG_BTC_DYN_MAX_LEN_BT 92 +#define WCN36XX_HAL_CFG_BTC_DYN_MAX_LEN_WLAN 93 +#define WCN36XX_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC 94 +#define WCN36XX_HAL_CFG_BTC_DHCP_PROT_ON_A2DP 95 +#define WCN36XX_HAL_CFG_BTC_DHCP_PROT_ON_SCO 96 +#define WCN36XX_HAL_CFG_ENABLE_UNICAST_FILTER 97 +#define WCN36XX_HAL_CFG_MAX_ASSOC_LIMIT 98 +#define WCN36XX_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION 99 +#define WCN36XX_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER 100 +#define WCN36XX_HAL_CFG_ENABLE_DETECT_PS_SUPPORT 101 +#define WCN36XX_HAL_CFG_AP_LINK_MONITOR_TIMEOUT 102 +#define WCN36XX_HAL_CFG_BTC_DWELL_TIME_MULTIPLIER 103 +#define WCN36XX_HAL_CFG_ENABLE_TDLS_OXYGEN_MODE 104 +#define WCN36XX_HAL_CFG_MAX_PARAMS 105 + +/* Message definitons - All the messages below need to be packed */ + +/* Definition for HAL API Version. */ +struct wcnss_wlan_version { + u8 revision; + u8 version; + u8 minor; + u8 major; +} __packed; + +/* Definition for Encryption Keys */ +struct wcn36xx_hal_keys { + u8 id; + + /* 0 for multicast */ + u8 unicast; + + enum ani_key_direction direction; + + /* Usage is unknown */ + u8 rsc[WLAN_MAX_KEY_RSC_LEN]; + + /* =1 for authenticator,=0 for supplicant */ + u8 pae_role; + + u16 length; + u8 key[WCN36XX_HAL_MAC_MAX_KEY_LENGTH]; +} __packed; + +/* + * set_sta_key_params Moving here since it is shared by + * configbss/setstakey msgs + */ +struct wcn36xx_hal_set_sta_key_params { + /* STA Index */ + u16 sta_index; + + /* Encryption Type used with peer */ + enum ani_ed_type enc_type; + + /* STATIC/DYNAMIC - valid only for WEP */ + enum ani_wep_type wep_type; + + /* Default WEP key, valid only for static WEP, must between 0 and 3. */ + u8 def_wep_idx; + + /* valid only for non-static WEP encyrptions */ + struct wcn36xx_hal_keys key[WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS]; + + /* + * Control for Replay Count, 1= Single TID based replay count on Tx + * 0 = Per TID based replay count on TX + */ + u8 single_tid_rc; + +} __packed; + +/* 4-byte control message header used by HAL*/ +struct wcn36xx_hal_msg_header { + enum wcn36xx_hal_host_msg_type msg_type:16; + enum wcn36xx_hal_host_msg_version msg_version:16; + u32 len; +} __packed; + +/* Config format required by HAL for each CFG item*/ +struct wcn36xx_hal_cfg { + /* Cfg Id. The Id required by HAL is exported by HAL + * in shared header file between UMAC and HAL.*/ + u16 id; + + /* Length of the Cfg. This parameter is used to go to next cfg + * in the TLV format.*/ + u16 len; + + /* Padding bytes for unaligned address's */ + u16 pad_bytes; + + /* Reserve bytes for making cfgVal to align address */ + u16 reserve; + + /* Following the uCfgLen field there should be a 'uCfgLen' bytes + * containing the uCfgValue ; u8 uCfgValue[uCfgLen] */ +} __packed; + +struct wcn36xx_hal_mac_start_parameters { + /* Drive Type - Production or FTM etc */ + enum driver_type type; + + /* Length of the config buffer */ + u32 len; + + /* Following this there is a TLV formatted buffer of length + * "len" bytes containing all config values. + * The TLV is expected to be formatted like this: + * 0 15 31 31+CFG_LEN-1 length-1 + * | CFG_ID | CFG_LEN | CFG_BODY | CFG_ID |......| + */ +} __packed; + +struct wcn36xx_hal_mac_start_req_msg { + /* config buffer must start in TLV format just here */ + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_mac_start_parameters params; +} __packed; + +struct wcn36xx_hal_mac_start_rsp_params { + /* success or failure */ + u16 status; + + /* Max number of STA supported by the device */ + u8 stations; + + /* Max number of BSS supported by the device */ + u8 bssids; + + /* API Version */ + struct wcnss_wlan_version version; + + /* CRM build information */ + u8 crm_version[WCN36XX_HAL_VERSION_LENGTH]; + + /* hardware/chipset/misc version information */ + u8 wlan_version[WCN36XX_HAL_VERSION_LENGTH]; + +} __packed; + +struct wcn36xx_hal_mac_start_rsp_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_mac_start_rsp_params start_rsp_params; +} __packed; + +struct wcn36xx_hal_mac_stop_req_params { + /* The reason for which the device is being stopped */ + enum wcn36xx_hal_stop_type reason; + +} __packed; + +struct wcn36xx_hal_mac_stop_req_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_mac_stop_req_params stop_req_params; +} __packed; + +struct wcn36xx_hal_mac_stop_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +struct wcn36xx_hal_update_cfg_req_msg { + /* + * Note: The length specified in tHalUpdateCfgReqMsg messages should be + * header.msgLen = sizeof(tHalUpdateCfgReqMsg) + uConfigBufferLen + */ + struct wcn36xx_hal_msg_header header; + + /* Length of the config buffer. Allows UMAC to update multiple CFGs */ + u32 len; + + /* + * Following this there is a TLV formatted buffer of length + * "uConfigBufferLen" bytes containing all config values. + * The TLV is expected to be formatted like this: + * 0 15 31 31+CFG_LEN-1 length-1 + * | CFG_ID | CFG_LEN | CFG_BODY | CFG_ID |......| + */ + +} __packed; + +struct wcn36xx_hal_update_cfg_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + +} __packed; + +/* Frame control field format (2 bytes) */ +struct wcn36xx_hal_mac_frame_ctl { + +#ifndef ANI_LITTLE_BIT_ENDIAN + + u8 subType:4; + u8 type:2; + u8 protVer:2; + + u8 order:1; + u8 wep:1; + u8 moreData:1; + u8 powerMgmt:1; + u8 retry:1; + u8 moreFrag:1; + u8 fromDS:1; + u8 toDS:1; + +#else + + u8 protVer:2; + u8 type:2; + u8 subType:4; + + u8 toDS:1; + u8 fromDS:1; + u8 moreFrag:1; + u8 retry:1; + u8 powerMgmt:1; + u8 moreData:1; + u8 wep:1; + u8 order:1; + +#endif + +}; + +/* Sequence control field */ +struct wcn36xx_hal_mac_seq_ctl { + u8 fragNum:4; + u8 seqNumLo:4; + u8 seqNumHi:8; +}; + +/* Management header format */ +struct wcn36xx_hal_mac_mgmt_hdr { + struct wcn36xx_hal_mac_frame_ctl fc; + u8 durationLo; + u8 durationHi; + u8 da[6]; + u8 sa[6]; + u8 bssId[6]; + struct wcn36xx_hal_mac_seq_ctl seqControl; +}; + +/* FIXME: pronto v1 apparently has 4 */ +#define WCN36XX_HAL_NUM_BSSID 2 + +/* Scan Entry to hold active BSS idx's */ +struct wcn36xx_hal_scan_entry { + u8 bss_index[WCN36XX_HAL_NUM_BSSID]; + u8 active_bss_count; +}; + +struct wcn36xx_hal_init_scan_req_msg { + struct wcn36xx_hal_msg_header header; + + /* LEARN - AP Role + SCAN - STA Role */ + enum wcn36xx_hal_sys_mode mode; + + /* BSSID of the BSS */ + u8 bssid[ETH_ALEN]; + + /* Whether BSS needs to be notified */ + u8 notify; + + /* Kind of frame to be used for notifying the BSS (Data Null, QoS + * Null, or CTS to Self). Must always be a valid frame type. */ + u8 frame_type; + + /* UMAC has the option of passing the MAC frame to be used for + * notifying the BSS. If non-zero, HAL will use the MAC frame + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the + * appropriate MAC frame based on frameType. */ + u8 frame_len; + + /* Following the framelength there is a MAC frame buffer if + * frameLength is non-zero. */ + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; + + /* Entry to hold number of active BSS idx's */ + struct wcn36xx_hal_scan_entry scan_entry; +}; + +struct wcn36xx_hal_init_scan_con_req_msg { + struct wcn36xx_hal_msg_header header; + + /* LEARN - AP Role + SCAN - STA Role */ + enum wcn36xx_hal_sys_mode mode; + + /* BSSID of the BSS */ + u8 bssid[ETH_ALEN]; + + /* Whether BSS needs to be notified */ + u8 notify; + + /* Kind of frame to be used for notifying the BSS (Data Null, QoS + * Null, or CTS to Self). Must always be a valid frame type. */ + u8 frame_type; + + /* UMAC has the option of passing the MAC frame to be used for + * notifying the BSS. If non-zero, HAL will use the MAC frame + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the + * appropriate MAC frame based on frameType. */ + u8 frame_length; + + /* Following the framelength there is a MAC frame buffer if + * frameLength is non-zero. */ + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; + + /* Entry to hold number of active BSS idx's */ + struct wcn36xx_hal_scan_entry scan_entry; + + /* Single NoA usage in Scanning */ + u8 use_noa; + + /* Indicates the scan duration (in ms) */ + u16 scan_duration; + +}; + +struct wcn36xx_hal_init_scan_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + +} __packed; + +struct wcn36xx_hal_start_scan_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Indicates the channel to scan */ + u8 scan_channel; +} __packed; + +struct wcn36xx_hal_start_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + + u32 start_tsf[2]; + u8 tx_mgmt_power; + +} __packed; + +struct wcn36xx_hal_end_scan_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Indicates the channel to stop scanning. Not used really. But + * retained for symmetry with "start Scan" message. It can also + * help in error check if needed. */ + u8 scan_channel; +} __packed; + +struct wcn36xx_hal_end_scan_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +struct wcn36xx_hal_finish_scan_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Identifies the operational state of the AP/STA + * LEARN - AP Role SCAN - STA Role */ + enum wcn36xx_hal_sys_mode mode; + + /* Operating channel to tune to. */ + u8 oper_channel; + + /* Channel Bonding state If 20/40 MHz is operational, this will + * indicate the 40 MHz extension channel in combination with the + * control channel */ + enum phy_chan_bond_state cb_state; + + /* BSSID of the BSS */ + u8 bssid[ETH_ALEN]; + + /* Whether BSS needs to be notified */ + u8 notify; + + /* Kind of frame to be used for notifying the BSS (Data Null, QoS + * Null, or CTS to Self). Must always be a valid frame type. */ + u8 frame_type; + + /* UMAC has the option of passing the MAC frame to be used for + * notifying the BSS. If non-zero, HAL will use the MAC frame + * buffer pointed to by macMgmtHdr. If zero, HAL will generate the + * appropriate MAC frame based on frameType. */ + u8 frame_length; + + /* Following the framelength there is a MAC frame buffer if + * frameLength is non-zero. */ + struct wcn36xx_hal_mac_mgmt_hdr mac_mgmt_hdr; + + /* Entry to hold number of active BSS idx's */ + struct wcn36xx_hal_scan_entry scan_entry; + +} __packed; + +struct wcn36xx_hal_finish_scan_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + +} __packed; + +enum wcn36xx_hal_rate_index { + HW_RATE_INDEX_1MBPS = 0x82, + HW_RATE_INDEX_2MBPS = 0x84, + HW_RATE_INDEX_5_5MBPS = 0x8B, + HW_RATE_INDEX_6MBPS = 0x0C, + HW_RATE_INDEX_9MBPS = 0x12, + HW_RATE_INDEX_11MBPS = 0x96, + HW_RATE_INDEX_12MBPS = 0x18, + HW_RATE_INDEX_18MBPS = 0x24, + HW_RATE_INDEX_24MBPS = 0x30, + HW_RATE_INDEX_36MBPS = 0x48, + HW_RATE_INDEX_48MBPS = 0x60, + HW_RATE_INDEX_54MBPS = 0x6C +}; + +struct wcn36xx_hal_supported_rates { + /* + * For Self STA Entry: this represents Self Mode. + * For Peer Stations, this represents the mode of the peer. + * On Station: + * + * --this mode is updated when PE adds the Self Entry. + * + * -- OR when PE sends 'ADD_BSS' message and station context in BSS + * is used to indicate the mode of the AP. + * + * ON AP: + * + * -- this mode is updated when PE sends 'ADD_BSS' and Sta entry + * for that BSS is used to indicate the self mode of the AP. + * + * -- OR when a station is associated, PE sends 'ADD_STA' message + * with this mode updated. + */ + + enum sta_rate_mode op_rate_mode; + + /* 11b, 11a and aniLegacyRates are IE rates which gives rate in + * unit of 500Kbps */ + u16 dsss_rates[WCN36XX_HAL_NUM_DSSS_RATES]; + u16 ofdm_rates[WCN36XX_HAL_NUM_OFDM_RATES]; + u16 legacy_rates[WCN36XX_HAL_NUM_POLARIS_RATES]; + u16 reserved; + + /* Taurus only supports 26 Titan Rates(no ESF/concat Rates will be + * supported) First 26 bits are reserved for those Titan rates and + * the last 4 bits(bit28-31) for Taurus, 2(bit26-27) bits are + * reserved. */ + /* Titan and Taurus Rates */ + u32 enhanced_rate_bitmap; + + /* + * 0-76 bits used, remaining reserved + * bits 0-15 and 32 should be set. + */ + u8 supported_mcs_set[WCN36XX_HAL_MAC_MAX_SUPPORTED_MCS_SET]; + + /* + * RX Highest Supported Data Rate defines the highest data + * rate that the STA is able to receive, in unites of 1Mbps. + * This value is derived from "Supported MCS Set field" inside + * the HT capability element. + */ + u16 rx_highest_data_rate; + +} __packed; + +struct wcn36xx_hal_config_sta_params { + /* BSSID of STA */ + u8 bssid[ETH_ALEN]; + + /* ASSOC ID, as assigned by UMAC */ + u16 aid; + + /* STA entry Type: 0 - Self, 1 - Other/Peer, 2 - BSSID, 3 - BCAST */ + u8 type; + + /* Short Preamble Supported. */ + u8 short_preamble_supported; + + /* MAC Address of STA */ + u8 mac[ETH_ALEN]; + + /* Listen interval of the STA */ + u16 listen_interval; + + /* Support for 11e/WMM */ + u8 wmm_enabled; + + /* 11n HT capable STA */ + u8 ht_capable; + + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ + u8 tx_channel_width_set; + + /* RIFS mode 0 - NA, 1 - Allowed */ + u8 rifs_mode; + + /* L-SIG TXOP Protection mechanism + 0 - No Support, 1 - Supported + SG - there is global field */ + u8 lsig_txop_protection; + + /* Max Ampdu Size supported by STA. TPE programming. + 0 : 8k , 1 : 16k, 2 : 32k, 3 : 64k */ + u8 max_ampdu_size; + + /* Max Ampdu density. Used by RA. 3 : 0~7 : 2^(11nAMPDUdensity -4) */ + u8 max_ampdu_density; + + /* Max AMSDU size 1 : 3839 bytes, 0 : 7935 bytes */ + u8 max_amsdu_size; + + /* Short GI support for 40Mhz packets */ + u8 sgi_40mhz; + + /* Short GI support for 20Mhz packets */ + u8 sgi_20Mhz; + + /* TODO move this parameter to the end for 3680 */ + /* These rates are the intersection of peer and self capabilities. */ + struct wcn36xx_hal_supported_rates supported_rates; + + /* Robust Management Frame (RMF) enabled/disabled */ + u8 rmf; + + /* The unicast encryption type in the association */ + u32 encrypt_type; + + /* HAL should update the existing STA entry, if this flag is set. UMAC + will set this flag in case of RE-ASSOC, where we want to reuse the + old STA ID. 0 = Add, 1 = Update */ + u8 action; + + /* U-APSD Flags: 1b per AC. Encoded as follows: + b7 b6 b5 b4 b3 b2 b1 b0 = + X X X X BE BK VI VO */ + u8 uapsd; + + /* Max SP Length */ + u8 max_sp_len; + + /* 11n Green Field preamble support + 0 - Not supported, 1 - Supported */ + u8 green_field_capable; + + /* MIMO Power Save mode */ + enum wcn36xx_hal_ht_mimo_state mimo_ps; + + /* Delayed BA Support */ + u8 delayed_ba_support; + + /* Max AMPDU duration in 32us */ + u8 max_ampdu_duration; + + /* HT STA should set it to 1 if it is enabled in BSS. HT STA should + * set it to 0 if AP does not support it. This indication is sent + * to HAL and HAL uses this flag to pickup up appropriate 40Mhz + * rates. */ + u8 dsss_cck_mode_40mhz; + + /* Valid STA Idx when action=Update. Set to 0xFF when invalid! + * Retained for backward compalibity with existing HAL code */ + u8 sta_index; + + /* BSSID of BSS to which station is associated. Set to 0xFF when + * invalid. Retained for backward compalibity with existing HAL + * code */ + u8 bssid_index; + + u8 p2p; + + /* TODO add this parameter for 3680. */ + /* Reserved to align next field on a dword boundary */ + /* u8 reserved; */ +} __packed; + +struct wcn36xx_hal_config_sta_req_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_config_sta_params sta_params; +} __packed; + +struct wcn36xx_hal_config_sta_params_v1 { + /* BSSID of STA */ + u8 bssid[ETH_ALEN]; + + /* ASSOC ID, as assigned by UMAC */ + u16 aid; + + /* STA entry Type: 0 - Self, 1 - Other/Peer, 2 - BSSID, 3 - BCAST */ + u8 type; + + /* Short Preamble Supported. */ + u8 short_preamble_supported; + + /* MAC Address of STA */ + u8 mac[ETH_ALEN]; + + /* Listen interval of the STA */ + u16 listen_interval; + + /* Support for 11e/WMM */ + u8 wmm_enabled; + + /* 11n HT capable STA */ + u8 ht_capable; + + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ + u8 tx_channel_width_set; + + /* RIFS mode 0 - NA, 1 - Allowed */ + u8 rifs_mode; + + /* L-SIG TXOP Protection mechanism + 0 - No Support, 1 - Supported + SG - there is global field */ + u8 lsig_txop_protection; + + /* Max Ampdu Size supported by STA. TPE programming. + 0 : 8k , 1 : 16k, 2 : 32k, 3 : 64k */ + u8 max_ampdu_size; + + /* Max Ampdu density. Used by RA. 3 : 0~7 : 2^(11nAMPDUdensity -4) */ + u8 max_ampdu_density; + + /* Max AMSDU size 1 : 3839 bytes, 0 : 7935 bytes */ + u8 max_amsdu_size; + + /* Short GI support for 40Mhz packets */ + u8 sgi_40mhz; + + /* Short GI support for 20Mhz packets */ + u8 sgi_20Mhz; + + /* Robust Management Frame (RMF) enabled/disabled */ + u8 rmf; + + /* The unicast encryption type in the association */ + u32 encrypt_type; + + /* HAL should update the existing STA entry, if this flag is set. UMAC + will set this flag in case of RE-ASSOC, where we want to reuse the + old STA ID. 0 = Add, 1 = Update */ + u8 action; + + /* U-APSD Flags: 1b per AC. Encoded as follows: + b7 b6 b5 b4 b3 b2 b1 b0 = + X X X X BE BK VI VO */ + u8 uapsd; + + /* Max SP Length */ + u8 max_sp_len; + + /* 11n Green Field preamble support + 0 - Not supported, 1 - Supported */ + u8 green_field_capable; + + /* MIMO Power Save mode */ + enum wcn36xx_hal_ht_mimo_state mimo_ps; + + /* Delayed BA Support */ + u8 delayed_ba_support; + + /* Max AMPDU duration in 32us */ + u8 max_ampdu_duration; + + /* HT STA should set it to 1 if it is enabled in BSS. HT STA should + * set it to 0 if AP does not support it. This indication is sent + * to HAL and HAL uses this flag to pickup up appropriate 40Mhz + * rates. */ + u8 dsss_cck_mode_40mhz; + + /* Valid STA Idx when action=Update. Set to 0xFF when invalid! + * Retained for backward compalibity with existing HAL code */ + u8 sta_index; + + /* BSSID of BSS to which station is associated. Set to 0xFF when + * invalid. Retained for backward compalibity with existing HAL + * code */ + u8 bssid_index; + + u8 p2p; + + /* Reserved to align next field on a dword boundary */ + u8 reserved; + + /* These rates are the intersection of peer and self capabilities. */ + struct wcn36xx_hal_supported_rates supported_rates; +} __packed; + +struct wcn36xx_hal_config_sta_req_msg_v1 { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_config_sta_params_v1 sta_params; +} __packed; + +struct config_sta_rsp_params { + /* success or failure */ + u32 status; + + /* Station index; valid only when 'status' field value SUCCESS */ + u8 sta_index; + + /* BSSID Index of BSS to which the station is associated */ + u8 bssid_index; + + /* DPU Index for PTK */ + u8 dpu_index; + + /* DPU Index for GTK */ + u8 bcast_dpu_index; + + /* DPU Index for IGTK */ + u8 bcast_mgmt_dpu_idx; + + /* PTK DPU signature */ + u8 uc_ucast_sig; + + /* GTK DPU isignature */ + u8 uc_bcast_sig; + + /* IGTK DPU signature */ + u8 uc_mgmt_sig; + + u8 p2p; + +} __packed; + +struct wcn36xx_hal_config_sta_rsp_msg { + struct wcn36xx_hal_msg_header header; + + struct config_sta_rsp_params params; +} __packed; + +/* Delete STA Request message */ +struct wcn36xx_hal_delete_sta_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Index of STA to delete */ + u8 sta_index; + +} __packed; + +/* Delete STA Response message */ +struct wcn36xx_hal_delete_sta_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + + /* Index of STA deleted */ + u8 sta_id; +} __packed; + +/* 12 Bytes long because this structure can be used to represent rate and + * extended rate set IEs. The parser assume this to be at least 12 */ +struct wcn36xx_hal_rate_set { + u8 num_rates; + u8 rate[WCN36XX_HAL_MAC_RATESET_EID_MAX]; +} __packed; + +/* access category record */ +struct wcn36xx_hal_aci_aifsn { +#ifndef ANI_LITTLE_BIT_ENDIAN + u8 rsvd:1; + u8 aci:2; + u8 acm:1; + u8 aifsn:4; +#else + u8 aifsn:4; + u8 acm:1; + u8 aci:2; + u8 rsvd:1; +#endif +} __packed; + +/* contention window size */ +struct wcn36xx_hal_mac_cw { +#ifndef ANI_LITTLE_BIT_ENDIAN + u8 max:4; + u8 min:4; +#else + u8 min:4; + u8 max:4; +#endif +} __packed; + +struct wcn36xx_hal_edca_param_record { + struct wcn36xx_hal_aci_aifsn aci; + struct wcn36xx_hal_mac_cw cw; + u16 txop_limit; +} __packed; + +struct wcn36xx_hal_mac_ssid { + u8 length; + u8 ssid[32]; +} __packed; + +/* Concurrency role. These are generic IDs that identify the various roles + * in the software system. */ +enum wcn36xx_hal_con_mode { + WCN36XX_HAL_STA_MODE = 0, + + /* to support softAp mode . This is misleading. + It means AP MODE only. */ + WCN36XX_HAL_STA_SAP_MODE = 1, + + WCN36XX_HAL_P2P_CLIENT_MODE, + WCN36XX_HAL_P2P_GO_MODE, + WCN36XX_HAL_MONITOR_MODE, +}; + +/* This is a bit pattern to be set for each mode + * bit 0 - sta mode + * bit 1 - ap mode + * bit 2 - p2p client mode + * bit 3 - p2p go mode */ +enum wcn36xx_hal_concurrency_mode { + HAL_STA = 1, + HAL_SAP = 2, + + /* to support sta, softAp mode . This means STA+AP mode */ + HAL_STA_SAP = 3, + + HAL_P2P_CLIENT = 4, + HAL_P2P_GO = 8, + HAL_MAX_CONCURRENCY_PERSONA = 4 +}; + +struct wcn36xx_hal_config_bss_params { + /* BSSID */ + u8 bssid[ETH_ALEN]; + + /* Self Mac Address */ + u8 self_mac_addr[ETH_ALEN]; + + /* BSS type */ + enum wcn36xx_hal_bss_type bss_type; + + /* Operational Mode: AP =0, STA = 1 */ + u8 oper_mode; + + /* Network Type */ + enum wcn36xx_hal_nw_type nw_type; + + /* Used to classify PURE_11G/11G_MIXED to program MTU */ + u8 short_slot_time_supported; + + /* Co-exist with 11a STA */ + u8 lla_coexist; + + /* Co-exist with 11b STA */ + u8 llb_coexist; + + /* Co-exist with 11g STA */ + u8 llg_coexist; + + /* Coexistence with 11n STA */ + u8 ht20_coexist; + + /* Non GF coexist flag */ + u8 lln_non_gf_coexist; + + /* TXOP protection support */ + u8 lsig_tx_op_protection_full_support; + + /* RIFS mode */ + u8 rifs_mode; + + /* Beacon Interval in TU */ + u16 beacon_interval; + + /* DTIM period */ + u8 dtim_period; + + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ + u8 tx_channel_width_set; + + /* Operating channel */ + u8 oper_channel; + + /* Extension channel for channel bonding */ + u8 ext_channel; + + /* Reserved to align next field on a dword boundary */ + u8 reserved; + + /* TODO move sta to the end for 3680 */ + /* Context of the station being added in HW + * Add a STA entry for "itself" - + * + * On AP - Add the AP itself in an "STA context" + * + * On STA - Add the AP to which this STA is joining in an + * "STA context" + */ + struct wcn36xx_hal_config_sta_params sta; + /* SSID of the BSS */ + struct wcn36xx_hal_mac_ssid ssid; + + /* HAL should update the existing BSS entry, if this flag is set. + * UMAC will set this flag in case of reassoc, where we want to + * resue the the old BSSID and still return success 0 = Add, 1 = + * Update */ + u8 action; + + /* MAC Rate Set */ + struct wcn36xx_hal_rate_set rateset; + + /* Enable/Disable HT capabilities of the BSS */ + u8 ht; + + /* Enable/Disable OBSS protection */ + u8 obss_prot_enabled; + + /* RMF enabled/disabled */ + u8 rmf; + + /* HT Operating Mode operating mode of the 802.11n STA */ + enum wcn36xx_hal_ht_operating_mode ht_oper_mode; + + /* Dual CTS Protection: 0 - Unused, 1 - Used */ + u8 dual_cts_protection; + + /* Probe Response Max retries */ + u8 max_probe_resp_retry_limit; + + /* To Enable Hidden ssid */ + u8 hidden_ssid; + + /* To Enable Disable FW Proxy Probe Resp */ + u8 proxy_probe_resp; + + /* Boolean to indicate if EDCA params are valid. UMAC might not + * have valid EDCA params or might not desire to apply EDCA params + * during config BSS. 0 implies Not Valid ; Non-Zero implies + * valid */ + u8 edca_params_valid; + + /* EDCA Parameters for Best Effort Access Category */ + struct wcn36xx_hal_edca_param_record acbe; + + /* EDCA Parameters forBackground Access Category */ + struct wcn36xx_hal_edca_param_record acbk; + + /* EDCA Parameters for Video Access Category */ + struct wcn36xx_hal_edca_param_record acvi; + + /* EDCA Parameters for Voice Access Category */ + struct wcn36xx_hal_edca_param_record acvo; + + /* Ext Bss Config Msg if set */ + u8 ext_set_sta_key_param_valid; + + /* SetStaKeyParams for ext bss msg */ + struct wcn36xx_hal_set_sta_key_params ext_set_sta_key_param; + + /* Persona for the BSS can be STA,AP,GO,CLIENT value same as enum + * wcn36xx_hal_con_mode */ + u8 wcn36xx_hal_persona; + + u8 spectrum_mgt_enable; + + /* HAL fills in the tx power used for mgmt frames in txMgmtPower */ + s8 tx_mgmt_power; + + /* maxTxPower has max power to be used after applying the power + * constraint if any */ + s8 max_tx_power; +} __packed; + +struct wcn36xx_hal_config_bss_req_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_config_bss_params bss_params; +} __packed; + +struct wcn36xx_hal_config_bss_params_v1 { + /* BSSID */ + u8 bssid[ETH_ALEN]; + + /* Self Mac Address */ + u8 self_mac_addr[ETH_ALEN]; + + /* BSS type */ + enum wcn36xx_hal_bss_type bss_type; + + /* Operational Mode: AP =0, STA = 1 */ + u8 oper_mode; + + /* Network Type */ + enum wcn36xx_hal_nw_type nw_type; + + /* Used to classify PURE_11G/11G_MIXED to program MTU */ + u8 short_slot_time_supported; + + /* Co-exist with 11a STA */ + u8 lla_coexist; + + /* Co-exist with 11b STA */ + u8 llb_coexist; + + /* Co-exist with 11g STA */ + u8 llg_coexist; + + /* Coexistence with 11n STA */ + u8 ht20_coexist; + + /* Non GF coexist flag */ + u8 lln_non_gf_coexist; + + /* TXOP protection support */ + u8 lsig_tx_op_protection_full_support; + + /* RIFS mode */ + u8 rifs_mode; + + /* Beacon Interval in TU */ + u16 beacon_interval; + + /* DTIM period */ + u8 dtim_period; + + /* TX Width Set: 0 - 20 MHz only, 1 - 20/40 MHz */ + u8 tx_channel_width_set; + + /* Operating channel */ + u8 oper_channel; + + /* Extension channel for channel bonding */ + u8 ext_channel; + + /* Reserved to align next field on a dword boundary */ + u8 reserved; + + /* SSID of the BSS */ + struct wcn36xx_hal_mac_ssid ssid; + + /* HAL should update the existing BSS entry, if this flag is set. + * UMAC will set this flag in case of reassoc, where we want to + * resue the the old BSSID and still return success 0 = Add, 1 = + * Update */ + u8 action; + + /* MAC Rate Set */ + struct wcn36xx_hal_rate_set rateset; + + /* Enable/Disable HT capabilities of the BSS */ + u8 ht; + + /* Enable/Disable OBSS protection */ + u8 obss_prot_enabled; + + /* RMF enabled/disabled */ + u8 rmf; + + /* HT Operating Mode operating mode of the 802.11n STA */ + enum wcn36xx_hal_ht_operating_mode ht_oper_mode; + + /* Dual CTS Protection: 0 - Unused, 1 - Used */ + u8 dual_cts_protection; + + /* Probe Response Max retries */ + u8 max_probe_resp_retry_limit; + + /* To Enable Hidden ssid */ + u8 hidden_ssid; + + /* To Enable Disable FW Proxy Probe Resp */ + u8 proxy_probe_resp; + + /* Boolean to indicate if EDCA params are valid. UMAC might not + * have valid EDCA params or might not desire to apply EDCA params + * during config BSS. 0 implies Not Valid ; Non-Zero implies + * valid */ + u8 edca_params_valid; + + /* EDCA Parameters for Best Effort Access Category */ + struct wcn36xx_hal_edca_param_record acbe; + + /* EDCA Parameters forBackground Access Category */ + struct wcn36xx_hal_edca_param_record acbk; + + /* EDCA Parameters for Video Access Category */ + struct wcn36xx_hal_edca_param_record acvi; + + /* EDCA Parameters for Voice Access Category */ + struct wcn36xx_hal_edca_param_record acvo; + + /* Ext Bss Config Msg if set */ + u8 ext_set_sta_key_param_valid; + + /* SetStaKeyParams for ext bss msg */ + struct wcn36xx_hal_set_sta_key_params ext_set_sta_key_param; + + /* Persona for the BSS can be STA,AP,GO,CLIENT value same as enum + * wcn36xx_hal_con_mode */ + u8 wcn36xx_hal_persona; + + u8 spectrum_mgt_enable; + + /* HAL fills in the tx power used for mgmt frames in txMgmtPower */ + s8 tx_mgmt_power; + + /* maxTxPower has max power to be used after applying the power + * constraint if any */ + s8 max_tx_power; + + /* Context of the station being added in HW + * Add a STA entry for "itself" - + * + * On AP - Add the AP itself in an "STA context" + * + * On STA - Add the AP to which this STA is joining in an + * "STA context" + */ + struct wcn36xx_hal_config_sta_params_v1 sta; +} __packed; + +struct wcn36xx_hal_config_bss_req_msg_v1 { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_config_bss_params_v1 bss_params; +} __packed; + +struct wcn36xx_hal_config_bss_rsp_params { + /* Success or Failure */ + u32 status; + + /* BSS index allocated by HAL */ + u8 bss_index; + + /* DPU descriptor index for PTK */ + u8 dpu_desc_index; + + /* PTK DPU signature */ + u8 ucast_dpu_signature; + + /* DPU descriptor index for GTK */ + u8 bcast_dpu_desc_indx; + + /* GTK DPU signature */ + u8 bcast_dpu_signature; + + /* DPU descriptor for IGTK */ + u8 mgmt_dpu_desc_index; + + /* IGTK DPU signature */ + u8 mgmt_dpu_signature; + + /* Station Index for BSS entry */ + u8 bss_sta_index; + + /* Self station index for this BSS */ + u8 bss_self_sta_index; + + /* Bcast station for buffering bcast frames in AP role */ + u8 bss_bcast_sta_idx; + + /* MAC Address of STA(PEER/SELF) in staContext of configBSSReq */ + u8 mac[ETH_ALEN]; + + /* HAL fills in the tx power used for mgmt frames in this field. */ + s8 tx_mgmt_power; + +} __packed; + +struct wcn36xx_hal_config_bss_rsp_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_config_bss_rsp_params bss_rsp_params; +} __packed; + +struct wcn36xx_hal_delete_bss_req_msg { + struct wcn36xx_hal_msg_header header; + + /* BSS index to be deleted */ + u8 bss_index; + +} __packed; + +struct wcn36xx_hal_delete_bss_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* Success or Failure */ + u32 status; + + /* BSS index that has been deleted */ + u8 bss_index; + +} __packed; + +struct wcn36xx_hal_join_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Indicates the BSSID to which STA is going to associate */ + u8 bssid[ETH_ALEN]; + + /* Indicates the channel to switch to. */ + u8 channel; + + /* Self STA MAC */ + u8 self_sta_mac_addr[ETH_ALEN]; + + /* Local power constraint */ + u8 local_power_constraint; + + /* Secondary channel offset */ + enum phy_chan_bond_state secondary_channel_offset; + + /* link State */ + enum wcn36xx_hal_link_state link_state; + + /* Max TX power */ + s8 max_tx_power; +} __packed; + +struct wcn36xx_hal_join_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + + /* HAL fills in the tx power used for mgmt frames in this field */ + u8 tx_mgmt_power; +} __packed; + +struct post_assoc_req_msg { + struct wcn36xx_hal_msg_header header; + + struct wcn36xx_hal_config_sta_params sta_params; + struct wcn36xx_hal_config_bss_params bss_params; +}; + +struct post_assoc_rsp_msg { + struct wcn36xx_hal_msg_header header; + struct config_sta_rsp_params sta_rsp_params; + struct wcn36xx_hal_config_bss_rsp_params bss_rsp_params; +}; + +/* This is used to create a set of WEP keys for a given BSS. */ +struct wcn36xx_hal_set_bss_key_req_msg { + struct wcn36xx_hal_msg_header header; + + /* BSS Index of the BSS */ + u8 bss_idx; + + /* Encryption Type used with peer */ + enum ani_ed_type enc_type; + + /* Number of keys */ + u8 num_keys; + + /* Array of keys. */ + struct wcn36xx_hal_keys keys[WCN36XX_HAL_MAC_MAX_NUM_OF_DEFAULT_KEYS]; + + /* Control for Replay Count, 1= Single TID based replay count on Tx + * 0 = Per TID based replay count on TX */ + u8 single_tid_rc; +} __packed; + +/* tagged version of set bss key */ +struct wcn36xx_hal_set_bss_key_req_msg_tagged { + struct wcn36xx_hal_set_bss_key_req_msg Msg; + u32 tag; +} __packed; + +struct wcn36xx_hal_set_bss_key_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +/* + * This is used configure the key information on a given station. + * When the sec_type is WEP40 or WEP104, the def_wep_idx is used to locate + * a preconfigured key from a BSS the station assoicated with; otherwise + * a new key descriptor is created based on the key field. + */ +struct wcn36xx_hal_set_sta_key_req_msg { + struct wcn36xx_hal_msg_header header; + struct wcn36xx_hal_set_sta_key_params set_sta_key_params; +} __packed; + +struct wcn36xx_hal_set_sta_key_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +struct wcn36xx_hal_remove_bss_key_req_msg { + struct wcn36xx_hal_msg_header header; + + /* BSS Index of the BSS */ + u8 bss_idx; + + /* Encryption Type used with peer */ + enum ani_ed_type enc_type; + + /* Key Id */ + u8 key_id; + + /* STATIC/DYNAMIC. Used in Nullifying in Key Descriptors for + * Static/Dynamic keys */ + enum ani_wep_type wep_type; +} __packed; + +struct wcn36xx_hal_remove_bss_key_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +/* + * This is used by PE to Remove the key information on a given station. + */ +struct wcn36xx_hal_remove_sta_key_req_msg { + struct wcn36xx_hal_msg_header header; + + /* STA Index */ + u16 sta_idx; + + /* Encryption Type used with peer */ + enum ani_ed_type enc_type; + + /* Key Id */ + u8 key_id; + + /* Whether to invalidate the Broadcast key or Unicast key. In case + * of WEP, the same key is used for both broadcast and unicast. */ + u8 unicast; + +} __packed; + +struct wcn36xx_hal_remove_sta_key_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /*success or failure */ + u32 status; + +} __packed; + +#ifdef FEATURE_OEM_DATA_SUPPORT + +#ifndef OEM_DATA_REQ_SIZE +#define OEM_DATA_REQ_SIZE 134 +#endif + +#ifndef OEM_DATA_RSP_SIZE +#define OEM_DATA_RSP_SIZE 1968 +#endif + +struct start_oem_data_req_msg { + struct wcn36xx_hal_msg_header header; + + u32 status; + tSirMacAddr self_mac_addr; + u8 oem_data_req[OEM_DATA_REQ_SIZE]; + +}; + +struct start_oem_data_rsp_msg { + struct wcn36xx_hal_msg_header header; + + u8 oem_data_rsp[OEM_DATA_RSP_SIZE]; +}; + +#endif + +struct wcn36xx_hal_switch_channel_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Channel number */ + u8 channel_number; + + /* Local power constraint */ + u8 local_power_constraint; + + /* Secondary channel offset */ + enum phy_chan_bond_state secondary_channel_offset; + + /* HAL fills in the tx power used for mgmt frames in this field. */ + u8 tx_mgmt_power; + + /* Max TX power */ + u8 max_tx_power; + + /* Self STA MAC */ + u8 self_sta_mac_addr[ETH_ALEN]; + + /* VO WIFI comment: BSSID needed to identify session. As the + * request has power constraints, this should be applied only to + * that session Since MTU timing and EDCA are sessionized, this + * struct needs to be sessionized and bssid needs to be out of the + * VOWifi feature flag V IMP: Keep bssId field at the end of this + * msg. It is used to mantain backward compatbility by way of + * ignoring if using new host/old FW or old host/new FW since it is + * at the end of this struct + */ + u8 bssid[ETH_ALEN]; +} __packed; + +struct wcn36xx_hal_switch_channel_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* Status */ + u32 status; + + /* Channel number - same as in request */ + u8 channel_number; + + /* HAL fills in the tx power used for mgmt frames in this field */ + u8 tx_mgmt_power; + + /* BSSID needed to identify session - same as in request */ + u8 bssid[ETH_ALEN]; + +} __packed; + +struct update_edca_params_req_msg { + struct wcn36xx_hal_msg_header header; + + /*BSS Index */ + u16 bss_index; + + /* Best Effort */ + struct wcn36xx_hal_edca_param_record acbe; + + /* Background */ + struct wcn36xx_hal_edca_param_record acbk; + + /* Video */ + struct wcn36xx_hal_edca_param_record acvi; + + /* Voice */ + struct wcn36xx_hal_edca_param_record acvo; +}; + +struct update_edca_params_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +struct dpu_stats_params { + /* Index of STA to which the statistics */ + u16 sta_index; + + /* Encryption mode */ + u8 enc_mode; + + /* status */ + u32 status; + + /* Statistics */ + u32 send_blocks; + u32 recv_blocks; + u32 replays; + u8 mic_error_cnt; + u32 prot_excl_cnt; + u16 format_err_cnt; + u16 un_decryptable_cnt; + u32 decrypt_err_cnt; + u32 decrypt_ok_cnt; +}; + +struct wcn36xx_hal_stats_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Valid STA Idx for per STA stats request */ + u32 sta_id; + + /* Categories of stats requested as specified in eHalStatsMask */ + u32 stats_mask; +}; + +struct ani_summary_stats_info { + /* Total number of packets(per AC) that were successfully + * transmitted with retries */ + u32 retry_cnt[4]; + + /* The number of MSDU packets and MMPDU frames per AC that the + * 802.11 station successfully transmitted after more than one + * retransmission attempt */ + u32 multiple_retry_cnt[4]; + + /* Total number of packets(per AC) that were successfully + * transmitted (with and without retries, including multi-cast, + * broadcast) */ + u32 tx_frm_cnt[4]; + + /* Total number of packets that were successfully received (after + * appropriate filter rules including multi-cast, broadcast) */ + u32 rx_frm_cnt; + + /* Total number of duplicate frames received successfully */ + u32 frm_dup_cnt; + + /* Total number packets(per AC) failed to transmit */ + u32 fail_cnt[4]; + + /* Total number of RTS/CTS sequence failures for transmission of a + * packet */ + u32 rts_fail_cnt; + + /* Total number packets failed transmit because of no ACK from the + * remote entity */ + u32 ack_fail_cnt; + + /* Total number of RTS/CTS sequence success for transmission of a + * packet */ + u32 rts_succ_cnt; + + /* The sum of the receive error count and dropped-receive-buffer + * error count. HAL will provide this as a sum of (FCS error) + + * (Fail get BD/PDU in HW) */ + u32 rx_discard_cnt; + + /* + * The receive error count. HAL will provide the RxP FCS error + * global counter. */ + u32 rx_error_cnt; + + /* The sum of the transmit-directed byte count, transmit-multicast + * byte count and transmit-broadcast byte count. HAL will sum TPE + * UC/MC/BCAST global counters to provide this. */ + u32 tx_byte_cnt; +}; + +/* defines tx_rate_flags */ +enum tx_rate_info { + /* Legacy rates */ + HAL_TX_RATE_LEGACY = 0x1, + + /* HT20 rates */ + HAL_TX_RATE_HT20 = 0x2, + + /* HT40 rates */ + HAL_TX_RATE_HT40 = 0x4, + + /* Rate with Short guard interval */ + HAL_TX_RATE_SGI = 0x8, + + /* Rate with Long guard interval */ + HAL_TX_RATE_LGI = 0x10 +}; + +struct ani_global_class_a_stats_info { + /* The number of MPDU frames received by the 802.11 station for + * MSDU packets or MMPDU frames */ + u32 rx_frag_cnt; + + /* The number of MPDU frames received by the 802.11 station for + * MSDU packets or MMPDU frames when a promiscuous packet filter + * was enabled */ + u32 promiscuous_rx_frag_cnt; + + /* The receiver input sensitivity referenced to a FER of 8% at an + * MPDU length of 1024 bytes at the antenna connector. Each element + * of the array shall correspond to a supported rate and the order + * shall be the same as the supporteRates parameter. */ + u32 rx_input_sensitivity; + + /* The maximum transmit power in dBm upto one decimal. for eg: if + * it is 10.5dBm, the value would be 105 */ + u32 max_pwr; + + /* Number of times the receiver failed to synchronize with the + * incoming signal after detecting the sync in the preamble of the + * transmitted PLCP protocol data unit. */ + u32 sync_fail_cnt; + + /* Legacy transmit rate, in units of 500 kbit/sec, for the most + * recently transmitted frame */ + u32 tx_rate; + + /* mcs index for HT20 and HT40 rates */ + u32 mcs_index; + + /* to differentiate between HT20 and HT40 rates; short and long + * guard interval */ + u32 tx_rate_flags; +}; + +struct ani_global_security_stats { + /* The number of unencrypted received MPDU frames that the MAC + * layer discarded when the IEEE 802.11 dot11ExcludeUnencrypted + * management information base (MIB) object is enabled */ + u32 rx_wep_unencrypted_frm_cnt; + + /* The number of received MSDU packets that that the 802.11 station + * discarded because of MIC failures */ + u32 rx_mic_fail_cnt; + + /* The number of encrypted MPDU frames that the 802.11 station + * failed to decrypt because of a TKIP ICV error */ + u32 tkip_icv_err; + + /* The number of received MPDU frames that the 802.11 discarded + * because of an invalid AES-CCMP format */ + u32 aes_ccmp_format_err; + + /* The number of received MPDU frames that the 802.11 station + * discarded because of the AES-CCMP replay protection procedure */ + u32 aes_ccmp_replay_cnt; + + /* The number of received MPDU frames that the 802.11 station + * discarded because of errors detected by the AES-CCMP decryption + * algorithm */ + u32 aes_ccmp_decrpt_err; + + /* The number of encrypted MPDU frames received for which a WEP + * decryption key was not available on the 802.11 station */ + u32 wep_undecryptable_cnt; + + /* The number of encrypted MPDU frames that the 802.11 station + * failed to decrypt because of a WEP ICV error */ + u32 wep_icv_err; + + /* The number of received encrypted packets that the 802.11 station + * successfully decrypted */ + u32 rx_decrypt_succ_cnt; + + /* The number of encrypted packets that the 802.11 station failed + * to decrypt */ + u32 rx_decrypt_fail_cnt; +}; + +struct ani_global_class_b_stats_info { + struct ani_global_security_stats uc_stats; + struct ani_global_security_stats mc_bc_stats; +}; + +struct ani_global_class_c_stats_info { + /* This counter shall be incremented for a received A-MSDU frame + * with the stations MAC address in the address 1 field or an + * A-MSDU frame with a group address in the address 1 field */ + u32 rx_amsdu_cnt; + + /* This counter shall be incremented when the MAC receives an AMPDU + * from the PHY */ + u32 rx_ampdu_cnt; + + /* This counter shall be incremented when a Frame is transmitted + * only on the primary channel */ + u32 tx_20_frm_cnt; + + /* This counter shall be incremented when a Frame is received only + * on the primary channel */ + u32 rx_20_frm_cnt; + + /* This counter shall be incremented by the number of MPDUs + * received in the A-MPDU when an A-MPDU is received */ + u32 rx_mpdu_in_ampdu_cnt; + + /* This counter shall be incremented when an MPDU delimiter has a + * CRC error when this is the first CRC error in the received AMPDU + * or when the previous delimiter has been decoded correctly */ + u32 ampdu_delimiter_crc_err; +}; + +struct ani_per_sta_stats_info { + /* The number of MPDU frames that the 802.11 station transmitted + * and acknowledged through a received 802.11 ACK frame */ + u32 tx_frag_cnt[4]; + + /* This counter shall be incremented when an A-MPDU is transmitted */ + u32 tx_ampdu_cnt; + + /* This counter shall increment by the number of MPDUs in the AMPDU + * when an A-MPDU is transmitted */ + u32 tx_mpdu_in_ampdu_cnt; +}; + +struct wcn36xx_hal_stats_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* Success or Failure */ + u32 status; + + /* STA Idx */ + u32 sta_index; + + /* Categories of STATS being returned as per eHalStatsMask */ + u32 stats_mask; + + /* message type is same as the request type */ + u16 msg_type; + + /* length of the entire request, includes the pStatsBuf length too */ + u16 msg_len; +}; + +struct wcn36xx_hal_set_link_state_req_msg { + struct wcn36xx_hal_msg_header header; + + u8 bssid[ETH_ALEN]; + enum wcn36xx_hal_link_state state; + u8 self_mac_addr[ETH_ALEN]; + +} __packed; + +struct set_link_state_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +/* TSPEC Params */ +struct wcn36xx_hal_ts_info_tfc { +#ifndef ANI_LITTLE_BIT_ENDIAN + u16 ackPolicy:2; + u16 userPrio:3; + u16 psb:1; + u16 aggregation:1; + u16 accessPolicy:2; + u16 direction:2; + u16 tsid:4; + u16 trafficType:1; +#else + u16 trafficType:1; + u16 tsid:4; + u16 direction:2; + u16 accessPolicy:2; + u16 aggregation:1; + u16 psb:1; + u16 userPrio:3; + u16 ackPolicy:2; +#endif +}; + +/* Flag to schedule the traffic type */ +struct wcn36xx_hal_ts_info_sch { +#ifndef ANI_LITTLE_BIT_ENDIAN + u8 rsvd:7; + u8 schedule:1; +#else + u8 schedule:1; + u8 rsvd:7; +#endif +}; + +/* Traffic and scheduling info */ +struct wcn36xx_hal_ts_info { + struct wcn36xx_hal_ts_info_tfc traffic; + struct wcn36xx_hal_ts_info_sch schedule; +}; + +/* Information elements */ +struct wcn36xx_hal_tspec_ie { + u8 type; + u8 length; + struct wcn36xx_hal_ts_info ts_info; + u16 nom_msdu_size; + u16 max_msdu_size; + u32 min_svc_interval; + u32 max_svc_interval; + u32 inact_interval; + u32 suspend_interval; + u32 svc_start_time; + u32 min_data_rate; + u32 mean_data_rate; + u32 peak_data_rate; + u32 max_burst_sz; + u32 delay_bound; + u32 min_phy_rate; + u16 surplus_bw; + u16 medium_time; +}; + +struct add_ts_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Station Index */ + u16 sta_index; + + /* TSPEC handler uniquely identifying a TSPEC for a STA in a BSS */ + u16 tspec_index; + + /* To program TPE with required parameters */ + struct wcn36xx_hal_tspec_ie tspec; + + /* U-APSD Flags: 1b per AC. Encoded as follows: + b7 b6 b5 b4 b3 b2 b1 b0 = + X X X X BE BK VI VO */ + u8 uapsd; + + /* These parameters are for all the access categories */ + + /* Service Interval */ + u32 service_interval[WCN36XX_HAL_MAX_AC]; + + /* Suspend Interval */ + u32 suspend_interval[WCN36XX_HAL_MAX_AC]; + + /* Delay Interval */ + u32 delay_interval[WCN36XX_HAL_MAX_AC]; +}; + +struct add_rs_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +struct del_ts_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Station Index */ + u16 sta_index; + + /* TSPEC identifier uniquely identifying a TSPEC for a STA in a BSS */ + u16 tspec_index; + + /* To lookup station id using the mac address */ + u8 bssid[ETH_ALEN]; +}; + +struct del_ts_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +/* End of TSpec Parameters */ + +/* Start of BLOCK ACK related Parameters */ + +struct wcn36xx_hal_add_ba_session_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Station Index */ + u16 sta_index; + + /* Peer MAC Address */ + u8 mac_addr[ETH_ALEN]; + + /* ADDBA Action Frame dialog token + HAL will not interpret this object */ + u8 dialog_token; + + /* TID for which the BA is being setup + This identifies the TC or TS of interest */ + u8 tid; + + /* 0 - Delayed BA (Not supported) + 1 - Immediate BA */ + u8 policy; + + /* Indicates the number of buffers for this TID (baTID) + NOTE - This is the requested buffer size. When this + is processed by HAL and subsequently by HDD, it is + possible that HDD may change this buffer size. Any + change in the buffer size should be noted by PE and + advertized appropriately in the ADDBA response */ + u16 buffer_size; + + /* BA timeout in TU's 0 means no timeout will occur */ + u16 timeout; + + /* b0..b3 - Fragment Number - Always set to 0 + b4..b15 - Starting Sequence Number of first MSDU + for which this BA is setup */ + u16 ssn; + + /* ADDBA direction + 1 - Originator + 0 - Recipient */ + u8 direction; +} __packed; + +struct wcn36xx_hal_add_ba_session_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + + /* Dialog token */ + u8 dialog_token; + + /* TID for which the BA session has been setup */ + u8 ba_tid; + + /* BA Buffer Size allocated for the current BA session */ + u8 ba_buffer_size; + + u8 ba_session_id; + + /* Reordering Window buffer */ + u8 win_size; + + /* Station Index to id the sta */ + u8 sta_index; + + /* Starting Sequence Number */ + u16 ssn; +} __packed; + +struct wcn36xx_hal_add_ba_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Session Id */ + u8 session_id; + + /* Reorder Window Size */ + u8 win_size; +/* Old FW 1.2.2.4 does not support this*/ +#ifdef FEATURE_ON_CHIP_REORDERING + u8 reordering_done_on_chip; +#endif +} __packed; + +struct wcn36xx_hal_add_ba_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; + + /* Dialog token */ + u8 dialog_token; +} __packed; + +struct add_ba_info { + u16 ba_enable:1; + u16 starting_seq_num:12; + u16 reserved:3; +}; + +struct wcn36xx_hal_trigger_ba_rsp_candidate { + u8 sta_addr[ETH_ALEN]; + struct add_ba_info ba_info[STACFG_MAX_TC]; +} __packed; + +struct wcn36xx_hal_trigget_ba_req_candidate { + u8 sta_index; + u8 tid_bitmap; +} __packed; + +struct wcn36xx_hal_trigger_ba_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Session Id */ + u8 session_id; + + /* baCandidateCnt is followed by trigger BA + * Candidate List(tTriggerBaCandidate) + */ + u16 candidate_cnt; + +} __packed; + +struct wcn36xx_hal_trigger_ba_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* TO SUPPORT BT-AMP */ + u8 bssid[ETH_ALEN]; + + /* success or failure */ + u32 status; + + /* baCandidateCnt is followed by trigger BA + * Rsp Candidate List(tTriggerRspBaCandidate) + */ + u16 candidate_cnt; +} __packed; + +struct wcn36xx_hal_del_ba_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Station Index */ + u16 sta_index; + + /* TID for which the BA session is being deleted */ + u8 tid; + + /* DELBA direction + 1 - Originator + 0 - Recipient */ + u8 direction; +} __packed; + +struct wcn36xx_hal_del_ba_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +} __packed; + +struct tsm_stats_req_msg { + struct wcn36xx_hal_msg_header header; + + /* Traffic Id */ + u8 tid; + + u8 bssid[ETH_ALEN]; +}; + +struct tsm_stats_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /*success or failure */ + u32 status; + + /* Uplink Packet Queue delay */ + u16 uplink_pkt_queue_delay; + + /* Uplink Packet Queue delay histogram */ + u16 uplink_pkt_queue_delay_hist[4]; + + /* Uplink Packet Transmit delay */ + u32 uplink_pkt_tx_delay; + + /* Uplink Packet loss */ + u16 uplink_pkt_loss; + + /* Uplink Packet count */ + u16 uplink_pkt_count; + + /* Roaming count */ + u8 roaming_count; + + /* Roaming Delay */ + u16 roaming_delay; +}; + +struct set_key_done_msg { + struct wcn36xx_hal_msg_header header; + + /*bssid of the keys */ + u8 bssidx; + u8 enc_type; +}; + +struct wcn36xx_hal_nv_img_download_req_msg { + /* Note: The length specified in wcn36xx_hal_nv_img_download_req_msg + * messages should be + * header.len = sizeof(wcn36xx_hal_nv_img_download_req_msg) + + * nv_img_buffer_size */ + struct wcn36xx_hal_msg_header header; + + /* Fragment sequence number of the NV Image. Note that NV Image + * might not fit into one message due to size limitation of the SMD + * channel FIFO. UMAC can hence choose to chop the NV blob into + * multiple fragments starting with seqeunce number 0, 1, 2 etc. + * The last fragment MUST be indicated by marking the + * isLastFragment field to 1. Note that all the NV blobs would be + * concatenated together by HAL without any padding bytes in + * between.*/ + u16 frag_number; + + /* Is this the last fragment? When set to 1 it indicates that no + * more fragments will be sent by UMAC and HAL can concatenate all + * the NV blobs rcvd & proceed with the parsing. HAL would generate + * a WCN36XX_HAL_DOWNLOAD_NV_RSP to the WCN36XX_HAL_DOWNLOAD_NV_REQ + * after it receives each fragment */ + u16 last_fragment; + + /* NV Image size (number of bytes) */ + u32 nv_img_buffer_size; + + /* Following the 'nv_img_buffer_size', there should be + * nv_img_buffer_size bytes of NV Image i.e. + * u8[nv_img_buffer_size] */ +} __packed; + +struct wcn36xx_hal_nv_img_download_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* Success or Failure. HAL would generate a + * WCN36XX_HAL_DOWNLOAD_NV_RSP after each fragment */ + u32 status; +} __packed; + +struct wcn36xx_hal_nv_store_ind { + /* Note: The length specified in tHalNvStoreInd messages should be + * header.msgLen = sizeof(tHalNvStoreInd) + nvBlobSize */ + struct wcn36xx_hal_msg_header header; + + /* NV Item */ + u32 table_id; + + /* Size of NV Blob */ + u32 nv_blob_size; + + /* Following the 'nvBlobSize', there should be nvBlobSize bytes of + * NV blob i.e. u8[nvBlobSize] */ +}; + +/* End of Block Ack Related Parameters */ + +#define WCN36XX_HAL_CIPHER_SEQ_CTR_SIZE 6 + +/* Definition for MIC failure indication MAC reports this each time a MIC + * failure occures on Rx TKIP packet + */ +struct mic_failure_ind_msg { + struct wcn36xx_hal_msg_header header; + + u8 bssid[ETH_ALEN]; + + /* address used to compute MIC */ + u8 src_addr[ETH_ALEN]; + + /* transmitter address */ + u8 ta_addr[ETH_ALEN]; + + u8 dst_addr[ETH_ALEN]; + + u8 multicast; + + /* first byte of IV */ + u8 iv1; + + /* second byte of IV */ + u8 key_id; + + /* sequence number */ + u8 tsc[WCN36XX_HAL_CIPHER_SEQ_CTR_SIZE]; + + /* receive address */ + u8 rx_addr[ETH_ALEN]; +}; + +struct update_vht_op_mode_req_msg { + struct wcn36xx_hal_msg_header header; + + u16 op_mode; + u16 sta_id; +}; + +struct update_vht_op_mode_params_rsp_msg { + struct wcn36xx_hal_msg_header header; + + u32 status; +}; + +struct update_beacon_req_msg { + struct wcn36xx_hal_msg_header header; + + u8 bss_index; + + /* shortPreamble mode. HAL should update all the STA rates when it + * receives this message */ + u8 short_preamble; + + /* short Slot time. */ + u8 short_slot_time; + + /* Beacon Interval */ + u16 beacon_interval; + + /* Protection related */ + u8 lla_coexist; + u8 llb_coexist; + u8 llg_coexist; + u8 ht20_coexist; + u8 lln_non_gf_coexist; + u8 lsig_tx_op_protection_full_support; + u8 rifs_mode; + + u16 param_change_bitmap; +}; + +struct update_beacon_rsp_msg { + struct wcn36xx_hal_msg_header header; + u32 status; +}; + +struct wcn36xx_hal_send_beacon_req_msg { + struct wcn36xx_hal_msg_header header; + + /* length of the template. */ + u32 beacon_length; + + /* Beacon data. */ + u8 beacon[BEACON_TEMPLATE_SIZE]; + + u8 bssid[ETH_ALEN]; + + /* TIM IE offset from the beginning of the template. */ + u32 tim_ie_offset; + + /* P2P IE offset from the begining of the template */ + u16 p2p_ie_offset; +} __packed; + +struct send_beacon_rsp_msg { + struct wcn36xx_hal_msg_header header; + u32 status; +} __packed; + +struct enable_radar_req_msg { + struct wcn36xx_hal_msg_header header; + + u8 bssid[ETH_ALEN]; + u8 channel; +}; + +struct enable_radar_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* Link Parameters */ + u8 bssid[ETH_ALEN]; + + /* success or failure */ + u32 status; +}; + +struct radar_detect_intr_ind_msg { + struct wcn36xx_hal_msg_header header; + + u8 radar_det_channel; +}; + +struct radar_detect_ind_msg { + struct wcn36xx_hal_msg_header header; + + /* channel number in which the RADAR detected */ + u8 channel_number; + + /* RADAR pulse width in usecond */ + u16 radar_pulse_width; + + /* Number of RADAR pulses */ + u16 num_radar_pulse; +}; + +struct wcn36xx_hal_get_tpc_report_req_msg { + struct wcn36xx_hal_msg_header header; + + u8 sta[ETH_ALEN]; + u8 dialog_token; + u8 txpower; +}; + +struct wcn36xx_hal_get_tpc_report_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +struct wcn36xx_hal_send_probe_resp_req_msg { + struct wcn36xx_hal_msg_header header; + + u8 probe_resp_template[BEACON_TEMPLATE_SIZE]; + u32 probe_resp_template_len; + u32 proxy_probe_req_valid_ie_bmap[8]; + u8 bssid[ETH_ALEN]; +}; + +struct send_probe_resp_rsp_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +struct send_unknown_frame_rx_ind_msg { + struct wcn36xx_hal_msg_header header; + + /* success or failure */ + u32 status; +}; + +struct wcn36xx_hal_delete_sta_context_ind_msg { + struct wcn36xx_hal_msg_header header; + + u16 aid; + u16 sta_id; + + /* TO SUPPORT BT-AMP */ + u8 bssid[ETH_ALEN]; + + /* HAL copies bssid from the sta table. */ + u8 addr2[ETH_ALEN]; + + /* To unify the keepalive / unknown A2 / tim-based disa */ + u16 reason_code; +} __packed; + +struct indicate_del_sta { + struct wcn36xx_hal_msg_header header; + u8 aid; + u8 sta_index; + u8 bss_index; + u8 reason_code;
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
1.8.2.2
Part of the diff is not shown here. View the raw message.
PATCH v2 7/16 wcn36xx: add pmc.c
In reply to Eugene KrasnikovAdding pmc.c
--- drivers/net/wireless/ath/wcn36xx/pmc.c | 46 ++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.c
drivers/net/wireless/ath/wcn36xx/pmc.c new file +46 -0
@@ -0,0 +1,46 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include "wcn36xx.h" + +int wcn36xx_pmc_init (struct wcn36xx *wcn) +{ + wcn->pw_state =WCN36XX_FULL_POWER ; +return 0 ; +} + +int wcn36xx_pmc_enter_bmps_state (struct wcn36xx *wcn,u64 tsf) +{ +/* TODO: Make sure the TX chain clean */ +wcn36xx_smd_enter_bmps (wcn, tsf); + wcn->pw_state =WCN36XX_BMPS ; +return 0 ; +} + +int wcn36xx_pmc_exit_bmps_state (struct wcn36xx *wcn) +{ +wcn36xx_smd_exit_bmps (wcn); + wcn->pw_state =WCN36XX_FULL_POWER ; +return 0 ; +} + +int wcn36xx_enable_keep_alive_null_packet (struct wcn36xx *wcn) +{ +wcn36xx_dbg (WCN36XX_DBG_PMC ,"%s\n" , __func__); +return wcn36xx_smd_keep_alive_req (wcn,WCN36XX_HAL_KEEP_ALIVE_NULL_PKT ); +}
Signature · 1 line
1.8.2.2
PATCH v2 8/16 wcn36xx: add pmc.h
In reply to Eugene KrasnikovAdding pmc.h
--- drivers/net/wireless/ath/wcn36xx/pmc.h | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/pmc.h
drivers/net/wireless/ath/wcn36xx/pmc.h new file +32 -0
@@ -0,0 +1,32 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _WCN36XX_PMC_H_ +#define _WCN36XX_PMC_H_ + +struct wcn36xx ; + +enum wcn36xx_power_state { +WCN36XX_FULL_POWER , +WCN36XX_BMPS +}; + +int wcn36xx_pmc_init (struct wcn36xx *wcn); +int wcn36xx_pmc_enter_bmps_state (struct wcn36xx *wcn,u64 tbtt); +int wcn36xx_pmc_exit_bmps_state (struct wcn36xx *wcn); +int wcn36xx_enable_keep_alive_null_packet (struct wcn36xx *wcn); +int wcn36xx_enable_keep_alive_null_packet (struct wcn36xx *wcn); +#endif /* _WCN36XX_PMC_H_ */
Signature · 1 line
1.8.2.2
PATCH v2 9/16 wcn36xx: add smd.c
In reply to Eugene KrasnikovAdding smd.c
--- drivers/net/wireless/ath/wcn36xx/smd.c | 1530 ++++++++++++++++++++++++++++++++ 1 file changed, 1530 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.c
drivers/net/wireless/ath/wcn36xx/smd.c new file +1530 -0
@@ -0,0 +1,1530 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include <linux/etherdevice.h> +#include <linux/firmware.h> +#include <linux/bitops.h> +#include "smd.h" + +static int put_cfg_tlv_u32 (struct wcn36xx *wcn,size_t *len,u32 id,u32 value) +{ +struct wcn36xx_hal_cfg *entry; +u32 *val; + +if (*len +sizeof (*entry) +sizeof (u32) >=WCN36XX_SMD_BUF_SIZE ) { +wcn36xx_err ("Not enough room for TLV entry\n" ); +return -ENOMEM ; + } + + entry = (struct wcn36xx_hal_cfg *) (wcn->smd_buf + *len); + entry->id = id; + entry->len =sizeof (u32); + entry->pad_bytes =0 ; + entry->reserve =0 ; + + val = (u32 *) (entry +1 ); + *val = value; + + *len +=sizeof (*entry) +sizeof (u32); + +return 0 ; +} + +static void wcn36xx_smd_set_bss_nw_type (struct wcn36xx *wcn, +struct ieee80211_sta *sta, +struct wcn36xx_hal_config_bss_params *bss_params) +{ +if (IEEE80211_BAND_5GHZ ==WCN36XX_BAND (wcn)) + bss_params->nw_type =WCN36XX_HAL_11A_NW_TYPE ; +else if (sta && sta->ht_cap.ht_supported) + bss_params->nw_type =WCN36XX_HAL_11N_NW_TYPE ; +else if (sta && (sta->supp_rates[IEEE80211_BAND_2GHZ ] &0x7f )) + bss_params->nw_type =WCN36XX_HAL_11G_NW_TYPE ; +else + bss_params->nw_type =WCN36XX_HAL_11B_NW_TYPE ; +} + +static void wcn36xx_smd_set_bss_ht_params (struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct wcn36xx_hal_config_bss_params *bss_params) +{ +if (sta && sta->ht_cap.ht_supported) { +unsigned long caps = sta->ht_cap.cap; + bss_params->ht = sta->ht_cap.ht_supported; + bss_params->tx_channel_width_set = +test_bit (IEEE80211_HT_CAP_SUP_WIDTH_20_40 , &caps); + bss_params->lsig_tx_op_protection_full_support = +test_bit (IEEE80211_HT_CAP_LSIG_TXOP_PROT , &caps); + + bss_params->ht_oper_mode = vif->bss_conf.ht_operation_mode; + bss_params->lln_non_gf_coexist = + !!(vif->bss_conf.ht_operation_mode & +IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT ); +/* IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT */ + bss_params->dual_cts_protection =0 ; +/* IEEE80211_HT_OP_MODE_PROTECTION_20MHZ */ + bss_params->ht20_coexist =0 ; + } +} + +static void wcn36xx_smd_set_sta_ht_params (struct ieee80211_sta *sta, +struct wcn36xx_hal_config_sta_params *sta_params) +{ +if (sta->ht_cap.ht_supported) { +unsigned long caps = sta->ht_cap.cap; + sta_params->ht_capable = sta->ht_cap.ht_supported; + sta_params->tx_channel_width_set = +test_bit (IEEE80211_HT_CAP_SUP_WIDTH_20_40 , &caps); + sta_params->lsig_txop_protection = +test_bit (IEEE80211_HT_CAP_LSIG_TXOP_PROT , &caps); + + sta_params->max_ampdu_size = sta->ht_cap.ampdu_factor; + sta_params->max_ampdu_density = sta->ht_cap.ampdu_density; + sta_params->max_amsdu_size = +test_bit (IEEE80211_HT_CAP_MAX_AMSDU , &caps); + sta_params->sgi_20Mhz = +test_bit (IEEE80211_HT_CAP_SGI_20 , &caps); + sta_params->sgi_40mhz = +test_bit (IEEE80211_HT_CAP_SGI_40 , &caps); + sta_params->green_field_capable = +test_bit (IEEE80211_HT_CAP_GRN_FLD , &caps); + sta_params->delayed_ba_support = +test_bit (IEEE80211_HT_CAP_DELAY_BA , &caps); + sta_params->dsss_cck_mode_40mhz = +test_bit (IEEE80211_HT_CAP_DSSSCCK40 , &caps); + } +} + +static void wcn36xx_smd_set_sta_params (struct wcn36xx *wcn, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct wcn36xx_hal_config_sta_params *sta_params) +{ +if (vif->type ==NL80211_IFTYPE_ADHOC || + vif->type ==NL80211_IFTYPE_AP || + vif->type ==NL80211_IFTYPE_MESH_POINT ) { + sta_params->type =1 ; + sta_params->sta_index =0xFF ; + }else { + sta_params->type =0 ; + sta_params->sta_index =1 ; + } + + sta_params->aid = wcn->aid; + sta_params->listen_interval =WCN36XX_LISTEN_INTERVAL (wcn); + +/* +* In STA mode ieee80211_sta contains bssid and ieee80211_vif +* contains our mac address. In AP mode we are bssid so vif +* contains bssid and ieee80211_sta contains mac. +*/ +if (NL80211_IFTYPE_STATION == vif->type) +memcpy (&sta_params->mac, vif->addr,ETH_ALEN ); +else +memcpy (&sta_params->bssid, vif->addr,ETH_ALEN ); + + sta_params->encrypt_type = wcn->encrypt_type; + sta_params->short_preamble_supported = + !(WCN36XX_FLAGS (wcn) & +IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE ); + + sta_params->rifs_mode =0 ; + sta_params->rmf =0 ; + sta_params->action =0 ; + sta_params->uapsd =0 ; + sta_params->mimo_ps =WCN36XX_HAL_HT_MIMO_PS_STATIC ; + sta_params->max_ampdu_duration =0 ; + sta_params->bssid_index = wcn->current_vif->bss_index; + sta_params->p2p =0 ; + +memcpy (&sta_params->supported_rates, &wcn->supported_rates, +sizeof (wcn->supported_rates)); + +if (sta) { +if (NL80211_IFTYPE_STATION == vif->type) +memcpy (&sta_params->bssid, sta->addr,ETH_ALEN ); +else +memcpy (&sta_params->mac, sta->addr,ETH_ALEN ); + sta_params->wmm_enabled = sta->wme; + sta_params->max_sp_len = sta->max_sp; +wcn36xx_smd_set_sta_ht_params (sta, sta_params); + } +} + +static int wcn36xx_smd_send_and_wait (struct wcn36xx *wcn,size_t len) +{ +int ret; +wcn36xx_dbg_dump (WCN36XX_DBG_SMD_DUMP ,"SMD >>> " , wcn->smd_buf, len); + + ret = wcn->ctrl_ops->tx (wcn->smd_buf, len); +mutex_unlock (&wcn->smd_mutex); +return ret; +} + +#define INIT_HAL_MSG (msg_body, type) \ + do { \ + memset(&msg_body, 0, sizeof(msg_body)); \ + msg_body.header.msg_type = type; \ + msg_body.header.msg_version = WCN36XX_HAL_MSG_VERSION0; \ + msg_body.header.len = sizeof(msg_body); \ + } while (0) \ + +#define PREPARE_HAL_BUF (send_buf, msg_body) \ + do { \ + struct wcn36xx *__wcn = \ + container_of(&send_buf, \ + struct wcn36xx, smd_buf); \ + mutex_lock(&__wcn->smd_mutex); \ + memset(send_buf, 0, msg_body.header.len); \ + memcpy(send_buf, &msg_body, sizeof(msg_body)); \ + } while (0) \ + +static int wcn36xx_smd_rsp_status_check (void *buf,size_t len) +{ +struct wcn36xx_fw_msg_status_rsp *rsp; + +if (len <sizeof (struct wcn36xx_hal_msg_header ) + +sizeof (struct wcn36xx_fw_msg_status_rsp )) +return -EIO ; + + rsp = (struct wcn36xx_fw_msg_status_rsp *) + (buf +sizeof (struct wcn36xx_hal_msg_header )); + +if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) +return -EIO ; + +return 0 ; +} + +int wcn36xx_smd_load_nv (struct wcn36xx *wcn) +{ +const struct firmware *nv; +struct nv_data *nv_d; +struct wcn36xx_hal_nv_img_download_req_msg msg_body; +int fw_bytes_left; +int ret; +u16 fm_offset =0 ; + + ret =request_firmware (&nv,WLAN_NV_FILE , wcn->dev); +if (ret) { +wcn36xx_err ("Failed to load nv file %s: %d\n" , +WLAN_NV_FILE , ret); + goto out_free_nv; + } + + nv_d = (struct nv_data *)nv->data; +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DOWNLOAD_NV_REQ ); + + msg_body.header.len +=WCN36XX_NV_FRAGMENT_SIZE ; + + msg_body.frag_number =0 ; + +do { + fw_bytes_left = nv->size - fm_offset -4 ; +if (fw_bytes_left >WCN36XX_NV_FRAGMENT_SIZE ) { + msg_body.last_fragment =0 ; + msg_body.nv_img_buffer_size =WCN36XX_NV_FRAGMENT_SIZE ; + }else { + msg_body.last_fragment =1 ; + msg_body.nv_img_buffer_size = fw_bytes_left; + +/* Do not forget update general message len */ + msg_body.header.len =sizeof (msg_body) + fw_bytes_left; + + } +/* smd_buf must be protected with mutex */ +mutex_lock (&wcn->smd_mutex); + +/* Add load NV request message header */ +memcpy (wcn->smd_buf, &msg_body,sizeof (msg_body)); + +/* Add NV body itself */ +memcpy (wcn->smd_buf +sizeof (msg_body), + &nv_d->table + fm_offset, + msg_body.nv_img_buffer_size); + + ret =wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +if (ret) +return ret; + + msg_body.frag_number++; + fm_offset +=WCN36XX_NV_FRAGMENT_SIZE ; + + }while (msg_body.last_fragment !=1 ); + +out_free_nv: +release_firmware (nv); + +return ret; +} + +int wcn36xx_smd_start (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_mac_start_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_START_REQ ); + + msg_body.params.type =DRIVER_TYPE_PRODUCTION ; + msg_body.params.len =0 ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal start type %d\n" , + msg_body.params.type); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static int wcn36xx_smd_start_rsp (struct wcn36xx *wcn,void *buf,size_t len) +{ +struct wcn36xx_hal_mac_start_rsp_msg *rsp; + +if (len <sizeof (*rsp)) +return -EIO ; + + rsp = (struct wcn36xx_hal_mac_start_rsp_msg *)buf; + +if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->start_rsp_params.status) +return -EIO ; + +memcpy (wcn->crm_version, rsp->start_rsp_params.crm_version, +WCN36XX_HAL_VERSION_LENGTH ); +memcpy (wcn->wlan_version, rsp->start_rsp_params.wlan_version, +WCN36XX_HAL_VERSION_LENGTH ); + +/* null terminate the strings, just in case */ + wcn->crm_version[WCN36XX_HAL_VERSION_LENGTH ] ='\0' ; + wcn->wlan_version[WCN36XX_HAL_VERSION_LENGTH ] ='\0' ; + + wcn->fw_revision = rsp->start_rsp_params.version.revision; + wcn->fw_version = rsp->start_rsp_params.version.version; + wcn->fw_minor = rsp->start_rsp_params.version.minor; + wcn->fw_major = rsp->start_rsp_params.version.major; + +wcn36xx_info ("firmware WLAN version '%s' and CRM version '%s'\n" , + wcn->wlan_version, wcn->crm_version); + +wcn36xx_info ("firmware API %u.%u.%u.%u, %u stations, %u bssids\n" , + wcn->fw_major, wcn->fw_minor, + wcn->fw_version, wcn->fw_revision, + rsp->start_rsp_params.stations, + rsp->start_rsp_params.bssids); + +return 0 ; +} + +int wcn36xx_smd_stop (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_mac_stop_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_STOP_REQ ); + + msg_body.stop_req_params.reason =HAL_STOP_TYPE_RF_KILL ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_init_scan (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_init_scan_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_INIT_SCAN_REQ ); + + msg_body.mode =HAL_SYS_MODE_SCAN ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal init scan mode %d\n" , msg_body.mode); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_start_scan (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_start_scan_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_START_SCAN_REQ ); + + msg_body.scan_channel =WCN36XX_HW_CHANNEL (wcn); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal start scan channel %d\n" , + msg_body.scan_channel); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_end_scan (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_end_scan_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_END_SCAN_REQ ); + + msg_body.scan_channel =WCN36XX_HW_CHANNEL (wcn); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal end scan channel %d\n" , + msg_body.scan_channel); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_finish_scan (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_finish_scan_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_FINISH_SCAN_REQ ); + + msg_body.mode =HAL_SYS_MODE_SCAN ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal finish scan mode %d\n" , + msg_body.mode); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_switch_channel (struct wcn36xx *wcn,int ch) +{ +struct wcn36xx_hal_switch_channel_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_CH_SWITCH_REQ ); + + msg_body.channel_number = (u8 )ch; + msg_body.tx_mgmt_power =0xbf ; + msg_body.max_tx_power =0xbf ; +memcpy (msg_body.self_sta_mac_addr, wcn->addresses.addr,ETH_ALEN ); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static void wcn36xx_smd_switch_channel_rsp (void *buf,size_t len) +{ +struct wcn36xx_hal_switch_channel_rsp_msg *rsp; + rsp = (struct wcn36xx_hal_switch_channel_rsp_msg *)buf; +wcn36xx_dbg (WCN36XX_DBG_HAL ,"channel switched to: %d, status: %d\n" , + rsp->channel_number, rsp->status); +} + +int wcn36xx_smd_update_scan_params (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_update_scan_params_req msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ ); + + msg_body.dot11d_enabled =0 ; + msg_body.dot11d_resolved =0 ; + msg_body.channel_count =26 ; + msg_body.active_min_ch_time =60 ; + msg_body.active_max_ch_time =120 ; + msg_body.passive_min_ch_time =60 ; + msg_body.passive_max_ch_time =110 ; + msg_body.state =0 ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal update scan params channel_count %d\n" , + msg_body.channel_count); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static int wcn36xx_smd_update_scan_params_rsp (void *buf,size_t len) +{ +struct wcn36xx_hal_update_scan_params_resp *rsp; + + rsp = (struct wcn36xx_hal_update_scan_params_resp *)buf; + +/* Remove the PNO version bit */ + rsp->status &= (~(WCN36XX_FW_MSG_PNO_VERSION_MASK )); + +if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) { +wcn36xx_warn ("error response from update scan\n" ); +return -EIO ; + } + +return 0 ; +} + +int wcn36xx_smd_add_sta_self (struct wcn36xx *wcn,u8 *addr,u32 status) +{ +struct wcn36xx_hal_add_sta_self_req msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_ADD_STA_SELF_REQ ); + +memcpy (&msg_body.self_addr, addr,ETH_ALEN ); + msg_body.status = status; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal add sta self self_addr %pM status %d\n" , + msg_body.self_addr, msg_body.status); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static int wcn36xx_smd_add_sta_self_rsp (struct wcn36xx *wcn, +void *buf, +size_t len) +{ +struct wcn36xx_hal_add_sta_self_rsp_msg *rsp; + +if (len <sizeof (*rsp)) +return -EINVAL ; + + rsp = (struct wcn36xx_hal_add_sta_self_rsp_msg *)buf; + +if (rsp->status !=WCN36XX_FW_MSG_RESULT_SUCCESS ) { +wcn36xx_warn ("hal add sta self failure: %d\n" , + rsp->status); +return -EIO ; + } + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal add sta self status %d self_sta_index %d dpu_index %d\n" , + rsp->status, rsp->self_sta_index, rsp->dpu_index); + + wcn->current_vif->self_sta_index = rsp->self_sta_index; + wcn->current_vif->self_dpu_desc_index = rsp->dpu_index; + +return 0 ; +} + +int wcn36xx_smd_delete_sta_self (struct wcn36xx *wcn,u8 *addr) +{ +struct wcn36xx_hal_del_sta_self_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DEL_STA_SELF_REQ ); + +memcpy (&msg_body.self_addr, addr,ETH_ALEN ); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_delete_sta (struct wcn36xx *wcn,u8 sta_index) +{ +struct wcn36xx_hal_delete_sta_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DELETE_STA_REQ ); + + msg_body.sta_index = sta_index; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal delete sta sta_index %d\n" , + msg_body.sta_index); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); + +} + +int wcn36xx_smd_join (struct wcn36xx *wcn,const u8 *bssid,u8 *vif,u8 ch) +{ +struct wcn36xx_hal_join_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_JOIN_REQ ); + +memcpy (&msg_body.bssid, bssid,ETH_ALEN ); +memcpy (&msg_body.self_sta_mac_addr, vif,ETH_ALEN ); + msg_body.channel = ch; + +if (conf_is_ht40_minus (&wcn->hw->conf)) + msg_body.secondary_channel_offset = +PHY_DOUBLE_CHANNEL_HIGH_PRIMARY ; +else if (conf_is_ht40_plus (&wcn->hw->conf)) + msg_body.secondary_channel_offset = +PHY_DOUBLE_CHANNEL_LOW_PRIMARY ; +else + msg_body.secondary_channel_offset = +PHY_SINGLE_CHANNEL_CENTERED ; + + msg_body.link_state =WCN36XX_HAL_LINK_PREASSOC_STATE ; + + msg_body.max_tx_power =0xbf ; +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal join req bssid %pM self_sta_mac_addr %pM channel %d link_state %d\n" , + msg_body.bssid, msg_body.self_sta_mac_addr, + msg_body.channel, msg_body.link_state); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_set_link_st (struct wcn36xx *wcn,const u8 *bssid, +const u8 *sta_mac, +enum wcn36xx_hal_link_state state) +{ +struct wcn36xx_hal_set_link_state_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_SET_LINK_ST_REQ ); + +memcpy (&msg_body.bssid, bssid,ETH_ALEN ); +memcpy (&msg_body.self_mac_addr, sta_mac,ETH_ALEN ); + msg_body.state = state; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal set link state bssid %pM self_mac_addr %pM state %d\n" , + msg_body.bssid, msg_body.self_mac_addr, msg_body.state); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static void wcn36xx_smd_convert_sta_to_v1 (struct wcn36xx *wcn, +const struct wcn36xx_hal_config_sta_params *orig, +struct wcn36xx_hal_config_sta_params_v1 *v1) +{ +/* convert orig to v1 format */ +memcpy (&v1->bssid, orig->bssid,ETH_ALEN ); +memcpy (&v1->mac, orig->mac,ETH_ALEN ); + v1->aid = orig->aid; + v1->type = orig->type; + v1->listen_interval = orig->listen_interval; + v1->ht_capable = orig->ht_capable; + + v1->max_ampdu_size = orig->max_ampdu_size; + v1->max_ampdu_density = orig->max_ampdu_density; + v1->sgi_40mhz = orig->sgi_40mhz; + v1->sgi_20Mhz = orig->sgi_20Mhz; + +memcpy (&v1->supported_rates, &orig->supported_rates, +sizeof (orig->supported_rates)); + v1->sta_index = orig->sta_index; +} + +static int wcn36xx_smd_config_sta_v1 (struct wcn36xx *wcn, +const struct wcn36xx_hal_config_sta_req_msg *orig) +{ +struct wcn36xx_hal_config_sta_req_msg_v1 msg_body; +struct wcn36xx_hal_config_sta_params_v1 *sta = &msg_body.sta_params; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_CONFIG_STA_REQ ); + +wcn36xx_smd_convert_sta_to_v1 (wcn, &orig->sta_params, + &msg_body.sta_params); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config sta v1 action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n" , + sta->action, sta->sta_index, sta->bssid_index, + sta->bssid, sta->type, sta->mac, sta->aid); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_config_sta (struct wcn36xx *wcn,struct ieee80211_vif *vif, +struct ieee80211_sta *sta) +{ +struct wcn36xx_hal_config_sta_req_msg msg; +struct wcn36xx_hal_config_sta_params *sta_params; + +INIT_HAL_MSG (msg,WCN36XX_HAL_CONFIG_STA_REQ ); + + sta_params = &msg.sta_params; + +wcn36xx_smd_set_sta_params (wcn, vif, sta, sta_params); + +if (!wcn36xx_is_fw_version (wcn,1 ,2 ,2 ,24 )) +return wcn36xx_smd_config_sta_v1 (wcn, &msg); + +PREPARE_HAL_BUF (wcn->smd_buf, msg); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config sta action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n" , + sta_params->action, sta_params->sta_index, + sta_params->bssid_index, sta_params->bssid, + sta_params->type, sta_params->mac, sta_params->aid); + +return wcn36xx_smd_send_and_wait (wcn, msg.header.len); +} + +static int wcn36xx_smd_config_sta_rsp (struct wcn36xx *wcn,void *buf, +size_t len) +{ +struct wcn36xx_hal_config_sta_rsp_msg *rsp; +struct config_sta_rsp_params *params; + +if (len <sizeof (*rsp)) +return -EINVAL ; + + rsp = (struct wcn36xx_hal_config_sta_rsp_msg *)buf; + params = &rsp->params; + +if (params->status !=WCN36XX_FW_MSG_RESULT_SUCCESS ) { +wcn36xx_warn ("hal config sta response failure: %d\n" , + params->status); +return -EIO ; + } + +if (wcn->sta) { + wcn->sta->sta_index = params->sta_index; + wcn->sta->dpu_desc_index = params->dpu_index; + wcn->sta =NULL ; + } + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config sta rsp status %d sta_index %d bssid_index %d p2p %d\n" , + params->status, params->sta_index, params->bssid_index, + params->p2p); + +return 0 ; +} + +static int wcn36xx_smd_join_rsp (void *buf,size_t len) +{ +struct wcn36xx_hal_join_rsp_msg *rsp; + +if (wcn36xx_smd_rsp_status_check (buf, len)) +return -EIO ; + + rsp = (struct wcn36xx_hal_join_rsp_msg *)buf; + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal rsp join status %d tx_mgmt_power %d\n" , + rsp->status, rsp->tx_mgmt_power); + +return 0 ; +} + +static int wcn36xx_smd_config_bss_v1 (struct wcn36xx *wcn, +const struct wcn36xx_hal_config_bss_req_msg *orig) +{ +struct wcn36xx_hal_config_bss_req_msg_v1 msg_body; +struct wcn36xx_hal_config_bss_params_v1 *bss = &msg_body.bss_params; +struct wcn36xx_hal_config_sta_params_v1 *sta = &bss->sta; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_CONFIG_BSS_REQ ); + +/* convert orig to v1 */ +memcpy (&msg_body.bss_params.bssid, + &orig->bss_params.bssid,ETH_ALEN ); +memcpy (&msg_body.bss_params.self_mac_addr, + &orig->bss_params.self_mac_addr,ETH_ALEN ); + + msg_body.bss_params.bss_type = orig->bss_params.bss_type; + msg_body.bss_params.oper_mode = orig->bss_params.oper_mode; + msg_body.bss_params.nw_type = orig->bss_params.nw_type; + + msg_body.bss_params.short_slot_time_supported = + orig->bss_params.short_slot_time_supported; + msg_body.bss_params.lla_coexist = orig->bss_params.lla_coexist; + msg_body.bss_params.llb_coexist = orig->bss_params.llb_coexist; + msg_body.bss_params.llg_coexist = orig->bss_params.llg_coexist; + msg_body.bss_params.ht20_coexist = orig->bss_params.ht20_coexist; + msg_body.bss_params.lln_non_gf_coexist = + orig->bss_params.lln_non_gf_coexist; + + msg_body.bss_params.lsig_tx_op_protection_full_support = + orig->bss_params.lsig_tx_op_protection_full_support; + msg_body.bss_params.rifs_mode = orig->bss_params.rifs_mode; + msg_body.bss_params.beacon_interval = orig->bss_params.beacon_interval; + msg_body.bss_params.dtim_period = orig->bss_params.dtim_period; + msg_body.bss_params.tx_channel_width_set = + orig->bss_params.tx_channel_width_set; + msg_body.bss_params.oper_channel = orig->bss_params.oper_channel; + msg_body.bss_params.ext_channel = orig->bss_params.ext_channel; + + msg_body.bss_params.reserved = orig->bss_params.reserved; + +memcpy (&msg_body.bss_params.ssid, + &orig->bss_params.ssid, +sizeof (orig->bss_params.ssid)); + + msg_body.bss_params.action = orig->bss_params.action; + msg_body.bss_params.rateset = orig->bss_params.rateset; + msg_body.bss_params.ht = orig->bss_params.ht; + msg_body.bss_params.obss_prot_enabled = + orig->bss_params.obss_prot_enabled; + msg_body.bss_params.rmf = orig->bss_params.rmf; + msg_body.bss_params.ht_oper_mode = orig->bss_params.ht_oper_mode; + msg_body.bss_params.dual_cts_protection = + orig->bss_params.dual_cts_protection; + + msg_body.bss_params.max_probe_resp_retry_limit = + orig->bss_params.max_probe_resp_retry_limit; + msg_body.bss_params.hidden_ssid = orig->bss_params.hidden_ssid; + msg_body.bss_params.proxy_probe_resp = + orig->bss_params.proxy_probe_resp; + msg_body.bss_params.edca_params_valid = + orig->bss_params.edca_params_valid; + +memcpy (&msg_body.bss_params.acbe, + &orig->bss_params.acbe, +sizeof (orig->bss_params.acbe)); +memcpy (&msg_body.bss_params.acbk, + &orig->bss_params.acbk, +sizeof (orig->bss_params.acbk)); +memcpy (&msg_body.bss_params.acvi, + &orig->bss_params.acvi, +sizeof (orig->bss_params.acvi)); +memcpy (&msg_body.bss_params.acvo, + &orig->bss_params.acvo, +sizeof (orig->bss_params.acvo)); + + msg_body.bss_params.ext_set_sta_key_param_valid = + orig->bss_params.ext_set_sta_key_param_valid; + +memcpy (&msg_body.bss_params.ext_set_sta_key_param, + &orig->bss_params.ext_set_sta_key_param, +sizeof (orig->bss_params.acvo)); + + msg_body.bss_params.wcn36xx_hal_persona = + orig->bss_params.wcn36xx_hal_persona; + msg_body.bss_params.spectrum_mgt_enable = + orig->bss_params.spectrum_mgt_enable; + msg_body.bss_params.tx_mgmt_power = orig->bss_params.tx_mgmt_power; + msg_body.bss_params.max_tx_power = orig->bss_params.max_tx_power; + +wcn36xx_smd_convert_sta_to_v1 (wcn, &orig->bss_params.sta, + &msg_body.bss_params.sta); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config bss v1 bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n" , + bss->bssid, bss->self_mac_addr, bss->bss_type, + bss->oper_mode, bss->nw_type); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n" , + sta->bssid, sta->action, sta->sta_index, + sta->bssid_index, sta->aid, sta->type, sta->mac); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_config_bss (struct wcn36xx *wcn,struct ieee80211_vif *vif, +struct ieee80211_sta *sta,const u8 *bssid, +bool update) +{ +struct wcn36xx_hal_config_bss_req_msg msg; +struct wcn36xx_hal_config_bss_params *bss; +struct wcn36xx_hal_config_sta_params *sta_params; + +INIT_HAL_MSG (msg,WCN36XX_HAL_CONFIG_BSS_REQ ); + + bss = &msg.bss_params; + sta_params = &bss->sta; + +WARN_ON (is_zero_ether_addr (bssid)); + +memcpy (&bss->bssid, bssid,ETH_ALEN ); + +memcpy (&bss->self_mac_addr, &wcn->addresses,ETH_ALEN ); + +if (vif->type ==NL80211_IFTYPE_STATION ) { + bss->bss_type =WCN36XX_HAL_INFRASTRUCTURE_MODE ; + +/* STA */ + bss->oper_mode =1 ; + bss->wcn36xx_hal_persona =WCN36XX_HAL_STA_MODE ; + }else if (vif->type ==NL80211_IFTYPE_AP ) { + bss->bss_type =WCN36XX_HAL_INFRA_AP_MODE ; + +/* AP */ + bss->oper_mode =0 ; + bss->wcn36xx_hal_persona =WCN36XX_HAL_STA_SAP_MODE ; + }else if (vif->type ==NL80211_IFTYPE_ADHOC || + vif->type ==NL80211_IFTYPE_MESH_POINT ) { + bss->bss_type =WCN36XX_HAL_IBSS_MODE ; + +/* STA */ + bss->oper_mode =1 ; + }else { +wcn36xx_warn ("Unknown type for bss config: %d\n" , vif->type); + } + +if (vif->type ==NL80211_IFTYPE_STATION ) +wcn36xx_smd_set_bss_nw_type (wcn, sta, bss); +else + bss->nw_type =WCN36XX_HAL_11N_NW_TYPE ; + + bss->short_slot_time_supported = vif->bss_conf.use_short_slot; + bss->lla_coexist =0 ; + bss->llb_coexist =0 ; + bss->llg_coexist =0 ; + bss->rifs_mode =0 ; + bss->beacon_interval = vif->bss_conf.beacon_int; + bss->dtim_period = wcn->dtim_period; + +wcn36xx_smd_set_bss_ht_params (vif, sta, bss); + + bss->oper_channel =WCN36XX_HW_CHANNEL (wcn); + +if (conf_is_ht40_minus (&wcn->hw->conf)) + bss->ext_channel =IEEE80211_HT_PARAM_CHA_SEC_BELOW ; +else if (conf_is_ht40_plus (&wcn->hw->conf)) + bss->ext_channel =IEEE80211_HT_PARAM_CHA_SEC_ABOVE ; +else + bss->ext_channel =IEEE80211_HT_PARAM_CHA_SEC_NONE ; + + bss->reserved =0 ; +wcn36xx_smd_set_sta_params (wcn, vif, sta, sta_params); + +/* wcn->ssid is only valid in AP and IBSS mode */ + bss->ssid.length = wcn->ssid.length; +memcpy (bss->ssid.ssid, wcn->ssid.ssid, wcn->ssid.length); + + bss->obss_prot_enabled =0 ; + bss->rmf =0 ; + bss->max_probe_resp_retry_limit =0 ; + bss->hidden_ssid = vif->bss_conf.hidden_ssid; + bss->proxy_probe_resp =0 ; + bss->edca_params_valid =0 ; + +/* FIXME: set acbe, acbk, acvi and acvo */ + + bss->ext_set_sta_key_param_valid =0 ; + +/* FIXME: set ext_set_sta_key_param */ + + bss->spectrum_mgt_enable =0 ; + bss->tx_mgmt_power =0 ; + bss->max_tx_power =WCN36XX_MAX_POWER (wcn); + + bss->action = update; + +if (!wcn36xx_is_fw_version (wcn,1 ,2 ,2 ,24 )) +return wcn36xx_smd_config_bss_v1 (wcn, &msg); + +PREPARE_HAL_BUF (wcn->smd_buf, msg); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config bss bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n" , + bss->bssid, bss->self_mac_addr, bss->bss_type, + bss->oper_mode, bss->nw_type); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n" , + sta_params->bssid, sta_params->action, + sta_params->sta_index, sta_params->bssid_index, + sta_params->aid, sta_params->type, + sta_params->mac); + +return wcn36xx_smd_send_and_wait (wcn, msg.header.len); +} + +static int wcn36xx_smd_config_bss_rsp (struct wcn36xx *wcn, +void *buf, +size_t len) +{ +struct wcn36xx_hal_config_bss_rsp_msg *rsp; +struct wcn36xx_hal_config_bss_rsp_params *params; + +if (len <sizeof (*rsp)) +return -EINVAL ; + + rsp = (struct wcn36xx_hal_config_bss_rsp_msg *)buf; + params = &rsp->bss_rsp_params; + +if (params->status !=WCN36XX_FW_MSG_RESULT_SUCCESS ) { +wcn36xx_warn ("hal config bss response failure: %d\n" , + params->status); +return -EIO ; + } + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal config bss rsp status %d bss_idx %d dpu_desc_index %d" +" sta_idx %d self_idx %d bcast_idx %d mac %pM" +" power %d ucast_dpu_signature %d\n" , + params->status, params->bss_index, params->dpu_desc_index, + params->bss_sta_index, params->bss_self_sta_index, + params->bss_bcast_sta_idx, params->mac, + params->tx_mgmt_power, params->ucast_dpu_signature); + + wcn->current_vif->bss_index = params->bss_index; + +if (wcn->sta) { + wcn->sta->bss_sta_index = params->bss_sta_index; + wcn->sta->bss_dpu_desc_index = params->dpu_desc_index; + } + + wcn->current_vif->ucast_dpu_signature = params->ucast_dpu_signature; + +return 0 ; +} + +int wcn36xx_smd_delete_bss (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_delete_bss_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DELETE_BSS_REQ ); + + msg_body.bss_index = wcn->current_vif->bss_index; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL ,"hal delete bss %d\n" , msg_body.bss_index); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_send_beacon (struct wcn36xx *wcn,struct sk_buff *skb_beacon, +u16 tim_off,u16 p2p_off) +{ +struct wcn36xx_hal_send_beacon_req_msg msg_body; +INIT_HAL_MSG (msg_body,WCN36XX_HAL_SEND_BEACON_REQ ); + +/* TODO need to find out why this is needed? */ + msg_body.beacon_length = skb_beacon->len +6 ; + +if (BEACON_TEMPLATE_SIZE > msg_body.beacon_length) { +memcpy (&msg_body.beacon, &skb_beacon->len,sizeof (u32)); +memcpy (&(msg_body.beacon[4 ]), skb_beacon->data, + skb_beacon->len); + }else { +wcn36xx_err ("Beacon is to big: beacon size=%d\n" , + msg_body.beacon_length); +return -ENOMEM ; + } +memcpy (&msg_body.bssid, &wcn->addresses,ETH_ALEN ); + +/* TODO need to find out why this is needed? */ + msg_body.tim_ie_offset = tim_off+4 ; + msg_body.p2p_ie_offset = p2p_off; +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal send beacon beacon_length %d\n" , + msg_body.beacon_length); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_update_proberesp_tmpl (struct wcn36xx *wcn,struct sk_buff *skb) +{ +struct wcn36xx_hal_send_probe_resp_req_msg msg; + +INIT_HAL_MSG (msg,WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ ); + +if (skb->len >BEACON_TEMPLATE_SIZE ) { +wcn36xx_warn ("probe response template is too big: %d\n" , + skb->len); +return -E2BIG ; + } + + msg.probe_resp_template_len = skb->len; +memcpy (&msg.probe_resp_template, skb->data, skb->len); + +memcpy (&msg.bssid, &wcn->addresses,ETH_ALEN ); + +PREPARE_HAL_BUF (wcn->smd_buf, msg); + +wcn36xx_dbg (WCN36XX_DBG_HAL , +"hal update probe rsp len %d bssid %pM\n" , + msg.probe_resp_template_len, msg.bssid); + +return wcn36xx_smd_send_and_wait (wcn, msg.header.len); +} + +int wcn36xx_smd_set_stakey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 keylen, +u8 *key, +u8 sta_index) +{ +struct wcn36xx_hal_set_sta_key_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_SET_STAKEY_REQ ); + + msg_body.set_sta_key_params.sta_index = sta_index; + msg_body.set_sta_key_params.enc_type = enc_type; + + msg_body.set_sta_key_params.key[0 ].id = keyidx; + msg_body.set_sta_key_params.key[0 ].unicast =1 ; + msg_body.set_sta_key_params.key[0 ].direction =WCN36XX_HAL_TX_RX ; + msg_body.set_sta_key_params.key[0 ].pae_role =0 ; + msg_body.set_sta_key_params.key[0 ].length = keylen; +memcpy (msg_body.set_sta_key_params.key[0 ].key, key, keylen); + msg_body.set_sta_key_params.single_tid_rc =1 ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_set_bsskey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 keylen, +u8 *key) +{ +struct wcn36xx_hal_set_bss_key_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_SET_BSSKEY_REQ ); + msg_body.bss_idx =0 ; + msg_body.enc_type = enc_type; + msg_body.num_keys =1 ; + msg_body.keys[0 ].id = keyidx; + msg_body.keys[0 ].unicast =0 ; + msg_body.keys[0 ].direction =WCN36XX_HAL_RX_ONLY ; + msg_body.keys[0 ].pae_role =0 ; + msg_body.keys[0 ].length = keylen; +memcpy (msg_body.keys[0 ].key, key, keylen); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_remove_stakey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 sta_index) +{ +struct wcn36xx_hal_remove_sta_key_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_RMV_STAKEY_REQ ); + + msg_body.sta_idx = sta_index; + msg_body.enc_type = enc_type; + msg_body.key_id = keyidx; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_remove_bsskey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx) +{ +struct wcn36xx_hal_remove_bss_key_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_RMV_BSSKEY_REQ ); + msg_body.bss_idx =0 ; + msg_body.enc_type = enc_type; + msg_body.key_id = keyidx; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_enter_bmps (struct wcn36xx *wcn,u64 tbtt) +{ +struct wcn36xx_hal_enter_bmps_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_ENTER_BMPS_REQ ); + + msg_body.bss_index = wcn->current_vif->bss_index; + msg_body.tbtt = tbtt; + msg_body.dtim_period = wcn->dtim_period; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_exit_bmps (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_enter_bmps_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_EXIT_BMPS_REQ ); + + msg_body.bss_index = wcn->current_vif->bss_index; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +/* Notice: This function should be called after associated, or else it +* will be invalid +*/ +int wcn36xx_smd_keep_alive_req (struct wcn36xx *wcn,int packet_type) +{ +struct wcn36xx_hal_keep_alive_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_KEEP_ALIVE_REQ ); + +if (packet_type ==WCN36XX_HAL_KEEP_ALIVE_NULL_PKT ) { + msg_body.bss_index = wcn->current_vif->bss_index; + msg_body.packet_type =WCN36XX_HAL_KEEP_ALIVE_NULL_PKT ; + msg_body.time_period =WCN36XX_KEEP_ALIVE_TIME_PERIOD ; + }else if (packet_type ==WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP ) { +/* TODO: it also support ARP response type */ + }else { +wcn36xx_warn ("unknow keep alive packet type %d\n" , packet_type); +return -EINVAL ; + } + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_dump_cmd_req (struct wcn36xx *wcn,u32 arg1,u32 arg2, +u32 arg3,u32 arg4,u32 arg5) +{ +struct wcn36xx_hal_dump_cmd_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DUMP_COMMAND_REQ ); + + msg_body.arg1 = arg1; + msg_body.arg2 = arg2; + msg_body.arg3 = arg3; + msg_body.arg4 = arg4; + msg_body.arg5 = arg5; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static inline void set_feat_caps (u32 *bitmap, +enum place_holder_in_cap_bitmap cap) +{ +int arr_idx, bit_idx; + +if (cap <0 || cap >127 ) { +wcn36xx_warn ("error cap idx %d\n" , cap); +return ; + } + + arr_idx = cap /32 ; + bit_idx = cap %32 ; + bitmap[arr_idx] |= (1 << bit_idx); +} + +static inline int get_feat_caps (u32 *bitmap, +enum place_holder_in_cap_bitmap cap) +{ +int arr_idx, bit_idx; +int ret =0 ; + +if (cap <0 || cap >127 ) { +wcn36xx_warn ("error cap idx %d\n" , cap); +return -EINVAL ; + } + + arr_idx = cap /32 ; + bit_idx = cap %32 ; + ret = (bitmap[arr_idx] & (1 << bit_idx)) ?1 :0 ; +return ret; +} + +static inline void clear_feat_caps (u32 *bitmap, +enum place_holder_in_cap_bitmap cap) +{ +int arr_idx, bit_idx; + +if (cap <0 || cap >127 ) { +wcn36xx_warn ("error cap idx %d\n" , cap); +return ; + } + + arr_idx = cap /32 ; + bit_idx = cap %32 ; + bitmap[arr_idx] &= ~(1 << bit_idx); +} + +int wcn36xx_smd_feature_caps_exchange (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_feat_caps_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ ); + +set_feat_caps (msg_body.feat_caps,STA_POWERSAVE ); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +/* FW sends its capability bitmap as a response */ +int wcn36xx_smd_feature_caps_exchange_rsp (void *buf,size_t len) +{ +/* TODO: print the caps of rsp for comapre */ +if (wcn36xx_smd_rsp_status_check (buf, len)) { +wcn36xx_warn ("error response for caps exchange\n" ); +return -EIO ; + } + +return 0 ; +} + +int wcn36xx_smd_add_ba_session (struct wcn36xx *wcn, +struct ieee80211_sta *sta, +u16 tid, +u16 *ssn, +u8 direction, +u8 sta_index) +{ +struct wcn36xx_hal_add_ba_session_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_ADD_BA_SESSION_REQ ); + + msg_body.sta_index = sta_index; +memcpy (&msg_body.mac_addr, sta->addr,ETH_ALEN ); + msg_body.dialog_token =0x10 ; + msg_body.tid = tid; + +/* Immediate BA because Delayed BA is not supported */ + msg_body.policy =1 ; + msg_body.buffer_size =WCN36XX_AGGR_BUFFER_SIZE ; + msg_body.timeout =0 ; +if (ssn) + msg_body.ssn = *ssn; + msg_body.direction = direction; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_add_ba (struct wcn36xx *wcn) +{ +struct wcn36xx_hal_add_ba_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_ADD_BA_REQ ); + + msg_body.session_id =0 ; + msg_body.win_size =WCN36XX_AGGR_BUFFER_SIZE ; + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_del_ba (struct wcn36xx *wcn,u16 tid,u8 sta_index) +{ +struct wcn36xx_hal_del_ba_req_msg msg_body; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_DEL_BA_REQ ); + + msg_body.sta_index = sta_index; + msg_body.tid = tid; + msg_body.direction =0 ; +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +int wcn36xx_smd_trigger_ba (struct wcn36xx *wcn,u8 sta_index) +{ +struct wcn36xx_hal_trigger_ba_req_msg msg_body; +struct wcn36xx_hal_trigget_ba_req_candidate *candidate; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_TRIGGER_BA_REQ ); + + msg_body.session_id =0 ; + msg_body.candidate_cnt =1 ; + msg_body.header.len +=sizeof (*candidate); +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + + candidate = (struct wcn36xx_hal_trigget_ba_req_candidate *) + (wcn->smd_buf +sizeof (msg_body)); + candidate->sta_index = sta_index; + candidate->tid_bitmap =1 ; + +return wcn36xx_smd_send_and_wait (wcn, msg_body.header.len); +} + +static int wcn36xx_smd_tx_compl_ind (struct wcn36xx *wcn,void *buf,size_t len) +{ +struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf; + +if (len !=sizeof (*rsp)) { +wcn36xx_warn ("Bad TX complete indication\n" ); +return -EIO ; + } + +wcn36xx_dxe_tx_ack_ind (wcn, rsp->status); + +return 0 ; +} + +static int wcn36xx_smd_missed_beacon_ind (struct wcn36xx *wcn, +void *buf, +size_t len) +{ +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); + +mutex_lock (&wcn->pm_mutex); + +/* +* In suspended state mac80211 is still sleeping and that means we +* cannot notify it about connection lost. Wait until resume and +* then notify mac80211 about it. +*/ +if (wcn->is_suspended) { +wcn36xx_dbg (WCN36XX_DBG_HAL , +"postpone connection lost notification\n" ); + wcn->is_con_lost_pending = true; + }else { +wcn36xx_dbg (WCN36XX_DBG_HAL ,"beacon missed\n" ); +ieee80211_connection_loss (vif); + } + +mutex_unlock (&wcn->pm_mutex); + +return 0 ; +} + +static int wcn36xx_smd_delete_sta_context_ind (struct wcn36xx *wcn, +void *buf, +size_t len) +{ +struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf; +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); +struct ieee80211_sta *sta; + +if (len !=sizeof (*rsp)) { +wcn36xx_warn ("Bad delete sta indication\n" ); +return -EIO ; + } + + +rcu_read_lock (); + + sta =ieee80211_find_sta (vif, rsp->addr2); +if (sta) { +wcn36xx_dbg (WCN36XX_DBG_HAL , +"delete station indication %pM\n" , rsp->addr2); +ieee80211_report_low_ack (sta,0 ); + } + +rcu_read_unlock (); + +return 0 ; +} + +int wcn36xx_smd_update_cfg (struct wcn36xx *wcn,u32 cfg_id,u32 value) +{ +struct wcn36xx_hal_update_cfg_req_msg msg_body, *body; +size_t len; + +INIT_HAL_MSG (msg_body,WCN36XX_HAL_UPDATE_CFG_REQ ); + +PREPARE_HAL_BUF (wcn->smd_buf, msg_body); + + body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->smd_buf; + len = msg_body.header.len; + +put_cfg_tlv_u32 (wcn, &len, cfg_id, value); + body->header.len = len; + body->len = len -sizeof (*body); + +return wcn36xx_smd_send_and_wait (wcn, len); +} +static void wcn36xx_smd_rsp_process (struct wcn36xx *wcn,void *buf,size_t len) +{ +struct wcn36xx_hal_msg_header *msg_header = buf; + +wcn36xx_dbg_dump (WCN36XX_DBG_SMD_DUMP ,"SMD <<< " , buf, len); + +switch (msg_header->msg_type) { +case WCN36XX_HAL_START_RSP : +wcn36xx_smd_start_rsp (wcn, buf, len); +break ; +case WCN36XX_HAL_CONFIG_STA_RSP : +wcn36xx_smd_config_sta_rsp (wcn, buf, len); +break ; +case WCN36XX_HAL_CONFIG_BSS_RSP : +wcn36xx_smd_config_bss_rsp (wcn, buf, len); +break ; +case WCN36XX_HAL_ADD_STA_SELF_RSP : +wcn36xx_smd_add_sta_self_rsp (wcn, buf, len); +break ; +case WCN36XX_HAL_STOP_RSP : +case WCN36XX_HAL_DEL_STA_SELF_RSP : +case WCN36XX_HAL_DELETE_STA_RSP : +case WCN36XX_HAL_INIT_SCAN_RSP : +case WCN36XX_HAL_START_SCAN_RSP : +case WCN36XX_HAL_END_SCAN_RSP : +case WCN36XX_HAL_FINISH_SCAN_RSP : +case WCN36XX_HAL_DOWNLOAD_NV_RSP : +case WCN36XX_HAL_DELETE_BSS_RSP : +case WCN36XX_HAL_SEND_BEACON_RSP : +case WCN36XX_HAL_SET_LINK_ST_RSP : +case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP : +case WCN36XX_HAL_SET_BSSKEY_RSP : +case WCN36XX_HAL_SET_STAKEY_RSP : +case WCN36XX_HAL_RMV_STAKEY_RSP : +case WCN36XX_HAL_RMV_BSSKEY_RSP : +case WCN36XX_HAL_ENTER_BMPS_RSP : +case WCN36XX_HAL_EXIT_BMPS_RSP : +case WCN36XX_HAL_KEEP_ALIVE_RSP : +case WCN36XX_HAL_DUMP_COMMAND_RSP : +case WCN36XX_HAL_ADD_BA_SESSION_RSP : +case WCN36XX_HAL_ADD_BA_RSP : +case WCN36XX_HAL_DEL_BA_RSP : +case WCN36XX_HAL_TRIGGER_BA_RSP : +case WCN36XX_HAL_UPDATE_CFG_RSP : +if (wcn36xx_smd_rsp_status_check (buf, len)) { +wcn36xx_warn ("error response from hal request %d\n" , + msg_header->msg_type); + } +break ; +case WCN36XX_HAL_JOIN_RSP : +wcn36xx_smd_join_rsp (buf, len); +break ; +case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP : +wcn36xx_smd_update_scan_params_rsp (buf, len); +break ; +case WCN36XX_HAL_CH_SWITCH_RSP : +wcn36xx_smd_switch_channel_rsp (buf, len); +break ; +case WCN36XX_HAL_OTA_TX_COMPL_IND : +wcn36xx_smd_tx_compl_ind (wcn, buf, len); +break ; +case WCN36XX_HAL_MISSED_BEACON_IND : +wcn36xx_smd_missed_beacon_ind (wcn, buf, len); +break ; +case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP : +wcn36xx_smd_feature_caps_exchange_rsp (buf, len); +break ; +case WCN36XX_HAL_DELETE_STA_CONTEXT_IND : +wcn36xx_smd_delete_sta_context_ind (wcn, buf, len); +break ; +default : +wcn36xx_err ("SMD_EVENT (%d) not supported\n" , + msg_header->msg_type); + } +} + +int wcn36xx_smd_open (struct wcn36xx *wcn) +{ +return wcn->ctrl_ops->open (wcn, wcn36xx_smd_rsp_process); +} + +void wcn36xx_smd_close (struct wcn36xx *wcn) +{ + wcn->ctrl_ops->close (); +}
Signature · 1 line
1.8.2.2
PATCH v2 10/16 wcn36xx: add smd.h
In reply to Eugene KrasnikovAdding smd.h
--- drivers/net/wireless/ath/wcn36xx/smd.h | 121 +++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/smd.h
drivers/net/wireless/ath/wcn36xx/smd.h new file +121 -0
@@ -0,0 +1,121 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _SMD_H_ +#define _SMD_H_ + +#include "wcn36xx.h" + +/* Max shared size is 4k but we take less.*/ +#define WCN36XX_NV_FRAGMENT_SIZE 3072 + +#define WCN36XX_SMD_BUF_SIZE 4096 + +#define SMD_MSG_TIMEOUT 200 +#define WCN36XX_SMSM_WLAN_TX_ENABLE 0x00000400 +#define WCN36XX_SMSM_WLAN_TX_RINGS_EMPTY 0x00000200 +/* The PNO version info be contained in the rsp msg */ +#define WCN36XX_FW_MSG_PNO_VERSION_MASK 0x8000 + +enum wcn36xx_fw_msg_result { +WCN36XX_FW_MSG_RESULT_SUCCESS =0 , +WCN36XX_FW_MSG_RESULT_SUCCESS_SYNC =1 , + +WCN36XX_FW_MSG_RESULT_MEM_FAIL =5 , +}; + +/******************************/ +/* SMD requests and responses */ +/******************************/ +struct wcn36xx_fw_msg_status_rsp { +u32 status; +} __packed; + +struct wcn36xx ; + +int wcn36xx_smd_open (struct wcn36xx *wcn); +void wcn36xx_smd_close (struct wcn36xx *wcn); + +int wcn36xx_smd_load_nv (struct wcn36xx *wcn); +int wcn36xx_smd_start (struct wcn36xx *wcn); +int wcn36xx_smd_stop (struct wcn36xx *wcn); +int wcn36xx_smd_init_scan (struct wcn36xx *wcn); +int wcn36xx_smd_start_scan (struct wcn36xx *wcn); +int wcn36xx_smd_end_scan (struct wcn36xx *wcn); +int wcn36xx_smd_finish_scan (struct wcn36xx *wcn); +int wcn36xx_smd_update_scan_params (struct wcn36xx *wcn); +int wcn36xx_smd_add_sta_self (struct wcn36xx *wcn,u8 *addr,u32 status); +int wcn36xx_smd_delete_sta_self (struct wcn36xx *wcn,u8 *addr); +int wcn36xx_smd_delete_sta (struct wcn36xx *wcn,u8 sta_index); +int wcn36xx_smd_join (struct wcn36xx *wcn,const u8 *bssid,u8 *vif,u8 ch); +int wcn36xx_smd_set_link_st (struct wcn36xx *wcn,const u8 *bssid, +const u8 *sta_mac, +enum wcn36xx_hal_link_state state); +int wcn36xx_smd_config_bss (struct wcn36xx *wcn,struct ieee80211_vif *vif, +struct ieee80211_sta *sta,const u8 *bssid, +bool update); +int wcn36xx_smd_delete_bss (struct wcn36xx *wcn); +int wcn36xx_smd_config_sta (struct wcn36xx *wcn,struct ieee80211_vif *vif, +struct ieee80211_sta *sta); +int wcn36xx_smd_send_beacon (struct wcn36xx *wcn,struct sk_buff *skb_beacon, +u16 tim_off,u16 p2p_off); +int wcn36xx_smd_switch_channel (struct wcn36xx *wcn,int ch); +int wcn36xx_smd_update_proberesp_tmpl (struct wcn36xx *wcn,struct sk_buff *skb); +int wcn36xx_smd_set_stakey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 keylen, +u8 *key, +u8 sta_index); +int wcn36xx_smd_set_bsskey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 keylen, +u8 *key); +int wcn36xx_smd_remove_stakey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx, +u8 sta_index); +int wcn36xx_smd_remove_bsskey (struct wcn36xx *wcn, +enum ani_ed_type enc_type, +u8 keyidx); +int wcn36xx_smd_enter_bmps (struct wcn36xx *wcn,u64 tbtt); +int wcn36xx_smd_exit_bmps (struct wcn36xx *wcn); +int wcn36xx_smd_keep_alive_req (struct wcn36xx *wcn,int packet_type); +int wcn36xx_smd_dump_cmd_req (struct wcn36xx *wcn,u32 arg1,u32 arg2, +u32 arg3,u32 arg4,u32 arg5); +int wcn36xx_smd_feature_caps_exchange (struct wcn36xx *wcn); + +int wcn36xx_smd_add_ba_session (struct wcn36xx *wcn, +struct ieee80211_sta *sta, +u16 tid, +u16 *ssn, +u8 direction, +u8 sta_index); +int wcn36xx_smd_add_ba (struct wcn36xx *wcn); +int wcn36xx_smd_del_ba (struct wcn36xx *wcn,u16 tid,u8 sta_index); +int wcn36xx_smd_trigger_ba (struct wcn36xx *wcn,u8 sta_index); + +int wcn36xx_smd_update_cfg (struct wcn36xx *wcn,u32 cfg_id,u32 value); +/* WCN36XX configuration parameters */ +struct wcn36xx_fw_cfg { +u16 id; +u16 len; +u16 pad_bytes; +u16 reserved; +u8 *val; +}; +#endif /* _SMD_H_ */
Signature · 1 line
1.8.2.2
PATCH v2 11/16 wcn36xx: add txrx.c
In reply to Eugene KrasnikovAdding txrx.c
--- drivers/net/wireless/ath/wcn36xx/txrx.c | 256 ++++++++++++++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.c
drivers/net/wireless/ath/wcn36xx/txrx.c new file +256 -0
@@ -0,0 +1,256 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define pr_fmt (fmt) KBUILD_MODNAME ": " fmt + +#include "txrx.h" + +static inline int get_rssi0 (struct wcn36xx_rx_bd *bd) +{ +return 100 - ((bd->phy_stat0 >>24 ) &0xff ); +} + +int wcn36xx_rx_skb (struct wcn36xx *wcn,struct sk_buff *skb) +{ +struct ieee80211_rx_status status; +struct ieee80211_hdr *hdr; +struct wcn36xx_rx_bd *bd; +u16 fc, sn; + +/* +* All fields must be 0, otherwise it can lead to +* unexpected consequences. +*/ +memset (&status,0 ,sizeof (status)); + + bd = (struct wcn36xx_rx_bd *)skb->data; +buff_to_be ((u32 *)bd,sizeof (*bd)/sizeof (u32)); +wcn36xx_dbg_dump (WCN36XX_DBG_RX_DUMP , +"BD <<< " , (char *)bd, +sizeof (struct wcn36xx_rx_bd )); + +skb_put (skb, bd->pdu.mpdu_header_off + bd->pdu.mpdu_len); +skb_pull (skb, bd->pdu.mpdu_header_off); + + status.mactime =10 ; + status.freq =WCN36XX_CENTER_FREQ (wcn); + status.band =WCN36XX_BAND (wcn); + status.signal = -get_rssi0 (bd); + status.antenna =1 ; + status.rate_idx =1 ; + status.flag =0 ; + status.rx_flags =0 ; + status.flag |=RX_FLAG_IV_STRIPPED | +RX_FLAG_MMIC_STRIPPED | +RX_FLAG_DECRYPTED ; + +wcn36xx_dbg (WCN36XX_DBG_RX ,"status.flags=%x status->vendor_radiotap_len=%x\n" , + status.flag, status.vendor_radiotap_len); + +memcpy (IEEE80211_SKB_RXCB (skb), &status,sizeof (status)); + + hdr = (struct ieee80211_hdr *) skb->data; + fc =__le16_to_cpu (hdr->frame_control); + sn =IEEE80211_SEQ_TO_SN (__le16_to_cpu (hdr->seq_ctrl)); + +if (ieee80211_is_beacon (hdr->frame_control)) { +wcn36xx_dbg (WCN36XX_DBG_BEACON ,"beacon skb %p len %d fc %04x sn %d\n" , + skb, skb->len, fc, sn); +wcn36xx_dbg_dump (WCN36XX_DBG_BEACON_DUMP ,"SKB <<< " , + (char *)skb->data, skb->len); + }else { +wcn36xx_dbg (WCN36XX_DBG_RX ,"rx skb %p len %d fc %04x sn %d\n" , + skb, skb->len, fc, sn); +wcn36xx_dbg_dump (WCN36XX_DBG_RX_DUMP ,"SKB <<< " , + (char *)skb->data, skb->len); + } + +ieee80211_rx_irqsafe (wcn->hw, skb); + +return 0 ; +} + +static void wcn36xx_set_tx_pdu (struct wcn36xx_tx_bd *bd, +u32 mpdu_header_len, +u32 len, +u16 tid) +{ + bd->pdu.mpdu_header_len = mpdu_header_len; + bd->pdu.mpdu_header_off =sizeof (*bd); + bd->pdu.mpdu_data_off = bd->pdu.mpdu_header_len + + bd->pdu.mpdu_header_off; + bd->pdu.mpdu_len = len; + bd->pdu.tid = tid; +} + +static void wcn36xx_set_tx_data (struct wcn36xx_tx_bd *bd, +struct wcn36xx *wcn, +struct wcn36xx_sta *sta_priv, +struct ieee80211_hdr *hdr, +bool bcast) +{ +struct ieee80211_vif *vif =container_of ((void *)wcn->current_vif, + struct ieee80211_vif, + drv_priv); + bd->bd_rate =WCN36XX_BD_RATE_DATA ; + bd->dpu_sign = wcn->current_vif->ucast_dpu_signature; + +/* +* For not unicast frames mac80211 will not set sta pointer so use +* self_sta_index instead. +*/ +if (sta_priv) { +if (vif->type ==NL80211_IFTYPE_STATION ) { + bd->sta_index = sta_priv->bss_sta_index; + bd->dpu_desc_idx = sta_priv->bss_dpu_desc_index; + }else if (vif->type ==NL80211_IFTYPE_AP || + vif->type ==NL80211_IFTYPE_ADHOC || + vif->type ==NL80211_IFTYPE_MESH_POINT ) { + bd->sta_index = sta_priv->sta_index; + bd->dpu_desc_idx = sta_priv->dpu_desc_index; + } + }else { + bd->sta_index = wcn->current_vif->self_sta_index; + bd->dpu_desc_idx = wcn->current_vif->self_dpu_desc_index; + } + +if (ieee80211_is_nullfunc (hdr->frame_control) || + (sta_priv && !sta_priv->is_data_encrypted)) + bd->dpu_ne =1 ; + +if (bcast) { + bd->ub =1 ; + bd->ack_policy =1 ; + } +} + +static void wcn36xx_set_tx_mgmt (struct wcn36xx_tx_bd *bd, +struct wcn36xx *wcn, +struct ieee80211_hdr *hdr, +bool bcast) +{ + bd->sta_index = wcn->current_vif->self_sta_index; + bd->dpu_desc_idx = wcn->current_vif->self_dpu_desc_index; + bd->dpu_ne =1 ; + +/* default rate for unicast */ +if (ieee80211_is_mgmt (hdr->frame_control)) + bd->bd_rate = (WCN36XX_BAND (wcn) ==IEEE80211_BAND_5GHZ ) ? +WCN36XX_BD_RATE_CTRL : +WCN36XX_BD_RATE_MGMT ; +else if (ieee80211_is_ctl (hdr->frame_control)) + bd->bd_rate =WCN36XX_BD_RATE_CTRL ; +else +wcn36xx_warn ("frame control type unknown\n" ); + +/* +* In joining state trick hardware that probe is sent as +* unicast even if address is broadcast. +*/ +if (wcn->is_joining && +ieee80211_is_probe_req (hdr->frame_control)) + bcast = false; + +if (bcast) { +/* broadcast */ + bd->ub =1 ; +/* No ack needed not unicast */ + bd->ack_policy =1 ; + bd->queue_id =WCN36XX_TX_B_WQ_ID ; + }else + bd->queue_id =WCN36XX_TX_U_WQ_ID ; +} + +int wcn36xx_start_tx (struct wcn36xx *wcn, +struct wcn36xx_sta *sta_priv, +struct sk_buff *skb) +{ +struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; +struct ieee80211_tx_info *info =IEEE80211_SKB_CB (skb); +unsigned long flags; +bool is_low =ieee80211_is_data (hdr->frame_control); +bool bcast =is_broadcast_ether_addr (hdr->addr1) || +is_multicast_ether_addr (hdr->addr1); +struct wcn36xx_tx_bd *bd =wcn36xx_dxe_get_next_bd (wcn, is_low); + +if (!bd) { +/* +* TX DXE are used in pairs. One for the BD and one for the +* actual frame. The BD DXE's has a preallocated buffer while +* the skb ones does not. If this isn't true something is really +* wierd. TODO: Recover from this situation +*/ + +wcn36xx_err ("bd address may not be NULL for BD DXE\n" ); +return -EINVAL ; + } + +memset (bd,0 ,sizeof (*bd)); + +wcn36xx_dbg (WCN36XX_DBG_TX , +"tx skb %p len %d fc %04x sn %d %s %s\n" , + skb, skb->len,__le16_to_cpu (hdr->frame_control), +IEEE80211_SEQ_TO_SN (__le16_to_cpu (hdr->seq_ctrl)), + is_low ?"low" :"high" , bcast ?"bcast" :"ucast" ); + +wcn36xx_dbg_dump (WCN36XX_DBG_TX_DUMP ,"" , skb->data, skb->len); + + bd->dpu_rf =WCN36XX_BMU_WQ_TX ; + + bd->tx_comp = info->flags &IEEE80211_TX_CTL_REQ_TX_STATUS ; +if (bd->tx_comp) { +wcn36xx_dbg (WCN36XX_DBG_DXE ,"TX_ACK status requested\n" ); +spin_lock_irqsave (&wcn->dxe_lock, flags); +if (wcn->tx_ack_skb) { +spin_unlock_irqrestore (&wcn->dxe_lock, flags); +wcn36xx_warn ("tx_ack_skb already set\n" ); +return -EINVAL ; + } + + wcn->tx_ack_skb = skb; +spin_unlock_irqrestore (&wcn->dxe_lock, flags); + +/* Only one at a time is supported by fw. Stop the TX queues +* until the ack status gets back. +* +* TODO: Add watchdog in case FW does not answer +*/ +ieee80211_stop_queues (wcn->hw); + } + +/* Data frames served first*/ +if (is_low) { +wcn36xx_set_tx_data (bd, wcn, sta_priv, hdr, bcast); +wcn36xx_set_tx_pdu (bd, +ieee80211_is_data_qos (hdr->frame_control) ? +sizeof (struct ieee80211_qos_hdr ) : +sizeof (struct ieee80211_hdr_3addr ), + skb->len, sta_priv ? sta_priv->tid :0 ); + }else { +/* MGMT and CTRL frames are handeld here*/ +wcn36xx_set_tx_mgmt (bd, wcn, hdr, bcast); +wcn36xx_set_tx_pdu (bd, +ieee80211_is_data_qos (hdr->frame_control) ? +sizeof (struct ieee80211_qos_hdr ) : +sizeof (struct ieee80211_hdr_3addr ), + skb->len,WCN36XX_TID ); + } + +buff_to_be ((u32 *)bd,sizeof (*bd)/sizeof (u32)); + bd->tx_bd_sign =0xbdbdbdbd ; + +return wcn36xx_dxe_tx_frame (wcn, skb, is_low); +}
Signature · 1 line
1.8.2.2
PATCH v2 12/16 wcn36xx: add txrx.h
In reply to Eugene KrasnikovAdding txrx.h
--- drivers/net/wireless/ath/wcn36xx/txrx.h | 160 ++++++++++++++++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/txrx.h
drivers/net/wireless/ath/wcn36xx/txrx.h new file +160 -0
@@ -0,0 +1,160 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _TXRX_H_ +#define _TXRX_H_ + +#include <linux/etherdevice.h> +#include "wcn36xx.h" + +/* TODO describe all properties */ +#define WCN36XX_802_11_HEADER_LEN 24 +#define WCN36XX_BMU_WQ_TX 25 +#define WCN36XX_TID 7 +/* broadcast wq ID */ +#define WCN36XX_TX_B_WQ_ID 0xA +#define WCN36XX_TX_U_WQ_ID 0x9 +/* bd_rate */ +#define WCN36XX_BD_RATE_DATA 0 +#define WCN36XX_BD_RATE_MGMT 2 +#define WCN36XX_BD_RATE_CTRL 3 + +struct wcn36xx_pdu { +u32 dpu_fb:8 ; +u32 adu_fb:8 ; +u32 pdu_id:16 ; + +/* 0x04*/ +u32 tail_pdu_idx:16 ; +u32 head_pdu_idx:16 ; + +/* 0x08*/ +u32 pdu_count:7 ; +u32 mpdu_data_off:9 ; +u32 mpdu_header_off:8 ; +u32 mpdu_header_len:8 ; + +/* 0x0c*/ +u32 reserved4:8 ; +u32 tid:4 ; +u32 reserved3:4 ; +u32 mpdu_len:16 ; +}; + +struct wcn36xx_rx_bd { +u32 bdt:2 ; +u32 ft:1 ; +u32 dpu_ne:1 ; +u32 rx_key_id:3 ; +u32 ub:1 ; +u32 rmf:1 ; +u32 uma_bypass:1 ; +u32 csr11:1 ; +u32 reserved0:1 ; +u32 scan_learn:1 ; +u32 rx_ch:4 ; +u32 rtsf:1 ; +u32 bsf:1 ; +u32 a2hf:1 ; +u32 st_auf:1 ; +u32 dpu_sign:3 ; +u32 dpu_rf:8 ; + +struct wcn36xx_pdu pdu; + +/* 0x14*/ +u32 addr3:8 ; +u32 addr2:8 ; +u32 addr1:8 ; +u32 dpu_desc_idx:8 ; + +/* 0x18*/ +u32 rxp_flags:23 ; +u32 rate_id:9 ; + +u32 phy_stat0; +u32 phy_stat1; + +/* 0x24 */ +u32 rx_times; + +u32 pmi_cmd[6 ]; + +/* 0x40 */ +u32 reserved7:4 ; +u32 reorder_slot_id:6 ; +u32 reorder_fwd_id:6 ; +u32 reserved6:12 ; +u32 reorder_code:4 ; + +/* 0x44 */ +u32 exp_seq_num:12 ; +u32 cur_seq_num:12 ; +u32 fr_type_subtype:8 ; + +/* 0x48 */ +u32 msdu_size:16 ; +u32 sub_fr_id:4 ; +u32 proc_order:4 ; +u32 reserved9:4 ; +u32 aef:1 ; +u32 lsf:1 ; +u32 esf:1 ; +u32 asf:1 ; +}; + +struct wcn36xx_tx_bd { +u32 bdt:2 ; +u32 ft:1 ; +u32 dpu_ne:1 ; +u32 fw_tx_comp:1 ; +u32 tx_comp:1 ; +u32 reserved1:1 ; +u32 ub:1 ; +u32 rmf:1 ; +u32 reserved0:12 ; +u32 dpu_sign:3 ; +u32 dpu_rf:8 ; + +struct wcn36xx_pdu pdu; + +/* 0x14*/ +u32 reserved5:7 ; +u32 queue_id:5 ; +u32 bd_rate:2 ; +u32 ack_policy:2 ; +u32 sta_index:8 ; +u32 dpu_desc_idx:8 ; + +u32 tx_bd_sign; +u32 reserved6; +u32 dxe_start_time; +u32 dxe_end_time; + +/*u32 tcp_udp_start_off:10; +u32 header_cks:16; +u32 reserved7:6;*/ +}; + +struct wcn36xx_sta ; +struct wcn36xx ; + +int wcn36xx_rx_skb (struct wcn36xx *wcn,struct sk_buff *skb); +int wcn36xx_start_tx (struct wcn36xx *wcn, +struct wcn36xx_sta *sta_priv, +struct sk_buff *skb); + +#endif /* _TXRX_H_ */
Signature · 1 line
1.8.2.2
PATCH v2 13/16 wcn36xx: add wcn36xx.h
In reply to Eugene KrasnikovAdding wcn36xx.h
--- drivers/net/wireless/ath/wcn36xx/wcn36xx.h | 236 +++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/wcn36xx.h
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +236 -0
@@ -0,0 +1,236 @@ +/* +* Copyright (c) 2013 Eugene Krasnikov <[email protected]> +* +* Permission to use, copy, modify, and/or distribute this software for any +* purpose with or without fee is hereby granted, provided that the above +* copyright notice and this permission notice appear in all copies. +* +* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef _WCN36XX_H_ +#define _WCN36XX_H_ + +#include <linux/completion.h> +#include <linux/printk.h> +#include <linux/spinlock.h> +#include <net/mac80211.h> + +#include "hal.h" +#include "smd.h" +#include "txrx.h" +#include "dxe.h" +#include "pmc.h" +#include "debug.h" + +#define WLAN_NV_FILE "wlan/prima/WCNSS_qcom_wlan_nv.bin" +#define WCN36XX_AGGR_BUFFER_SIZE 64 + +extern unsigned int debug_mask; + +enum wcn36xx_debug_mask { +WCN36XX_DBG_DXE =0x00000001 , +WCN36XX_DBG_DXE_DUMP =0x00000002 , +WCN36XX_DBG_SMD =0x00000004 , +WCN36XX_DBG_SMD_DUMP =0x00000008 , +WCN36XX_DBG_RX =0x00000010 , +WCN36XX_DBG_RX_DUMP =0x00000020 , +WCN36XX_DBG_TX =0x00000040 , +WCN36XX_DBG_TX_DUMP =0x00000080 , +WCN36XX_DBG_HAL =0x00000100 , +WCN36XX_DBG_HAL_DUMP =0x00000200 , +WCN36XX_DBG_MAC =0x00000400 , +WCN36XX_DBG_BEACON =0x00000800 , +WCN36XX_DBG_BEACON_DUMP =0x00001000 , +WCN36XX_DBG_PMC =0x00002000 , +WCN36XX_DBG_PMC_DUMP =0x00004000 , +WCN36XX_DBG_ANY =0xffffffff , +}; + +#define wcn36xx_err(fmt, arg...) \ + printk(KERN_ERR pr_fmt("ERROR " fmt), ##arg); + +#define wcn36xx_warn(fmt, arg...) \ + printk(KERN_WARNING pr_fmt("WARNING " fmt), ##arg) + +#define wcn36xx_info(fmt, arg...) \ + printk(KERN_INFO pr_fmt(fmt), ##arg) + +#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0) + +#define wcn36xx_dbg_dump (mask, prefix_str, buf, len) do { \ + if (debug_mask & mask) \ + print_hex_dump(KERN_DEBUG, pr_fmt(prefix_str), \ + DUMP_PREFIX_OFFSET, 32, 1, \ + buf, len, false); \ +} while (0) + +#define WCN36XX_HW_CHANNEL (__wcn) (__wcn->hw->conf.chandef.chan->hw_value) +#define WCN36XX_BAND (__wcn) (__wcn->hw->conf.chandef.chan->band) +#define WCN36XX_CENTER_FREQ (__wcn) (__wcn->hw->conf.chandef.chan->center_freq) +#define WCN36XX_LISTEN_INTERVAL (__wcn) (__wcn->hw->conf.listen_interval) +#define WCN36XX_FLAGS (__wcn) (__wcn->hw->flags) +#define WCN36XX_MAX_POWER (__wcn) (__wcn->hw->conf.chandef.chan->max_power) + +static inline void buff_to_be (u32 *buf,size_t len) +{ +int i; +for (i =0 ; i < len; i++) + buf[i] =cpu_to_be32 (buf[i]); +} + +struct nv_data { +int is_valid; +u8 table; +}; + +/* Interface for platform control path +* +* @open: hook must be called when wcn36xx wants to open control channel. +* @tx: sends a buffer. +*/ +struct wcn36xx_platform_ctrl_ops { +int (*open)(void *drv_priv,void *rsp_cb); +void (*close)(void ); +int (*tx)(char *buf,size_t len); +int (*get_hw_mac)(u8 *addr); +int (*smsm_change_state)(u32 clear_mask,u32 set_mask); +}; + +/** +* struct wcn36xx_vif - holds VIF related fields +* +* @bss_index: bss_index is initially set to 0xFF. bss_index is received from +* HW after first config_bss call and must be used in delete_bss and +* enter/exit_bmps. +*/ +struct wcn36xx_vif { +u8 bss_index; +u8 ucast_dpu_signature; +/* Returned from WCN36XX_HAL_ADD_STA_SELF_RSP */ +u8 self_sta_index; +u8 self_dpu_desc_index; +}; + +/** +* struct wcn36xx_sta - holds STA related fields +* +* @tid: traffic ID that is used during AMPDU and in TX BD. +* @sta_index: STA index is returned from HW after config_sta call and is +* used in both SMD channel and TX BD. +* @dpu_desc_index: DPU descriptor index is returned from HW after config_sta +* call and is used in TX BD. +* @bss_sta_index: STA index is returned from HW after config_bss call and is +* used in both SMD channel and TX BD. See table bellow when it is used. +* @bss_dpu_desc_index: DPU descriptor index is returned from HW after +* config_bss call and is used in TX BD. +* ______________________________________________ +* | | STA | AP | +* |______________|_____________|_______________| +* | TX BD |bss_sta_index| sta_index | +* |______________|_____________|_______________| +* |all SMD calls |bss_sta_index| sta_index | +* |______________|_____________|_______________| +* |smd_delete_sta| sta_index | sta_index | +* |______________|_____________|_______________| +*/ +struct wcn36xx_sta { +u16 tid; +u8 sta_index; +u8 dpu_desc_index; +u8 bss_sta_index; +u8 bss_dpu_desc_index; +bool is_data_encrypted; +}; +struct wcn36xx_dxe_ch ; +struct wcn36xx { +struct ieee80211_hw *hw; +struct device *dev; +struct mac_address addresses; +struct wcn36xx_hal_mac_ssid ssid; +u16 aid; +struct wcn36xx_vif *current_vif; +struct wcn36xx_sta *sta; +u8 dtim_period; +enum ani_ed_type encrypt_type; + +/* WoW related*/ +struct mutex pm_mutex; +bool is_suspended; +bool is_con_lost_pending; + +u8 fw_revision; +u8 fw_version; +u8 fw_minor; +u8 fw_major; + +/* extra byte for the NULL termination */ +u8 crm_version[WCN36XX_HAL_VERSION_LENGTH +1 ]; +u8 wlan_version[WCN36XX_HAL_VERSION_LENGTH +1 ]; + +/* IRQs */ +int tx_irq; +int rx_irq; +void __iomem *mmio; + +/* Rates */ +struct wcn36xx_hal_supported_rates supported_rates; + +struct wcn36xx_platform_ctrl_ops *ctrl_ops; +/* +* smd_buf must be protected with smd_mutex to garantee +* that all messages are sent one after another +*/ +u8 *smd_buf; +struct mutex smd_mutex; + +bool is_joining; + +/* DXE channels */ +struct wcn36xx_dxe_ch dxe_tx_l_ch;/* TX low */ +struct wcn36xx_dxe_ch dxe_tx_h_ch;/* TX high */ +struct wcn36xx_dxe_ch dxe_rx_l_ch;/* RX low */ +struct wcn36xx_dxe_ch dxe_rx_h_ch;/* RX high */ + +/* For synchronization of DXE resources from BH, IRQ and WQ contexts */ +spinlock_t dxe_lock; +bool queues_stopped; + +/* Memory pools */ +struct wcn36xx_dxe_mem_pool mgmt_mem_pool; +struct wcn36xx_dxe_mem_pool data_mem_pool; + +struct sk_buff *tx_ack_skb; + +/* Power management */ +enum wcn36xx_power_state pw_state; + +#ifdef CONFIG_WCN36XX_DEBUGFS +/* Debug file system entry */ +struct wcn36xx_dfs_entry dfs; +#endif /* CONFIG_WCN36XX_DEBUGFS */ + +}; + +static inline bool wcn36xx_is_fw_version (struct wcn36xx *wcn, +u8 major, +u8 minor, +u8 version, +u8 revision) +{ +return (wcn->fw_major == major && + wcn->fw_minor == minor && + wcn->fw_version == version && + wcn->fw_revision == revision); +} + +#endif /* _WCN36XX_H_ */
Signature · 1 line
1.8.2.2
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 1 line · Eugene Krasnikov
Adding
wcn36xx.h
[]
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 64
Quoted 9 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +9
-0+#define wcn36xx_err(fmt, arg...) \ + printk(KERN_ERR pr_fmt("ERROR " fmt), ##arg); + +#define wcn36xx_warn(fmt, arg...) \ + printk(KERN_WARNING pr_fmt("WARNING " fmt), ##arg) + +#define wcn36xx_info(fmt, arg...) \ + printk(KERN_INFO pr_fmt(fmt), ##arg) +
I these would be better using:
#define wcn36xx_err(fmt, ...) \
pr_err("ERROR " fmt, ##__VA_ARGS__)etc...
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 68
Quoted 4 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +4
-0+#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0)
And maybe this one using pr_debug so dynamic_debug can work too.
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Since wcn36xx soon will become a part of ath family and all ath drivers are using printk i thought it's reasonable to use common approach everywhere:) May be in future all ath debug functions will be united into one debug framework and the same code will be used everywhere.
2013/8/24 Joe Perches <[email protected]>:
Quoted 29 lines · Eugene Krasnikov
Quoted 1 line
Adding
wcn36xx.h[]
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 64
Quoted 9 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +9
-0+#define wcn36xx_err(fmt, arg...) \ + printk(KERN_ERR pr_fmt("ERROR " fmt), ##arg); + +#define wcn36xx_warn(fmt, arg...) \ + printk(KERN_WARNING pr_fmt("WARNING " fmt), ##arg) + +#define wcn36xx_info(fmt, arg...) \ + printk(KERN_INFO pr_fmt(fmt), ##arg) +I these would be better using:
#define wcn36xx_err(fmt, ...) \ pr_err("ERROR " fmt, ##__VA_ARGS__)etc...
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 68
Quoted 4 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +4
-0+#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0)And maybe this one using
pr_debugsodynamic_debugcan work too.
Signature · 2 lines
Best regards, Eugene
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
In reply to Joe PerchesQuoted 7 lines · Joe Perches
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 68
Quoted 4 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +4
-0+#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0)And maybe this one using
pr_debugsodynamic_debugcan work too.
Please, no dynamic_debug. It's useless on a wifi driver.
Signature · 1 line
Kalle Valo
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 11 lines · Kalle Valo
Quoted 7 lines · Joe Perches
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 68
Quoted 4 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +4
-0+#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0)And maybe this one using
pr_debugsodynamic_debugcan work too.Please, no
dynamic_debug. It's useless on a wifi driver.
Why is that?
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 11 lines · Joe Perches
Quoted 10 lines · Kalle Valo
Quoted 7 lines · Joe Perches
drivers/net/wireless/ath/wcn36xx/wcn36xx.h line 68
Quoted 4 lines
drivers/net/wireless/ath/wcn36xx/wcn36xx.h new file +4
-0+#define wcn36xx_dbg(mask, fmt, arg...) do { \ + if (debug_mask & mask) \ + printk(KERN_DEBUG pr_fmt(fmt), ##arg); \ +} while (0)And maybe this one using
pr_debugsodynamic_debugcan work too.
Quoted 3 lines
Quoted 1 line
Please, no
dynamic_debug. It's useless on a wifi driver.Why is that?
It's not really usable in practise, at least the last time I looked at it. It's cumbersome to enable log messages based on their line numbers and line numbers change so you can't really make any scripts to help with that. And enabling log messages on the file level is sometimes too much. So it would really need some sort of grouping feature with a stable interface.
Signature · 1 line
Kalle Valo
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 5 lines · Kalle Valo
Joe Perches <[email protected]> writes:
Please, nodynamic_debug. It's useless on a wifi driver.Quoted 1 line
Why is that?
It's not really usable in practise, at least the last time I looked at it.
Then you probably haven't looked recently.
Quoted 3 lines
It's cumbersome to enable log messages based on their line numbers and line numbers change so you can't really make any scripts to help with that.
Most don't do that.
Generally it's enabled/disabled by module.
Quoted 3 lines
And enabling log messages on the file level is sometimes too much. So it would really need some sort of grouping feature with a stable interface.
Like by module?
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 8 lines · Joe Perches
Most don't do that.
Generally it's enabled/disabled by module.Quoted 3 lines
And enabling log messages on the file level is sometimes too much. So it would really need some sort of grouping feature with a stable interface.
Like by module?
What does module mean in this context? File like "wmi.c" or something else?
Signature · 1 line
Kalle Valo
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 5 lines · Kalle Valo
Quoted 3 lines · Joe Perches
Most don't do that.
Generally it's enabled/disabled by module.
Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
And enabling log messages on the file level is sometimes too much. So it would really need some sort of grouping feature with a stable interface.
Like by module?
What does module mean in this context?
KBUILD_MODNAME
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 10 lines · Joe Perches
Quoted 9 lines · Kalle Valo
Quoted 7 lines · Joe Perches
Most don't do that.
Generally it's enabled/disabled by module.Quoted 3 lines
And enabling log messages on the file level is sometimes too much. So it would really need some sort of grouping feature with a stable interface.
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
Like by module?
What does module mean in this context?
KBUILD_MODNAME
Ok, so there's no way to have functionality like ATH6KL_DBG_BOOT which prints information from various files during firmware boot. So dynamic_debug is not really usable for my work flow.
Signature · 1 line
Kalle Valo
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 7 lines · Kalle Valo
Quoted 3 lines
Quoted 1 line
What does module mean in this context?
KBUILD_MODNAMEOk, so there's no way to have functionality like
ATH6KL_DBG_BOOTwhich prints information from various files during firmware boot. Sodynamic_debugis not really usable for my work flow.
I'm confused by your response.
Dynamic debug can work with external masks/levels. What functionality do you think you're missing?
Re: [PATCH v2 13/16] wcn36xx: add wcn36xx.h
Quoted 5 lines · Joe Perches
Quoted 4 lines · Kalle Valo
Quoted 3 lines
Quoted 1 line
What does module mean in this context?
KBUILD_MODNAME
Quoted 7 lines
Quoted 3 lines
Ok, so there's no way to have functionality like
ATH6KL_DBG_BOOTwhich prints information from various files during firmware boot. Sodynamic_debugis not really usable for my work flow.I'm confused by your response.
Dynamic debug can work with external masks/levels. What functionality do you think you're missing?
I was just replying to your question why I think dynamic_debug is not usable in wifi drivers.
Signature · 1 line
Kalle Valo
PATCH v2 14/16 wcn36xx: add Makefile
In reply to Eugene KrasnikovAdding Makefile
--- drivers/net/wireless/ath/wcn36xx/Makefile | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/Makefile
drivers/net/wireless/ath/wcn36xx/Makefile new file +9 -0
@@ -0,0 +1,9 @@ +obj-$(CONFIG_WCN36XX) := wcn36xx.o +wcn36xx-y += main.o \ + dxe.o \ + txrx.o \ + smd.o \ + pmc.o \ + debug.o + +
Signature · 1 line
1.8.2.2
PATCH v2 15/16 wcn36xx: add Kconfig
In reply to Eugene KrasnikovAdding Kconfig
--- drivers/net/wireless/ath/wcn36xx/Kconfig | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 drivers/net/wireless/ath/wcn36xx/Kconfig
drivers/net/wireless/ath/wcn36xx/Kconfig new file +16 -0
@@ -0,0 +1,16 @@ +config WCN36XX + tristate "Qualcomm Atheros WCN3660/3680 support" + depends on MAC80211 && HAS_DMA + ---help--- + This module adds support for wireless adapters based on + Qualcomm Atheros WCN3660 and WCN3680 mobile chipsets. + + If you choose to build a module, it'll be called wcn36xx. + +config WCN36XX_DEBUGFS + bool "WCN36XX debugfs support" + depends on WCN36XX + ---help--- + Enabled debugfs support + + If unsure, say Y to make it easier to debug problems.
Signature · 1 line
1.8.2.2
PATCH v2 16/16 wcn36xx: Add wcn36xx to ath Makefile and Kconfig
In reply to Eugene KrasnikovNow wcn36xx is part of ath family.
--- drivers/net/wireless/ath/Kconfig | 1 + drivers/net/wireless/ath/Makefile | 1 + 2 files changed, 2 insertions(+)
drivers/net/wireless/ath/Kconfig +1 -0
@@ -32,5 +32,6 @@ source "drivers/net/wireless/ath/ath6kl/Kconfig" source "drivers/net/wireless/ath/ar5523/Kconfig" source "drivers/net/wireless/ath/wil6210/Kconfig" source "drivers/net/wireless/ath/ath10k/Kconfig" +source "drivers/net/wireless/ath/wcn36xx/Kconfig" endif
drivers/net/wireless/ath/Makefile +1 -0
@@ -5,6 +5,7 @@ obj-$(CONFIG_ATH6KL) += ath6kl/ obj-$(CONFIG_AR5523) += ar5523/ obj-$(CONFIG_WIL6210) += wil6210/ obj-$(CONFIG_ATH10K) += ath10k/ +obj-$(CONFIG_WCN36XX) += wcn36xx/ obj-$(CONFIG_ATH_COMMON) += ath.o
Signature · 1 line
1.8.2.2