| 1 |
/* |
| 2 |
* Copyright (c) 2013 Eugene Krasnikov <[email protected]> |
| 3 |
* |
| 4 |
* Permission to use, copy, modify, and/or distribute this software for any |
| 5 |
* purpose with or without fee is hereby granted, provided that the above |
| 6 |
* copyright notice and this permission notice appear in all copies. |
| 7 |
* |
| 8 |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 9 |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 10 |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 11 |
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 12 |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 13 |
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 14 |
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| 15 |
*/ |
| 16 |
|
| 17 |
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 18 |
|
| 19 |
#include <linux/module.h> |
| 20 |
#include <linux/firmware.h> |
| 21 |
#include <linux/platform_device.h> |
| 22 |
#include <linux/of.h> |
| 23 |
#include <linux/of_address.h> |
| 24 |
#include <linux/rpmsg.h> |
| 25 |
#include <linux/soc/qcom/smem_state.h> |
| 26 |
#include <linux/soc/qcom/wcnss_ctrl.h> |
| 27 |
#include <net/ipv6.h> |
| 28 |
#include "wcn36xx.h" |
| 29 |
#include "testmode.h" |
| 30 |
#include "firmware.h" |
| 31 |
|
| 32 |
unsigned int wcn36xx_dbg_mask; |
| 33 |
module_param_named(debug_mask, wcn36xx_dbg_mask, uint, 0644); |
| 34 |
MODULE_PARM_DESC(debug_mask, "Debugging mask"); |
| 35 |
|
| 36 |
#define CHAN2G(_freq, _idx) { \ |
| 37 |
.band = NL80211_BAND_2GHZ, \ |
| 38 |
.center_freq = (_freq), \ |
| 39 |
.hw_value = (_idx), \ |
| 40 |
.max_power = 25, \ |
| 41 |
} |
| 42 |
|
| 43 |
#define CHAN5G(_freq, _idx, _phy_val) { \ |
| 44 |
.band = NL80211_BAND_5GHZ, \ |
| 45 |
.center_freq = (_freq), \ |
| 46 |
.hw_value = (_phy_val) << HW_VALUE_PHY_SHIFT | HW_VALUE_CHANNEL(_idx), \ |
| 47 |
.max_power = 25, \ |
| 48 |
} |
| 49 |
|
| 50 |
/* The wcn firmware expects channel values to matching |
| 51 |
* their mnemonic values. So use these for .hw_value. */ |
| 52 |
static struct ieee80211_channel wcn_2ghz_channels[] = { |
| 53 |
CHAN2G(2412, 1), /* Channel 1 */ |
| 54 |
CHAN2G(2417, 2), /* Channel 2 */ |
| 55 |
CHAN2G(2422, 3), /* Channel 3 */ |
| 56 |
CHAN2G(2427, 4), /* Channel 4 */ |
| 57 |
CHAN2G(2432, 5), /* Channel 5 */ |
| 58 |
CHAN2G(2437, 6), /* Channel 6 */ |
| 59 |
CHAN2G(2442, 7), /* Channel 7 */ |
| 60 |
CHAN2G(2447, 8), /* Channel 8 */ |
| 61 |
CHAN2G(2452, 9), /* Channel 9 */ |
| 62 |
CHAN2G(2457, 10), /* Channel 10 */ |
| 63 |
CHAN2G(2462, 11), /* Channel 11 */ |
| 64 |
CHAN2G(2467, 12), /* Channel 12 */ |
| 65 |
CHAN2G(2472, 13), /* Channel 13 */ |
| 66 |
CHAN2G(2484, 14) /* Channel 14 */ |
| 67 |
|
| 68 |
}; |
| 69 |
|
| 70 |
static struct ieee80211_channel wcn_5ghz_channels[] = { |
| 71 |
CHAN5G(5180, 36, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 72 |
CHAN5G(5200, 40, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 73 |
CHAN5G(5220, 44, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 74 |
CHAN5G(5240, 48, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 75 |
CHAN5G(5260, 52, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 76 |
CHAN5G(5280, 56, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 77 |
CHAN5G(5300, 60, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 78 |
CHAN5G(5320, 64, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 79 |
CHAN5G(5500, 100, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 80 |
CHAN5G(5520, 104, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 81 |
CHAN5G(5540, 108, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 82 |
CHAN5G(5560, 112, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 83 |
CHAN5G(5580, 116, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 84 |
CHAN5G(5600, 120, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 85 |
CHAN5G(5620, 124, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 86 |
CHAN5G(5640, 128, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 87 |
CHAN5G(5660, 132, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 88 |
CHAN5G(5680, 136, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 89 |
CHAN5G(5700, 140, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 90 |
CHAN5G(5720, 144, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 91 |
CHAN5G(5745, 149, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_LOW), |
| 92 |
CHAN5G(5765, 153, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_LOW), |
| 93 |
CHAN5G(5785, 157, PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_HIGH), |
| 94 |
CHAN5G(5805, 161, PHY_QUADRUPLE_CHANNEL_20MHZ_HIGH_40MHZ_HIGH), |
| 95 |
CHAN5G(5825, 165, 0) |
| 96 |
}; |
| 97 |
|
| 98 |
#define RATE(_bitrate, _hw_rate, _flags) { \ |
| 99 |
.bitrate = (_bitrate), \ |
| 100 |
.flags = (_flags), \ |
| 101 |
.hw_value = (_hw_rate), \ |
| 102 |
.hw_value_short = (_hw_rate) \ |
| 103 |
} |
| 104 |
|
| 105 |
static struct ieee80211_rate wcn_2ghz_rates[] = { |
| 106 |
RATE(10, HW_RATE_INDEX_1MBPS, 0), |
| 107 |
RATE(20, HW_RATE_INDEX_2MBPS, IEEE80211_RATE_SHORT_PREAMBLE), |
| 108 |
RATE(55, HW_RATE_INDEX_5_5MBPS, IEEE80211_RATE_SHORT_PREAMBLE), |
| 109 |
RATE(110, HW_RATE_INDEX_11MBPS, IEEE80211_RATE_SHORT_PREAMBLE), |
| 110 |
RATE(60, HW_RATE_INDEX_6MBPS, 0), |
| 111 |
RATE(90, HW_RATE_INDEX_9MBPS, 0), |
| 112 |
RATE(120, HW_RATE_INDEX_12MBPS, 0), |
| 113 |
RATE(180, HW_RATE_INDEX_18MBPS, 0), |
| 114 |
RATE(240, HW_RATE_INDEX_24MBPS, 0), |
| 115 |
RATE(360, HW_RATE_INDEX_36MBPS, 0), |
| 116 |
RATE(480, HW_RATE_INDEX_48MBPS, 0), |
| 117 |
RATE(540, HW_RATE_INDEX_54MBPS, 0) |
| 118 |
}; |
| 119 |
|
| 120 |
static struct ieee80211_rate wcn_5ghz_rates[] = { |
| 121 |
RATE(60, HW_RATE_INDEX_6MBPS, 0), |
| 122 |
RATE(90, HW_RATE_INDEX_9MBPS, 0), |
| 123 |
RATE(120, HW_RATE_INDEX_12MBPS, 0), |
| 124 |
RATE(180, HW_RATE_INDEX_18MBPS, 0), |
| 125 |
RATE(240, HW_RATE_INDEX_24MBPS, 0), |
| 126 |
RATE(360, HW_RATE_INDEX_36MBPS, 0), |
| 127 |
RATE(480, HW_RATE_INDEX_48MBPS, 0), |
| 128 |
RATE(540, HW_RATE_INDEX_54MBPS, 0) |
| 129 |
}; |
| 130 |
|
| 131 |
static struct ieee80211_supported_band wcn_band_2ghz = { |
| 132 |
.channels = wcn_2ghz_channels, |
| 133 |
.n_channels = ARRAY_SIZE(wcn_2ghz_channels), |
| 134 |
.bitrates = wcn_2ghz_rates, |
| 135 |
.n_bitrates = ARRAY_SIZE(wcn_2ghz_rates), |
| 136 |
.ht_cap = { |
| 137 |
.cap = IEEE80211_HT_CAP_GRN_FLD | |
| 138 |
IEEE80211_HT_CAP_SGI_20 | |
| 139 |
IEEE80211_HT_CAP_DSSSCCK40 | |
| 140 |
IEEE80211_HT_CAP_LSIG_TXOP_PROT | |
| 141 |
IEEE80211_HT_CAP_SGI_40 | |
| 142 |
IEEE80211_HT_CAP_SUP_WIDTH_20_40, |
| 143 |
.ht_supported = true, |
| 144 |
.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, |
| 145 |
.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16, |
| 146 |
.mcs = { |
| 147 |
.rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, |
| 148 |
.rx_highest = cpu_to_le16(72), |
| 149 |
.tx_params = IEEE80211_HT_MCS_TX_DEFINED, |
| 150 |
} |
| 151 |
} |
| 152 |
}; |
| 153 |
|
| 154 |
static struct ieee80211_supported_band wcn_band_5ghz = { |
| 155 |
.channels = wcn_5ghz_channels, |
| 156 |
.n_channels = ARRAY_SIZE(wcn_5ghz_channels), |
| 157 |
.bitrates = wcn_5ghz_rates, |
| 158 |
.n_bitrates = ARRAY_SIZE(wcn_5ghz_rates), |
| 159 |
.ht_cap = { |
| 160 |
.cap = IEEE80211_HT_CAP_GRN_FLD | |
| 161 |
IEEE80211_HT_CAP_SGI_20 | |
| 162 |
IEEE80211_HT_CAP_DSSSCCK40 | |
| 163 |
IEEE80211_HT_CAP_LSIG_TXOP_PROT | |
| 164 |
IEEE80211_HT_CAP_SGI_40 | |
| 165 |
IEEE80211_HT_CAP_SUP_WIDTH_20_40, |
| 166 |
.ht_supported = true, |
| 167 |
.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, |
| 168 |
.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16, |
| 169 |
.mcs = { |
| 170 |
.rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, |
| 171 |
.rx_highest = cpu_to_le16(150), |
| 172 |
.tx_params = IEEE80211_HT_MCS_TX_DEFINED, |
| 173 |
} |
| 174 |
} |
| 175 |
}; |
| 176 |
|
| 177 |
#ifdef CONFIG_PM |
| 178 |
|
| 179 |
static const struct wiphy_wowlan_support wowlan_support = { |
| 180 |
.flags = WIPHY_WOWLAN_ANY | |
| 181 |
WIPHY_WOWLAN_MAGIC_PKT | |
| 182 |
WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
| 183 |
}; |
| 184 |
|
| 185 |
#endif |
| 186 |
|
| 187 |
static inline u8 get_sta_index(struct ieee80211_vif *vif, |
| 188 |
struct wcn36xx_sta *sta_priv) |
| 189 |
{ |
| 190 |
return NL80211_IFTYPE_STATION == vif->type ? |
| 191 |
sta_priv->bss_sta_index : |
| 192 |
sta_priv->sta_index; |
| 193 |
} |
| 194 |
|
| 195 |
static void wcn36xx_feat_caps_info(struct wcn36xx *wcn) |
| 196 |
{ |
| 197 |
int i; |
| 198 |
|
| 199 |
for (i = 0; i < MAX_FEATURE_SUPPORTED; i++) { |
| 200 |
if (wcn36xx_firmware_get_feat_caps(wcn->fw_feat_caps, i)) { |
| 201 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "FW Cap %s\n", |
| 202 |
wcn36xx_firmware_get_cap_name(i)); |
| 203 |
} |
| 204 |
} |
| 205 |
} |
| 206 |
|
| 207 |
static int wcn36xx_start(struct ieee80211_hw *hw) |
| 208 |
{ |
| 209 |
struct wcn36xx *wcn = hw->priv; |
| 210 |
int ret; |
| 211 |
|
| 212 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac start\n"); |
| 213 |
|
| 214 |
/* SMD initialization */ |
| 215 |
ret = wcn36xx_smd_open(wcn); |
| 216 |
if (ret) { |
| 217 |
wcn36xx_err("Failed to open smd channel: %d\n", ret); |
| 218 |
goto out_err; |
| 219 |
} |
| 220 |
|
| 221 |
/* Allocate memory pools for Mgmt BD headers and Data BD headers */ |
| 222 |
ret = wcn36xx_dxe_allocate_mem_pools(wcn); |
| 223 |
if (ret) { |
| 224 |
wcn36xx_err("Failed to alloc DXE mempool: %d\n", ret); |
| 225 |
goto out_smd_close; |
| 226 |
} |
| 227 |
|
| 228 |
ret = wcn36xx_dxe_alloc_ctl_blks(wcn); |
| 229 |
if (ret) { |
| 230 |
wcn36xx_err("Failed to alloc DXE ctl blocks: %d\n", ret); |
| 231 |
goto out_free_dxe_pool; |
| 232 |
} |
| 233 |
|
| 234 |
ret = wcn36xx_smd_load_nv(wcn); |
| 235 |
if (ret) { |
| 236 |
wcn36xx_err("Failed to push NV to chip\n"); |
| 237 |
goto out_free_dxe_ctl; |
| 238 |
} |
| 239 |
|
| 240 |
ret = wcn36xx_smd_start(wcn); |
| 241 |
if (ret) { |
| 242 |
wcn36xx_err("Failed to start chip\n"); |
| 243 |
goto out_free_dxe_ctl; |
| 244 |
} |
| 245 |
|
| 246 |
if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) { |
| 247 |
ret = wcn36xx_smd_feature_caps_exchange(wcn); |
| 248 |
if (ret) |
| 249 |
wcn36xx_warn("Exchange feature caps failed\n"); |
| 250 |
else |
| 251 |
wcn36xx_feat_caps_info(wcn); |
| 252 |
} |
| 253 |
|
| 254 |
/* DMA channel initialization */ |
| 255 |
ret = wcn36xx_dxe_init(wcn); |
| 256 |
if (ret) { |
| 257 |
wcn36xx_err("DXE init failed\n"); |
| 258 |
goto out_smd_stop; |
| 259 |
} |
| 260 |
|
| 261 |
wcn36xx_debugfs_init(wcn); |
| 262 |
|
| 263 |
INIT_LIST_HEAD(&wcn->vif_list); |
| 264 |
spin_lock_init(&wcn->dxe_lock); |
| 265 |
spin_lock_init(&wcn->survey_lock); |
| 266 |
|
| 267 |
return 0; |
| 268 |
|
| 269 |
out_smd_stop: |
| 270 |
wcn36xx_smd_stop(wcn); |
| 271 |
out_free_dxe_ctl: |
| 272 |
wcn36xx_dxe_free_ctl_blks(wcn); |
| 273 |
out_free_dxe_pool: |
| 274 |
wcn36xx_dxe_free_mem_pools(wcn); |
| 275 |
out_smd_close: |
| 276 |
wcn36xx_smd_close(wcn); |
| 277 |
out_err: |
| 278 |
return ret; |
| 279 |
} |
| 280 |
|
| 281 |
static void wcn36xx_stop(struct ieee80211_hw *hw, bool suspend) |
| 282 |
{ |
| 283 |
struct wcn36xx *wcn = hw->priv; |
| 284 |
|
| 285 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac stop\n"); |
| 286 |
|
| 287 |
mutex_lock(&wcn->scan_lock); |
| 288 |
if (wcn->scan_req) { |
| 289 |
struct cfg80211_scan_info scan_info = { |
| 290 |
.aborted = true, |
| 291 |
}; |
| 292 |
|
| 293 |
ieee80211_scan_completed(wcn->hw, &scan_info); |
| 294 |
} |
| 295 |
wcn->scan_req = NULL; |
| 296 |
mutex_unlock(&wcn->scan_lock); |
| 297 |
|
| 298 |
wcn36xx_debugfs_exit(wcn); |
| 299 |
wcn36xx_smd_stop(wcn); |
| 300 |
wcn36xx_dxe_deinit(wcn); |
| 301 |
wcn36xx_smd_close(wcn); |
| 302 |
|
| 303 |
wcn36xx_dxe_free_mem_pools(wcn); |
| 304 |
wcn36xx_dxe_free_ctl_blks(wcn); |
| 305 |
} |
| 306 |
|
| 307 |
static void wcn36xx_change_ps(struct wcn36xx *wcn, bool enable) |
| 308 |
{ |
| 309 |
struct ieee80211_vif *vif = NULL; |
| 310 |
struct wcn36xx_vif *tmp; |
| 311 |
|
| 312 |
list_for_each_entry(tmp, &wcn->vif_list, list) { |
| 313 |
vif = wcn36xx_priv_to_vif(tmp); |
| 314 |
if (enable && !wcn->sw_scan) { |
| 315 |
if (vif->cfg.ps) /* ps allowed ? */ |
| 316 |
wcn36xx_pmc_enter_bmps_state(wcn, vif); |
| 317 |
} else { |
| 318 |
wcn36xx_pmc_exit_bmps_state(wcn, vif); |
| 319 |
} |
| 320 |
} |
| 321 |
} |
| 322 |
|
| 323 |
static void wcn36xx_change_opchannel(struct wcn36xx *wcn, int ch) |
| 324 |
{ |
| 325 |
struct ieee80211_vif *vif = NULL; |
| 326 |
struct wcn36xx_vif *tmp; |
| 327 |
struct ieee80211_supported_band *band; |
| 328 |
struct ieee80211_channel *channel = NULL; |
| 329 |
unsigned long flags; |
| 330 |
int i, j; |
| 331 |
|
| 332 |
for (i = 0; i < ARRAY_SIZE(wcn->hw->wiphy->bands); i++) { |
| 333 |
band = wcn->hw->wiphy->bands[i]; |
| 334 |
if (!band) |
| 335 |
break; |
| 336 |
for (j = 0; j < band->n_channels; j++) { |
| 337 |
if (HW_VALUE_CHANNEL(band->channels[j].hw_value) == ch) { |
| 338 |
channel = &band->channels[j]; |
| 339 |
break; |
| 340 |
} |
| 341 |
} |
| 342 |
if (channel) |
| 343 |
break; |
| 344 |
} |
| 345 |
|
| 346 |
if (!channel) { |
| 347 |
wcn36xx_err("Cannot tune to channel %d\n", ch); |
| 348 |
return; |
| 349 |
} |
| 350 |
|
| 351 |
spin_lock_irqsave(&wcn->survey_lock, flags); |
| 352 |
wcn->band = band; |
| 353 |
wcn->channel = channel; |
| 354 |
spin_unlock_irqrestore(&wcn->survey_lock, flags); |
| 355 |
|
| 356 |
list_for_each_entry(tmp, &wcn->vif_list, list) { |
| 357 |
vif = wcn36xx_priv_to_vif(tmp); |
| 358 |
wcn36xx_smd_switch_channel(wcn, vif, ch); |
| 359 |
} |
| 360 |
|
| 361 |
return; |
| 362 |
} |
| 363 |
|
| 364 |
static int wcn36xx_config(struct ieee80211_hw *hw, int radio_idx, u32 changed) |
| 365 |
{ |
| 366 |
struct wcn36xx *wcn = hw->priv; |
| 367 |
int ret; |
| 368 |
|
| 369 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac config changed 0x%08x\n", changed); |
| 370 |
|
| 371 |
mutex_lock(&wcn->conf_mutex); |
| 372 |
|
| 373 |
if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { |
| 374 |
int ch = WCN36XX_HW_CHANNEL(wcn); |
| 375 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "wcn36xx_config channel switch=%d\n", |
| 376 |
ch); |
| 377 |
|
| 378 |
if (wcn->sw_scan_opchannel == ch && wcn->sw_scan_channel) { |
| 379 |
/* If channel is the initial operating channel, we may |
| 380 |
* want to receive/transmit regular data packets, then |
| 381 |
* simply stop the scan session and exit PS mode. |
| 382 |
*/ |
| 383 |
if (wcn->sw_scan_channel) |
| 384 |
wcn36xx_smd_end_scan(wcn, wcn->sw_scan_channel); |
| 385 |
if (wcn->sw_scan_init) { |
| 386 |
wcn36xx_smd_finish_scan(wcn, HAL_SYS_MODE_SCAN, |
| 387 |
wcn->sw_scan_vif); |
| 388 |
} |
| 389 |
} else if (wcn->sw_scan) { |
| 390 |
/* A scan is ongoing, do not change the operating |
| 391 |
* channel, but start a scan session on the channel. |
| 392 |
*/ |
| 393 |
if (wcn->sw_scan_channel) |
| 394 |
wcn36xx_smd_end_scan(wcn, wcn->sw_scan_channel); |
| 395 |
if (!wcn->sw_scan_init) { |
| 396 |
/* This can fail if we are unable to notify the |
| 397 |
* operating channel. |
| 398 |
*/ |
| 399 |
ret = wcn36xx_smd_init_scan(wcn, |
| 400 |
HAL_SYS_MODE_SCAN, |
| 401 |
wcn->sw_scan_vif); |
| 402 |
if (ret) { |
| 403 |
mutex_unlock(&wcn->conf_mutex); |
| 404 |
return -EIO; |
| 405 |
} |
| 406 |
} |
| 407 |
wcn36xx_smd_start_scan(wcn, ch); |
| 408 |
} else { |
| 409 |
wcn36xx_change_opchannel(wcn, ch); |
| 410 |
} |
| 411 |
} |
| 412 |
|
| 413 |
if (changed & IEEE80211_CONF_CHANGE_PS) |
| 414 |
wcn36xx_change_ps(wcn, hw->conf.flags & IEEE80211_CONF_PS); |
| 415 |
|
| 416 |
if (changed & IEEE80211_CONF_CHANGE_IDLE) { |
| 417 |
if (hw->conf.flags & IEEE80211_CONF_IDLE) |
| 418 |
wcn36xx_smd_enter_imps(wcn); |
| 419 |
else |
| 420 |
wcn36xx_smd_exit_imps(wcn); |
| 421 |
} |
| 422 |
|
| 423 |
mutex_unlock(&wcn->conf_mutex); |
| 424 |
|
| 425 |
return 0; |
| 426 |
} |
| 427 |
|
| 428 |
static void wcn36xx_configure_filter(struct ieee80211_hw *hw, |
| 429 |
unsigned int changed, |
| 430 |
unsigned int *total, u64 multicast) |
| 431 |
{ |
| 432 |
struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp; |
| 433 |
struct wcn36xx *wcn = hw->priv; |
| 434 |
struct wcn36xx_vif *tmp; |
| 435 |
struct ieee80211_vif *vif = NULL; |
| 436 |
|
| 437 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac configure filter\n"); |
| 438 |
|
| 439 |
mutex_lock(&wcn->conf_mutex); |
| 440 |
|
| 441 |
*total &= FIF_ALLMULTI; |
| 442 |
|
| 443 |
fp = (void *)(unsigned long)multicast; |
| 444 |
list_for_each_entry(tmp, &wcn->vif_list, list) { |
| 445 |
vif = wcn36xx_priv_to_vif(tmp); |
| 446 |
|
| 447 |
/* FW handles MC filtering only when connected as STA */ |
| 448 |
if (*total & FIF_ALLMULTI) |
| 449 |
wcn36xx_smd_set_mc_list(wcn, vif, NULL); |
| 450 |
else if (NL80211_IFTYPE_STATION == vif->type && tmp->sta_assoc) |
| 451 |
wcn36xx_smd_set_mc_list(wcn, vif, fp); |
| 452 |
} |
| 453 |
|
| 454 |
mutex_unlock(&wcn->conf_mutex); |
| 455 |
kfree(fp); |
| 456 |
} |
| 457 |
|
| 458 |
static u64 wcn36xx_prepare_multicast(struct ieee80211_hw *hw, |
| 459 |
struct netdev_hw_addr_list *mc_list) |
| 460 |
{ |
| 461 |
struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp; |
| 462 |
struct netdev_hw_addr *ha; |
| 463 |
|
| 464 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac prepare multicast list\n"); |
| 465 |
fp = kzalloc_obj(*fp, GFP_ATOMIC); |
| 466 |
if (!fp) { |
| 467 |
wcn36xx_err("Out of memory setting filters.\n"); |
| 468 |
return 0; |
| 469 |
} |
| 470 |
|
| 471 |
fp->mc_addr_count = 0; |
| 472 |
/* update multicast filtering parameters */ |
| 473 |
if (netdev_hw_addr_list_count(mc_list) <= |
| 474 |
WCN36XX_HAL_MAX_NUM_MULTICAST_ADDRESS) { |
| 475 |
netdev_hw_addr_list_for_each(ha, mc_list) { |
| 476 |
memcpy(fp->mc_addr[fp->mc_addr_count], |
| 477 |
ha->addr, ETH_ALEN); |
| 478 |
fp->mc_addr_count++; |
| 479 |
} |
| 480 |
} |
| 481 |
|
| 482 |
return (u64)(unsigned long)fp; |
| 483 |
} |
| 484 |
|
| 485 |
static void wcn36xx_tx(struct ieee80211_hw *hw, |
| 486 |
struct ieee80211_tx_control *control, |
| 487 |
struct sk_buff *skb) |
| 488 |
{ |
| 489 |
struct wcn36xx *wcn = hw->priv; |
| 490 |
struct wcn36xx_sta *sta_priv = NULL; |
| 491 |
|
| 492 |
if (control->sta) |
| 493 |
sta_priv = wcn36xx_sta_to_priv(control->sta); |
| 494 |
|
| 495 |
if (wcn36xx_start_tx(wcn, sta_priv, skb)) |
| 496 |
ieee80211_free_txskb(wcn->hw, skb); |
| 497 |
} |
| 498 |
|
| 499 |
static int wcn36xx_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, |
| 500 |
struct ieee80211_vif *vif, |
| 501 |
struct ieee80211_sta *sta, |
| 502 |
struct ieee80211_key_conf *key_conf) |
| 503 |
{ |
| 504 |
struct wcn36xx *wcn = hw->priv; |
| 505 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 506 |
struct wcn36xx_sta *sta_priv = sta ? wcn36xx_sta_to_priv(sta) : NULL; |
| 507 |
int ret = 0; |
| 508 |
u8 key[WLAN_MAX_KEY_LEN]; |
| 509 |
|
| 510 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac80211 set key\n"); |
| 511 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "Key: cmd=0x%x algo:0x%x, id:%d, len:%d flags 0x%x\n", |
| 512 |
cmd, key_conf->cipher, key_conf->keyidx, |
| 513 |
key_conf->keylen, key_conf->flags); |
| 514 |
wcn36xx_dbg_dump(WCN36XX_DBG_MAC, "KEY: ", |
| 515 |
key_conf->key, |
| 516 |
key_conf->keylen); |
| 517 |
|
| 518 |
mutex_lock(&wcn->conf_mutex); |
| 519 |
|
| 520 |
switch (key_conf->cipher) { |
| 521 |
case WLAN_CIPHER_SUITE_WEP40: |
| 522 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_WEP40; |
| 523 |
break; |
| 524 |
case WLAN_CIPHER_SUITE_WEP104: |
| 525 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_WEP104; |
| 526 |
break; |
| 527 |
case WLAN_CIPHER_SUITE_CCMP: |
| 528 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_CCMP; |
| 529 |
break; |
| 530 |
case WLAN_CIPHER_SUITE_TKIP: |
| 531 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_TKIP; |
| 532 |
break; |
| 533 |
default: |
| 534 |
wcn36xx_err("Unsupported key type 0x%x\n", |
| 535 |
key_conf->cipher); |
| 536 |
ret = -EOPNOTSUPP; |
| 537 |
goto out; |
| 538 |
} |
| 539 |
|
| 540 |
switch (cmd) { |
| 541 |
case SET_KEY: |
| 542 |
if (WCN36XX_HAL_ED_TKIP == vif_priv->encrypt_type) { |
| 543 |
/* |
| 544 |
* Supplicant is sending key in the wrong order: |
| 545 |
* Temporal Key (16 b) - TX MIC (8 b) - RX MIC (8 b) |
| 546 |
* but HW expects it to be in the order as described in |
| 547 |
* IEEE 802.11 spec (see chapter 11.7) like this: |
| 548 |
* Temporal Key (16 b) - RX MIC (8 b) - TX MIC (8 b) |
| 549 |
*/ |
| 550 |
memcpy(key, key_conf->key, 16); |
| 551 |
memcpy(key + 16, key_conf->key + 24, 8); |
| 552 |
memcpy(key + 24, key_conf->key + 16, 8); |
| 553 |
} else { |
| 554 |
memcpy(key, key_conf->key, key_conf->keylen); |
| 555 |
} |
| 556 |
|
| 557 |
if (IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags) { |
| 558 |
sta_priv->is_data_encrypted = true; |
| 559 |
/* Reconfigure bss with encrypt_type */ |
| 560 |
if (NL80211_IFTYPE_STATION == vif->type) { |
| 561 |
wcn36xx_smd_config_bss(wcn, |
| 562 |
vif, |
| 563 |
sta, |
| 564 |
sta->addr, |
| 565 |
true); |
| 566 |
wcn36xx_smd_config_sta(wcn, vif, sta); |
| 567 |
} |
| 568 |
|
| 569 |
wcn36xx_smd_set_stakey(wcn, |
| 570 |
vif_priv->encrypt_type, |
| 571 |
key_conf->keyidx, |
| 572 |
key_conf->keylen, |
| 573 |
key, |
| 574 |
get_sta_index(vif, sta_priv)); |
| 575 |
} else { |
| 576 |
wcn36xx_smd_set_bsskey(wcn, |
| 577 |
vif_priv->encrypt_type, |
| 578 |
vif_priv->bss_index, |
| 579 |
key_conf->keyidx, |
| 580 |
key_conf->keylen, |
| 581 |
key); |
| 582 |
|
| 583 |
if ((WLAN_CIPHER_SUITE_WEP40 == key_conf->cipher) || |
| 584 |
(WLAN_CIPHER_SUITE_WEP104 == key_conf->cipher)) { |
| 585 |
list_for_each_entry(sta_priv, |
| 586 |
&vif_priv->sta_list, list) { |
| 587 |
sta_priv->is_data_encrypted = true; |
| 588 |
wcn36xx_smd_set_stakey(wcn, |
| 589 |
vif_priv->encrypt_type, |
| 590 |
key_conf->keyidx, |
| 591 |
key_conf->keylen, |
| 592 |
key, |
| 593 |
get_sta_index(vif, sta_priv)); |
| 594 |
} |
| 595 |
} |
| 596 |
} |
| 597 |
break; |
| 598 |
case DISABLE_KEY: |
| 599 |
if (!(IEEE80211_KEY_FLAG_PAIRWISE & key_conf->flags)) { |
| 600 |
if (vif_priv->bss_index != WCN36XX_HAL_BSS_INVALID_IDX) |
| 601 |
wcn36xx_smd_remove_bsskey(wcn, |
| 602 |
vif_priv->encrypt_type, |
| 603 |
vif_priv->bss_index, |
| 604 |
key_conf->keyidx); |
| 605 |
|
| 606 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_NONE; |
| 607 |
} else { |
| 608 |
sta_priv->is_data_encrypted = false; |
| 609 |
/* do not remove key if disassociated */ |
| 610 |
if (sta_priv->aid) |
| 611 |
wcn36xx_smd_remove_stakey(wcn, |
| 612 |
vif_priv->encrypt_type, |
| 613 |
key_conf->keyidx, |
| 614 |
get_sta_index(vif, sta_priv)); |
| 615 |
} |
| 616 |
break; |
| 617 |
default: |
| 618 |
wcn36xx_err("Unsupported key cmd 0x%x\n", cmd); |
| 619 |
ret = -EOPNOTSUPP; |
| 620 |
goto out; |
| 621 |
} |
| 622 |
|
| 623 |
out: |
| 624 |
mutex_unlock(&wcn->conf_mutex); |
| 625 |
|
| 626 |
return ret; |
| 627 |
} |
| 628 |
|
| 629 |
static int wcn36xx_hw_scan(struct ieee80211_hw *hw, |
| 630 |
struct ieee80211_vif *vif, |
| 631 |
struct ieee80211_scan_request *hw_req) |
| 632 |
{ |
| 633 |
struct wcn36xx *wcn = hw->priv; |
| 634 |
|
| 635 |
if (!wcn36xx_firmware_get_feat_caps(wcn->fw_feat_caps, SCAN_OFFLOAD)) { |
| 636 |
/* fallback to mac80211 software scan */ |
| 637 |
return 1; |
| 638 |
} |
| 639 |
|
| 640 |
/* Firmware scan offload is limited to 48 channels, fallback to |
| 641 |
* software driven scanning otherwise. |
| 642 |
*/ |
| 643 |
if (hw_req->req.n_channels > 48) { |
| 644 |
wcn36xx_warn("Offload scan aborted, n_channels=%u", |
| 645 |
hw_req->req.n_channels); |
| 646 |
return 1; |
| 647 |
} |
| 648 |
|
| 649 |
mutex_lock(&wcn->scan_lock); |
| 650 |
if (wcn->scan_req) { |
| 651 |
mutex_unlock(&wcn->scan_lock); |
| 652 |
return -EBUSY; |
| 653 |
} |
| 654 |
|
| 655 |
wcn->scan_aborted = false; |
| 656 |
wcn->scan_req = &hw_req->req; |
| 657 |
|
| 658 |
mutex_unlock(&wcn->scan_lock); |
| 659 |
|
| 660 |
wcn36xx_smd_update_channel_list(wcn, &hw_req->req); |
| 661 |
return wcn36xx_smd_start_hw_scan(wcn, vif, &hw_req->req); |
| 662 |
} |
| 663 |
|
| 664 |
static void wcn36xx_cancel_hw_scan(struct ieee80211_hw *hw, |
| 665 |
struct ieee80211_vif *vif) |
| 666 |
{ |
| 667 |
struct wcn36xx *wcn = hw->priv; |
| 668 |
|
| 669 |
mutex_lock(&wcn->scan_lock); |
| 670 |
wcn->scan_aborted = true; |
| 671 |
mutex_unlock(&wcn->scan_lock); |
| 672 |
|
| 673 |
if (wcn36xx_firmware_get_feat_caps(wcn->fw_feat_caps, SCAN_OFFLOAD)) { |
| 674 |
/* ieee80211_scan_completed will be called on FW scan |
| 675 |
* indication */ |
| 676 |
wcn36xx_smd_stop_hw_scan(wcn); |
| 677 |
} |
| 678 |
} |
| 679 |
|
| 680 |
static void wcn36xx_sw_scan_start(struct ieee80211_hw *hw, |
| 681 |
struct ieee80211_vif *vif, |
| 682 |
const u8 *mac_addr) |
| 683 |
{ |
| 684 |
struct wcn36xx *wcn = hw->priv; |
| 685 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 686 |
|
| 687 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "sw_scan_start"); |
| 688 |
|
| 689 |
wcn->sw_scan = true; |
| 690 |
wcn->sw_scan_vif = vif; |
| 691 |
wcn->sw_scan_channel = 0; |
| 692 |
if (vif_priv->sta_assoc) |
| 693 |
wcn->sw_scan_opchannel = WCN36XX_HW_CHANNEL(wcn); |
| 694 |
else |
| 695 |
wcn->sw_scan_opchannel = 0; |
| 696 |
} |
| 697 |
|
| 698 |
static void wcn36xx_sw_scan_complete(struct ieee80211_hw *hw, |
| 699 |
struct ieee80211_vif *vif) |
| 700 |
{ |
| 701 |
struct wcn36xx *wcn = hw->priv; |
| 702 |
|
| 703 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "sw_scan_complete"); |
| 704 |
|
| 705 |
/* ensure that any scan session is finished */ |
| 706 |
if (wcn->sw_scan_channel) |
| 707 |
wcn36xx_smd_end_scan(wcn, wcn->sw_scan_channel); |
| 708 |
if (wcn->sw_scan_init) { |
| 709 |
wcn36xx_smd_finish_scan(wcn, HAL_SYS_MODE_SCAN, |
| 710 |
wcn->sw_scan_vif); |
| 711 |
} |
| 712 |
wcn->sw_scan = false; |
| 713 |
wcn->sw_scan_opchannel = 0; |
| 714 |
} |
| 715 |
|
| 716 |
static void wcn36xx_update_allowed_rates(struct ieee80211_sta *sta, |
| 717 |
enum nl80211_band band) |
| 718 |
{ |
| 719 |
int i, size; |
| 720 |
u16 *rates_table; |
| 721 |
struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta); |
| 722 |
u32 rates = sta->deflink.supp_rates[band]; |
| 723 |
|
| 724 |
memset(&sta_priv->supported_rates, 0, |
| 725 |
sizeof(sta_priv->supported_rates)); |
| 726 |
sta_priv->supported_rates.op_rate_mode = STA_11n; |
| 727 |
|
| 728 |
size = ARRAY_SIZE(sta_priv->supported_rates.dsss_rates); |
| 729 |
rates_table = sta_priv->supported_rates.dsss_rates; |
| 730 |
if (band == NL80211_BAND_2GHZ) { |
| 731 |
for (i = 0; i < size; i++) { |
| 732 |
if (rates & 0x01) { |
| 733 |
rates_table[i] = wcn_2ghz_rates[i].hw_value; |
| 734 |
rates = rates >> 1; |
| 735 |
} |
| 736 |
} |
| 737 |
} |
| 738 |
|
| 739 |
size = ARRAY_SIZE(sta_priv->supported_rates.ofdm_rates); |
| 740 |
rates_table = sta_priv->supported_rates.ofdm_rates; |
| 741 |
for (i = 0; i < size; i++) { |
| 742 |
if (rates & 0x01) { |
| 743 |
rates_table[i] = wcn_5ghz_rates[i].hw_value; |
| 744 |
rates = rates >> 1; |
| 745 |
} |
| 746 |
} |
| 747 |
|
| 748 |
if (sta->deflink.ht_cap.ht_supported) { |
| 749 |
BUILD_BUG_ON(sizeof(sta->deflink.ht_cap.mcs.rx_mask) > |
| 750 |
sizeof(sta_priv->supported_rates.supported_mcs_set)); |
| 751 |
memcpy(sta_priv->supported_rates.supported_mcs_set, |
| 752 |
sta->deflink.ht_cap.mcs.rx_mask, |
| 753 |
sizeof(sta->deflink.ht_cap.mcs.rx_mask)); |
| 754 |
} |
| 755 |
|
| 756 |
if (sta->deflink.vht_cap.vht_supported) { |
| 757 |
sta_priv->supported_rates.op_rate_mode = STA_11ac; |
| 758 |
sta_priv->supported_rates.vht_rx_mcs_map = |
| 759 |
le16_to_cpu(sta->deflink.vht_cap.vht_mcs.rx_mcs_map); |
| 760 |
sta_priv->supported_rates.vht_tx_mcs_map = |
| 761 |
le16_to_cpu(sta->deflink.vht_cap.vht_mcs.tx_mcs_map); |
| 762 |
} |
| 763 |
} |
| 764 |
|
| 765 |
void wcn36xx_set_default_rates(struct wcn36xx_hal_supported_rates *rates) |
| 766 |
{ |
| 767 |
u16 ofdm_rates[WCN36XX_HAL_NUM_OFDM_RATES] = { |
| 768 |
HW_RATE_INDEX_6MBPS, |
| 769 |
HW_RATE_INDEX_9MBPS, |
| 770 |
HW_RATE_INDEX_12MBPS, |
| 771 |
HW_RATE_INDEX_18MBPS, |
| 772 |
HW_RATE_INDEX_24MBPS, |
| 773 |
HW_RATE_INDEX_36MBPS, |
| 774 |
HW_RATE_INDEX_48MBPS, |
| 775 |
HW_RATE_INDEX_54MBPS |
| 776 |
}; |
| 777 |
u16 dsss_rates[WCN36XX_HAL_NUM_DSSS_RATES] = { |
| 778 |
HW_RATE_INDEX_1MBPS, |
| 779 |
HW_RATE_INDEX_2MBPS, |
| 780 |
HW_RATE_INDEX_5_5MBPS, |
| 781 |
HW_RATE_INDEX_11MBPS |
| 782 |
}; |
| 783 |
|
| 784 |
rates->op_rate_mode = STA_11n; |
| 785 |
memcpy(rates->dsss_rates, dsss_rates, |
| 786 |
sizeof(*dsss_rates) * WCN36XX_HAL_NUM_DSSS_RATES); |
| 787 |
memcpy(rates->ofdm_rates, ofdm_rates, |
| 788 |
sizeof(*ofdm_rates) * WCN36XX_HAL_NUM_OFDM_RATES); |
| 789 |
rates->supported_mcs_set[0] = 0xFF; |
| 790 |
} |
| 791 |
|
| 792 |
void wcn36xx_set_default_rates_v1(struct wcn36xx_hal_supported_rates_v1 *rates) |
| 793 |
{ |
| 794 |
rates->op_rate_mode = STA_11ac; |
| 795 |
rates->vht_rx_mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9; |
| 796 |
rates->vht_tx_mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9; |
| 797 |
} |
| 798 |
|
| 799 |
static void wcn36xx_bss_info_changed(struct ieee80211_hw *hw, |
| 800 |
struct ieee80211_vif *vif, |
| 801 |
struct ieee80211_bss_conf *bss_conf, |
| 802 |
u64 changed) |
| 803 |
{ |
| 804 |
struct wcn36xx *wcn = hw->priv; |
| 805 |
struct sk_buff *skb = NULL; |
| 806 |
u16 tim_off, tim_len; |
| 807 |
enum wcn36xx_hal_link_state link_state; |
| 808 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 809 |
|
| 810 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss info changed vif %p changed 0x%llx\n", |
| 811 |
vif, changed); |
| 812 |
|
| 813 |
mutex_lock(&wcn->conf_mutex); |
| 814 |
|
| 815 |
if (changed & BSS_CHANGED_BEACON_INFO) { |
| 816 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 817 |
"mac bss changed dtim period %d\n", |
| 818 |
bss_conf->dtim_period); |
| 819 |
|
| 820 |
vif_priv->dtim_period = bss_conf->dtim_period; |
| 821 |
} |
| 822 |
|
| 823 |
if (changed & BSS_CHANGED_BSSID) { |
| 824 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss changed_bssid %pM\n", |
| 825 |
bss_conf->bssid); |
| 826 |
|
| 827 |
if (!is_zero_ether_addr(bss_conf->bssid)) { |
| 828 |
vif_priv->is_joining = true; |
| 829 |
vif_priv->bss_index = WCN36XX_HAL_BSS_INVALID_IDX; |
| 830 |
wcn36xx_smd_set_link_st(wcn, bss_conf->bssid, vif->addr, |
| 831 |
WCN36XX_HAL_LINK_PREASSOC_STATE); |
| 832 |
wcn36xx_smd_join(wcn, bss_conf->bssid, |
| 833 |
vif->addr, WCN36XX_HW_CHANNEL(wcn)); |
| 834 |
wcn36xx_smd_config_bss(wcn, vif, NULL, |
| 835 |
bss_conf->bssid, false); |
| 836 |
} else { |
| 837 |
vif_priv->is_joining = false; |
| 838 |
wcn36xx_smd_delete_bss(wcn, vif); |
| 839 |
wcn36xx_smd_set_link_st(wcn, bss_conf->bssid, vif->addr, |
| 840 |
WCN36XX_HAL_LINK_IDLE_STATE); |
| 841 |
vif_priv->encrypt_type = WCN36XX_HAL_ED_NONE; |
| 842 |
} |
| 843 |
} |
| 844 |
|
| 845 |
if (changed & BSS_CHANGED_SSID) { |
| 846 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 847 |
"mac bss changed ssid\n"); |
| 848 |
wcn36xx_dbg_dump(WCN36XX_DBG_MAC, "ssid ", |
| 849 |
vif->cfg.ssid, vif->cfg.ssid_len); |
| 850 |
|
| 851 |
vif_priv->ssid.length = vif->cfg.ssid_len; |
| 852 |
memcpy(&vif_priv->ssid.ssid, |
| 853 |
vif->cfg.ssid, |
| 854 |
vif->cfg.ssid_len); |
| 855 |
} |
| 856 |
|
| 857 |
if (changed & BSS_CHANGED_ASSOC) { |
| 858 |
vif_priv->is_joining = false; |
| 859 |
if (vif->cfg.assoc) { |
| 860 |
struct ieee80211_sta *sta; |
| 861 |
struct wcn36xx_sta *sta_priv; |
| 862 |
|
| 863 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 864 |
"mac assoc bss %pM vif %pM AID=%d\n", |
| 865 |
bss_conf->bssid, |
| 866 |
vif->addr, |
| 867 |
vif->cfg.aid); |
| 868 |
|
| 869 |
vif_priv->sta_assoc = true; |
| 870 |
|
| 871 |
/* |
| 872 |
* Holding conf_mutex ensures mutal exclusion with |
| 873 |
* wcn36xx_sta_remove() and as such ensures that sta |
| 874 |
* won't be freed while we're operating on it. As such |
| 875 |
* we do not need to hold the rcu_read_lock(). |
| 876 |
*/ |
| 877 |
sta = ieee80211_find_sta(vif, bss_conf->bssid); |
| 878 |
if (!sta) { |
| 879 |
wcn36xx_err("sta %pM is not found\n", |
| 880 |
bss_conf->bssid); |
| 881 |
goto out; |
| 882 |
} |
| 883 |
sta_priv = wcn36xx_sta_to_priv(sta); |
| 884 |
|
| 885 |
wcn36xx_update_allowed_rates(sta, WCN36XX_BAND(wcn)); |
| 886 |
|
| 887 |
wcn36xx_smd_set_link_st(wcn, bss_conf->bssid, |
| 888 |
vif->addr, |
| 889 |
WCN36XX_HAL_LINK_POSTASSOC_STATE); |
| 890 |
wcn36xx_smd_config_bss(wcn, vif, sta, |
| 891 |
bss_conf->bssid, |
| 892 |
true); |
| 893 |
sta_priv->aid = vif->cfg.aid; |
| 894 |
/* |
| 895 |
* config_sta must be called from because this is the |
| 896 |
* place where AID is available. |
| 897 |
*/ |
| 898 |
wcn36xx_smd_config_sta(wcn, vif, sta); |
| 899 |
if (vif->type == NL80211_IFTYPE_STATION) |
| 900 |
wcn36xx_smd_add_beacon_filter(wcn, vif); |
| 901 |
wcn36xx_enable_keep_alive_null_packet(wcn, vif); |
| 902 |
} else { |
| 903 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 904 |
"disassociated bss %pM vif %pM AID=%d\n", |
| 905 |
bss_conf->bssid, |
| 906 |
vif->addr, |
| 907 |
vif->cfg.aid); |
| 908 |
vif_priv->sta_assoc = false; |
| 909 |
wcn36xx_smd_set_link_st(wcn, |
| 910 |
bss_conf->bssid, |
| 911 |
vif->addr, |
| 912 |
WCN36XX_HAL_LINK_IDLE_STATE); |
| 913 |
} |
| 914 |
} |
| 915 |
|
| 916 |
if (changed & BSS_CHANGED_AP_PROBE_RESP) { |
| 917 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac bss changed ap probe resp\n"); |
| 918 |
skb = ieee80211_proberesp_get(hw, vif); |
| 919 |
if (!skb) { |
| 920 |
wcn36xx_err("failed to alloc probereq skb\n"); |
| 921 |
goto out; |
| 922 |
} |
| 923 |
|
| 924 |
wcn36xx_smd_update_proberesp_tmpl(wcn, vif, skb); |
| 925 |
dev_kfree_skb(skb); |
| 926 |
} |
| 927 |
|
| 928 |
if (changed & BSS_CHANGED_BEACON_ENABLED || |
| 929 |
changed & BSS_CHANGED_BEACON) { |
| 930 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 931 |
"mac bss changed beacon enabled %d\n", |
| 932 |
bss_conf->enable_beacon); |
| 933 |
|
| 934 |
if (bss_conf->enable_beacon) { |
| 935 |
vif_priv->dtim_period = bss_conf->dtim_period; |
| 936 |
vif_priv->bss_index = WCN36XX_HAL_BSS_INVALID_IDX; |
| 937 |
wcn36xx_smd_config_bss(wcn, vif, NULL, |
| 938 |
vif->addr, false); |
| 939 |
skb = ieee80211_beacon_get_tim(hw, vif, &tim_off, |
| 940 |
&tim_len, 0); |
| 941 |
if (!skb) { |
| 942 |
wcn36xx_err("failed to alloc beacon skb\n"); |
| 943 |
goto out; |
| 944 |
} |
| 945 |
wcn36xx_smd_send_beacon(wcn, vif, skb, tim_off, 0); |
| 946 |
dev_kfree_skb(skb); |
| 947 |
|
| 948 |
if (vif->type == NL80211_IFTYPE_ADHOC || |
| 949 |
vif->type == NL80211_IFTYPE_MESH_POINT) |
| 950 |
link_state = WCN36XX_HAL_LINK_IBSS_STATE; |
| 951 |
else |
| 952 |
link_state = WCN36XX_HAL_LINK_AP_STATE; |
| 953 |
|
| 954 |
wcn36xx_smd_set_link_st(wcn, vif->addr, vif->addr, |
| 955 |
link_state); |
| 956 |
} else { |
| 957 |
wcn36xx_smd_delete_bss(wcn, vif); |
| 958 |
wcn36xx_smd_set_link_st(wcn, vif->addr, vif->addr, |
| 959 |
WCN36XX_HAL_LINK_IDLE_STATE); |
| 960 |
} |
| 961 |
} |
| 962 |
out: |
| 963 |
|
| 964 |
mutex_unlock(&wcn->conf_mutex); |
| 965 |
} |
| 966 |
|
| 967 |
/* this is required when using IEEE80211_HW_HAS_RATE_CONTROL */ |
| 968 |
static int wcn36xx_set_rts_threshold(struct ieee80211_hw *hw, int radio_idx, |
| 969 |
u32 value) |
| 970 |
{ |
| 971 |
struct wcn36xx *wcn = hw->priv; |
| 972 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac set RTS threshold %d\n", value); |
| 973 |
|
| 974 |
mutex_lock(&wcn->conf_mutex); |
| 975 |
wcn36xx_smd_update_cfg(wcn, WCN36XX_HAL_CFG_RTS_THRESHOLD, value); |
| 976 |
mutex_unlock(&wcn->conf_mutex); |
| 977 |
|
| 978 |
return 0; |
| 979 |
} |
| 980 |
|
| 981 |
static void wcn36xx_remove_interface(struct ieee80211_hw *hw, |
| 982 |
struct ieee80211_vif *vif) |
| 983 |
{ |
| 984 |
struct wcn36xx *wcn = hw->priv; |
| 985 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 986 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac remove interface vif %p\n", vif); |
| 987 |
|
| 988 |
mutex_lock(&wcn->conf_mutex); |
| 989 |
|
| 990 |
list_del(&vif_priv->list); |
| 991 |
wcn36xx_smd_delete_sta_self(wcn, vif->addr); |
| 992 |
|
| 993 |
mutex_unlock(&wcn->conf_mutex); |
| 994 |
} |
| 995 |
|
| 996 |
static int wcn36xx_add_interface(struct ieee80211_hw *hw, |
| 997 |
struct ieee80211_vif *vif) |
| 998 |
{ |
| 999 |
struct wcn36xx *wcn = hw->priv; |
| 1000 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 1001 |
|
| 1002 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac add interface vif %p type %d\n", |
| 1003 |
vif, vif->type); |
| 1004 |
|
| 1005 |
if (!(NL80211_IFTYPE_STATION == vif->type || |
| 1006 |
NL80211_IFTYPE_AP == vif->type || |
| 1007 |
NL80211_IFTYPE_ADHOC == vif->type || |
| 1008 |
NL80211_IFTYPE_MESH_POINT == vif->type)) { |
| 1009 |
wcn36xx_warn("Unsupported interface type requested: %d\n", |
| 1010 |
vif->type); |
| 1011 |
return -EOPNOTSUPP; |
| 1012 |
} |
| 1013 |
|
| 1014 |
mutex_lock(&wcn->conf_mutex); |
| 1015 |
|
| 1016 |
vif_priv->bss_index = WCN36XX_HAL_BSS_INVALID_IDX; |
| 1017 |
INIT_LIST_HEAD(&vif_priv->sta_list); |
| 1018 |
list_add(&vif_priv->list, &wcn->vif_list); |
| 1019 |
wcn36xx_smd_add_sta_self(wcn, vif); |
| 1020 |
|
| 1021 |
mutex_unlock(&wcn->conf_mutex); |
| 1022 |
|
| 1023 |
return 0; |
| 1024 |
} |
| 1025 |
|
| 1026 |
static int wcn36xx_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| 1027 |
struct ieee80211_sta *sta) |
| 1028 |
{ |
| 1029 |
struct wcn36xx *wcn = hw->priv; |
| 1030 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 1031 |
struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta); |
| 1032 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac sta add vif %p sta %pM\n", |
| 1033 |
vif, sta->addr); |
| 1034 |
|
| 1035 |
mutex_lock(&wcn->conf_mutex); |
| 1036 |
|
| 1037 |
spin_lock_init(&sta_priv->ampdu_lock); |
| 1038 |
sta_priv->vif = vif_priv; |
| 1039 |
list_add(&sta_priv->list, &vif_priv->sta_list); |
| 1040 |
|
| 1041 |
/* |
| 1042 |
* For STA mode HW will be configured on BSS_CHANGED_ASSOC because |
| 1043 |
* at this stage AID is not available yet. |
| 1044 |
*/ |
| 1045 |
if (NL80211_IFTYPE_STATION != vif->type) { |
| 1046 |
wcn36xx_update_allowed_rates(sta, WCN36XX_BAND(wcn)); |
| 1047 |
sta_priv->aid = sta->aid; |
| 1048 |
wcn36xx_smd_config_sta(wcn, vif, sta); |
| 1049 |
} |
| 1050 |
|
| 1051 |
mutex_unlock(&wcn->conf_mutex); |
| 1052 |
|
| 1053 |
return 0; |
| 1054 |
} |
| 1055 |
|
| 1056 |
static int wcn36xx_sta_remove(struct ieee80211_hw *hw, |
| 1057 |
struct ieee80211_vif *vif, |
| 1058 |
struct ieee80211_sta *sta) |
| 1059 |
{ |
| 1060 |
struct wcn36xx *wcn = hw->priv; |
| 1061 |
struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta); |
| 1062 |
|
| 1063 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac sta remove vif %p sta %pM index %d\n", |
| 1064 |
vif, sta->addr, sta_priv->sta_index); |
| 1065 |
|
| 1066 |
mutex_lock(&wcn->conf_mutex); |
| 1067 |
|
| 1068 |
list_del(&sta_priv->list); |
| 1069 |
wcn36xx_smd_delete_sta(wcn, sta_priv->sta_index); |
| 1070 |
sta_priv->vif = NULL; |
| 1071 |
|
| 1072 |
mutex_unlock(&wcn->conf_mutex); |
| 1073 |
|
| 1074 |
return 0; |
| 1075 |
} |
| 1076 |
|
| 1077 |
#ifdef CONFIG_PM |
| 1078 |
|
| 1079 |
static struct ieee80211_vif *wcn36xx_get_first_assoc_vif(struct wcn36xx *wcn) |
| 1080 |
{ |
| 1081 |
struct wcn36xx_vif *vif_priv = NULL; |
| 1082 |
struct ieee80211_vif *vif = NULL; |
| 1083 |
|
| 1084 |
list_for_each_entry(vif_priv, &wcn->vif_list, list) { |
| 1085 |
if (vif_priv->sta_assoc) { |
| 1086 |
vif = wcn36xx_priv_to_vif(vif_priv); |
| 1087 |
break; |
| 1088 |
} |
| 1089 |
} |
| 1090 |
return vif; |
| 1091 |
} |
| 1092 |
|
| 1093 |
static int wcn36xx_suspend(struct ieee80211_hw *hw, struct cfg80211_wowlan *wow) |
| 1094 |
{ |
| 1095 |
struct wcn36xx *wcn = hw->priv; |
| 1096 |
struct ieee80211_vif *vif = NULL; |
| 1097 |
int ret = 0; |
| 1098 |
|
| 1099 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac suspend\n"); |
| 1100 |
|
| 1101 |
mutex_lock(&wcn->conf_mutex); |
| 1102 |
|
| 1103 |
vif = wcn36xx_get_first_assoc_vif(wcn); |
| 1104 |
if (vif) { |
| 1105 |
ret = wcn36xx_smd_arp_offload(wcn, vif, true); |
| 1106 |
if (ret) |
| 1107 |
goto out; |
| 1108 |
ret = wcn36xx_smd_ipv6_ns_offload(wcn, vif, true); |
| 1109 |
if (ret) |
| 1110 |
goto out; |
| 1111 |
ret = wcn36xx_smd_gtk_offload(wcn, vif, true); |
| 1112 |
if (ret) |
| 1113 |
goto out; |
| 1114 |
ret = wcn36xx_smd_set_power_params(wcn, true); |
| 1115 |
if (ret) |
| 1116 |
goto out; |
| 1117 |
ret = wcn36xx_smd_wlan_host_suspend_ind(wcn); |
| 1118 |
} |
| 1119 |
|
| 1120 |
/* Disable IRQ, we don't want to handle any packet before mac80211 is |
| 1121 |
* resumed and ready to receive packets. |
| 1122 |
*/ |
| 1123 |
disable_irq(wcn->tx_irq); |
| 1124 |
disable_irq(wcn->rx_irq); |
| 1125 |
|
| 1126 |
out: |
| 1127 |
mutex_unlock(&wcn->conf_mutex); |
| 1128 |
return ret; |
| 1129 |
} |
| 1130 |
|
| 1131 |
static int wcn36xx_resume(struct ieee80211_hw *hw) |
| 1132 |
{ |
| 1133 |
struct wcn36xx *wcn = hw->priv; |
| 1134 |
struct ieee80211_vif *vif = NULL; |
| 1135 |
|
| 1136 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac resume\n"); |
| 1137 |
|
| 1138 |
mutex_lock(&wcn->conf_mutex); |
| 1139 |
vif = wcn36xx_get_first_assoc_vif(wcn); |
| 1140 |
if (vif) { |
| 1141 |
wcn36xx_smd_host_resume(wcn); |
| 1142 |
wcn36xx_smd_set_power_params(wcn, false); |
| 1143 |
wcn36xx_smd_gtk_offload_get_info(wcn, vif); |
| 1144 |
wcn36xx_smd_gtk_offload(wcn, vif, false); |
| 1145 |
wcn36xx_smd_ipv6_ns_offload(wcn, vif, false); |
| 1146 |
wcn36xx_smd_arp_offload(wcn, vif, false); |
| 1147 |
} |
| 1148 |
|
| 1149 |
enable_irq(wcn->tx_irq); |
| 1150 |
enable_irq(wcn->rx_irq); |
| 1151 |
|
| 1152 |
mutex_unlock(&wcn->conf_mutex); |
| 1153 |
|
| 1154 |
return 0; |
| 1155 |
} |
| 1156 |
|
| 1157 |
static void wcn36xx_set_rekey_data(struct ieee80211_hw *hw, |
| 1158 |
struct ieee80211_vif *vif, |
| 1159 |
struct cfg80211_gtk_rekey_data *data) |
| 1160 |
{ |
| 1161 |
struct wcn36xx *wcn = hw->priv; |
| 1162 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 1163 |
|
| 1164 |
mutex_lock(&wcn->conf_mutex); |
| 1165 |
|
| 1166 |
memcpy(vif_priv->rekey_data.kek, data->kek, NL80211_KEK_LEN); |
| 1167 |
memcpy(vif_priv->rekey_data.kck, data->kck, NL80211_KCK_LEN); |
| 1168 |
vif_priv->rekey_data.replay_ctr = |
| 1169 |
cpu_to_le64(be64_to_cpup((__be64 *)data->replay_ctr)); |
| 1170 |
vif_priv->rekey_data.valid = true; |
| 1171 |
|
| 1172 |
mutex_unlock(&wcn->conf_mutex); |
| 1173 |
} |
| 1174 |
|
| 1175 |
#endif |
| 1176 |
|
| 1177 |
static int wcn36xx_ampdu_action(struct ieee80211_hw *hw, |
| 1178 |
struct ieee80211_vif *vif, |
| 1179 |
struct ieee80211_ampdu_params *params) |
| 1180 |
{ |
| 1181 |
struct wcn36xx *wcn = hw->priv; |
| 1182 |
struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(params->sta); |
| 1183 |
struct ieee80211_sta *sta = params->sta; |
| 1184 |
enum ieee80211_ampdu_mlme_action action = params->action; |
| 1185 |
u16 tid = params->tid; |
| 1186 |
u16 *ssn = ¶ms->ssn; |
| 1187 |
int ret = 0; |
| 1188 |
int session; |
| 1189 |
|
| 1190 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac ampdu action action %d tid %d\n", |
| 1191 |
action, tid); |
| 1192 |
|
| 1193 |
mutex_lock(&wcn->conf_mutex); |
| 1194 |
|
| 1195 |
switch (action) { |
| 1196 |
case IEEE80211_AMPDU_RX_START: |
| 1197 |
sta_priv->tid = tid; |
| 1198 |
session = wcn36xx_smd_add_ba_session(wcn, sta, tid, ssn, 0, |
| 1199 |
get_sta_index(vif, sta_priv)); |
| 1200 |
if (session < 0) { |
| 1201 |
ret = session; |
| 1202 |
goto out; |
| 1203 |
} |
| 1204 |
wcn36xx_smd_add_ba(wcn, session); |
| 1205 |
break; |
| 1206 |
case IEEE80211_AMPDU_RX_STOP: |
| 1207 |
wcn36xx_smd_del_ba(wcn, tid, 0, get_sta_index(vif, sta_priv)); |
| 1208 |
break; |
| 1209 |
case IEEE80211_AMPDU_TX_START: |
| 1210 |
spin_lock_bh(&sta_priv->ampdu_lock); |
| 1211 |
sta_priv->ampdu_state[tid] = WCN36XX_AMPDU_START; |
| 1212 |
spin_unlock_bh(&sta_priv->ampdu_lock); |
| 1213 |
|
| 1214 |
/* Replace the mac80211 ssn with the firmware one */ |
| 1215 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac ampdu ssn = %u\n", *ssn); |
| 1216 |
wcn36xx_smd_trigger_ba(wcn, get_sta_index(vif, sta_priv), tid, ssn); |
| 1217 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "mac ampdu fw-ssn = %u\n", *ssn); |
| 1218 |
|
| 1219 |
/* Start BA session */ |
| 1220 |
session = wcn36xx_smd_add_ba_session(wcn, sta, tid, ssn, 1, |
| 1221 |
get_sta_index(vif, sta_priv)); |
| 1222 |
if (session < 0) { |
| 1223 |
ret = session; |
| 1224 |
goto out; |
| 1225 |
} |
| 1226 |
ret = IEEE80211_AMPDU_TX_START_IMMEDIATE; |
| 1227 |
break; |
| 1228 |
case IEEE80211_AMPDU_TX_OPERATIONAL: |
| 1229 |
spin_lock_bh(&sta_priv->ampdu_lock); |
| 1230 |
sta_priv->ampdu_state[tid] = WCN36XX_AMPDU_OPERATIONAL; |
| 1231 |
spin_unlock_bh(&sta_priv->ampdu_lock); |
| 1232 |
|
| 1233 |
break; |
| 1234 |
case IEEE80211_AMPDU_TX_STOP_FLUSH: |
| 1235 |
case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: |
| 1236 |
case IEEE80211_AMPDU_TX_STOP_CONT: |
| 1237 |
spin_lock_bh(&sta_priv->ampdu_lock); |
| 1238 |
sta_priv->ampdu_state[tid] = WCN36XX_AMPDU_NONE; |
| 1239 |
spin_unlock_bh(&sta_priv->ampdu_lock); |
| 1240 |
|
| 1241 |
wcn36xx_smd_del_ba(wcn, tid, 1, get_sta_index(vif, sta_priv)); |
| 1242 |
ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); |
| 1243 |
break; |
| 1244 |
default: |
| 1245 |
wcn36xx_err("Unknown AMPDU action\n"); |
| 1246 |
} |
| 1247 |
|
| 1248 |
out: |
| 1249 |
mutex_unlock(&wcn->conf_mutex); |
| 1250 |
|
| 1251 |
return ret; |
| 1252 |
} |
| 1253 |
|
| 1254 |
#if IS_ENABLED(CONFIG_IPV6) |
| 1255 |
static void wcn36xx_ipv6_addr_change(struct ieee80211_hw *hw, |
| 1256 |
struct ieee80211_vif *vif, |
| 1257 |
struct inet6_dev *idev) |
| 1258 |
{ |
| 1259 |
struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif); |
| 1260 |
struct inet6_ifaddr *ifa; |
| 1261 |
int idx = 0; |
| 1262 |
|
| 1263 |
memset(vif_priv->tentative_addrs, 0, sizeof(vif_priv->tentative_addrs)); |
| 1264 |
|
| 1265 |
read_lock_bh(&idev->lock); |
| 1266 |
list_for_each_entry(ifa, &idev->addr_list, if_list) { |
| 1267 |
vif_priv->target_ipv6_addrs[idx] = ifa->addr; |
| 1268 |
if (ifa->flags & IFA_F_TENTATIVE) |
| 1269 |
__set_bit(idx, vif_priv->tentative_addrs); |
| 1270 |
idx++; |
| 1271 |
if (idx >= WCN36XX_HAL_IPV6_OFFLOAD_ADDR_MAX) |
| 1272 |
break; |
| 1273 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "%pI6 %s\n", &ifa->addr, |
| 1274 |
(ifa->flags & IFA_F_TENTATIVE) ? "tentative" : NULL); |
| 1275 |
} |
| 1276 |
read_unlock_bh(&idev->lock); |
| 1277 |
|
| 1278 |
vif_priv->num_target_ipv6_addrs = idx; |
| 1279 |
} |
| 1280 |
#endif |
| 1281 |
|
| 1282 |
static void wcn36xx_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| 1283 |
u32 queues, bool drop) |
| 1284 |
{ |
| 1285 |
struct wcn36xx *wcn = hw->priv; |
| 1286 |
|
| 1287 |
if (wcn36xx_dxe_tx_flush(wcn)) { |
| 1288 |
wcn36xx_err("Failed to flush hardware tx queues\n"); |
| 1289 |
} |
| 1290 |
} |
| 1291 |
|
| 1292 |
static int wcn36xx_get_survey(struct ieee80211_hw *hw, int idx, |
| 1293 |
struct survey_info *survey) |
| 1294 |
{ |
| 1295 |
struct wcn36xx *wcn = hw->priv; |
| 1296 |
struct ieee80211_supported_band *sband; |
| 1297 |
struct wcn36xx_chan_survey *chan_survey; |
| 1298 |
int band_idx; |
| 1299 |
unsigned long flags; |
| 1300 |
|
| 1301 |
sband = wcn->hw->wiphy->bands[NL80211_BAND_2GHZ]; |
| 1302 |
band_idx = idx; |
| 1303 |
if (band_idx >= sband->n_channels) { |
| 1304 |
band_idx -= sband->n_channels; |
| 1305 |
sband = wcn->hw->wiphy->bands[NL80211_BAND_5GHZ]; |
| 1306 |
} |
| 1307 |
|
| 1308 |
if (!sband || band_idx >= sband->n_channels) |
| 1309 |
return -ENOENT; |
| 1310 |
|
| 1311 |
spin_lock_irqsave(&wcn->survey_lock, flags); |
| 1312 |
|
| 1313 |
chan_survey = &wcn->chan_survey[idx]; |
| 1314 |
survey->channel = &sband->channels[band_idx]; |
| 1315 |
survey->noise = chan_survey->rssi - chan_survey->snr; |
| 1316 |
survey->filled = 0; |
| 1317 |
|
| 1318 |
if (chan_survey->rssi > -100 && chan_survey->rssi < 0) |
| 1319 |
survey->filled |= SURVEY_INFO_NOISE_DBM; |
| 1320 |
|
| 1321 |
if (survey->channel == wcn->channel) |
| 1322 |
survey->filled |= SURVEY_INFO_IN_USE; |
| 1323 |
|
| 1324 |
spin_unlock_irqrestore(&wcn->survey_lock, flags); |
| 1325 |
|
| 1326 |
wcn36xx_dbg(WCN36XX_DBG_MAC, |
| 1327 |
"ch %d rssi %d snr %d noise %d filled %x freq %d\n", |
| 1328 |
HW_VALUE_CHANNEL(survey->channel->hw_value), |
| 1329 |
chan_survey->rssi, chan_survey->snr, survey->noise, |
| 1330 |
survey->filled, survey->channel->center_freq); |
| 1331 |
|
| 1332 |
return 0; |
| 1333 |
} |
| 1334 |
|
| 1335 |
static void wcn36xx_sta_statistics(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| 1336 |
struct ieee80211_sta *sta, struct station_info *sinfo) |
| 1337 |
{ |
| 1338 |
struct wcn36xx *wcn; |
| 1339 |
u8 sta_index; |
| 1340 |
int status; |
| 1341 |
|
| 1342 |
wcn = hw->priv; |
| 1343 |
sta_index = get_sta_index(vif, wcn36xx_sta_to_priv(sta)); |
| 1344 |
status = wcn36xx_smd_get_stats(wcn, sta_index, HAL_GLOBAL_CLASS_A_STATS_INFO, sinfo); |
| 1345 |
|
| 1346 |
if (status) |
| 1347 |
wcn36xx_err("wcn36xx_smd_get_stats failed\n"); |
| 1348 |
} |
| 1349 |
|
| 1350 |
static const struct ieee80211_ops wcn36xx_ops = { |
| 1351 |
.add_chanctx = ieee80211_emulate_add_chanctx, |
| 1352 |
.remove_chanctx = ieee80211_emulate_remove_chanctx, |
| 1353 |
.change_chanctx = ieee80211_emulate_change_chanctx, |
| 1354 |
.switch_vif_chanctx = ieee80211_emulate_switch_vif_chanctx, |
| 1355 |
.start = wcn36xx_start, |
| 1356 |
.stop = wcn36xx_stop, |
| 1357 |
.add_interface = wcn36xx_add_interface, |
| 1358 |
.remove_interface = wcn36xx_remove_interface, |
| 1359 |
#ifdef CONFIG_PM |
| 1360 |
.suspend = wcn36xx_suspend, |
| 1361 |
.resume = wcn36xx_resume, |
| 1362 |
.set_rekey_data = wcn36xx_set_rekey_data, |
| 1363 |
#endif |
| 1364 |
.config = wcn36xx_config, |
| 1365 |
.prepare_multicast = wcn36xx_prepare_multicast, |
| 1366 |
.configure_filter = wcn36xx_configure_filter, |
| 1367 |
.tx = wcn36xx_tx, |
| 1368 |
.wake_tx_queue = ieee80211_handle_wake_tx_queue, |
| 1369 |
.set_key = wcn36xx_set_key, |
| 1370 |
.hw_scan = wcn36xx_hw_scan, |
| 1371 |
.cancel_hw_scan = wcn36xx_cancel_hw_scan, |
| 1372 |
.sw_scan_start = wcn36xx_sw_scan_start, |
| 1373 |
.sw_scan_complete = wcn36xx_sw_scan_complete, |
| 1374 |
.bss_info_changed = wcn36xx_bss_info_changed, |
| 1375 |
.set_rts_threshold = wcn36xx_set_rts_threshold, |
| 1376 |
.sta_add = wcn36xx_sta_add, |
| 1377 |
.sta_remove = wcn36xx_sta_remove, |
| 1378 |
.sta_statistics = wcn36xx_sta_statistics, |
| 1379 |
.ampdu_action = wcn36xx_ampdu_action, |
| 1380 |
#if IS_ENABLED(CONFIG_IPV6) |
| 1381 |
.ipv6_addr_change = wcn36xx_ipv6_addr_change, |
| 1382 |
#endif |
| 1383 |
.flush = wcn36xx_flush, |
| 1384 |
.get_survey = wcn36xx_get_survey, |
| 1385 |
|
| 1386 |
CFG80211_TESTMODE_CMD(wcn36xx_tm_cmd) |
| 1387 |
}; |
| 1388 |
|
| 1389 |
static void |
| 1390 |
wcn36xx_set_ieee80211_vht_caps(struct ieee80211_sta_vht_cap *vht_cap) |
| 1391 |
{ |
| 1392 |
vht_cap->vht_supported = true; |
| 1393 |
|
| 1394 |
vht_cap->cap = (IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895 | |
| 1395 |
IEEE80211_VHT_CAP_SHORT_GI_80 | |
| 1396 |
IEEE80211_VHT_CAP_RXSTBC_1 | |
| 1397 |
IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | |
| 1398 |
IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE | |
| 1399 |
3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT | |
| 1400 |
7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT); |
| 1401 |
|
| 1402 |
vht_cap->vht_mcs.rx_mcs_map = |
| 1403 |
cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 | |
| 1404 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 2 | |
| 1405 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 | |
| 1406 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 | |
| 1407 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 | |
| 1408 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 | |
| 1409 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 | |
| 1410 |
IEEE80211_VHT_MCS_NOT_SUPPORTED << 14); |
| 1411 |
|
| 1412 |
vht_cap->vht_mcs.rx_highest = cpu_to_le16(433); |
| 1413 |
vht_cap->vht_mcs.tx_highest = vht_cap->vht_mcs.rx_highest; |
| 1414 |
|
| 1415 |
vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map; |
| 1416 |
} |
| 1417 |
|
| 1418 |
static int wcn36xx_init_ieee80211(struct wcn36xx *wcn) |
| 1419 |
{ |
| 1420 |
static const u32 cipher_suites[] = { |
| 1421 |
WLAN_CIPHER_SUITE_WEP40, |
| 1422 |
WLAN_CIPHER_SUITE_WEP104, |
| 1423 |
WLAN_CIPHER_SUITE_TKIP, |
| 1424 |
WLAN_CIPHER_SUITE_CCMP, |
| 1425 |
}; |
| 1426 |
|
| 1427 |
ieee80211_hw_set(wcn->hw, TIMING_BEACON_ONLY); |
| 1428 |
ieee80211_hw_set(wcn->hw, AMPDU_AGGREGATION); |
| 1429 |
ieee80211_hw_set(wcn->hw, SUPPORTS_PS); |
| 1430 |
ieee80211_hw_set(wcn->hw, SIGNAL_DBM); |
| 1431 |
ieee80211_hw_set(wcn->hw, HAS_RATE_CONTROL); |
| 1432 |
ieee80211_hw_set(wcn->hw, SINGLE_SCAN_ON_ALL_BANDS); |
| 1433 |
ieee80211_hw_set(wcn->hw, REPORTS_TX_ACK_STATUS); |
| 1434 |
|
| 1435 |
wcn->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | |
| 1436 |
BIT(NL80211_IFTYPE_AP) | |
| 1437 |
BIT(NL80211_IFTYPE_ADHOC) | |
| 1438 |
BIT(NL80211_IFTYPE_MESH_POINT); |
| 1439 |
|
| 1440 |
wcn->hw->wiphy->bands[NL80211_BAND_2GHZ] = &wcn_band_2ghz; |
| 1441 |
if (wcn->rf_id != RF_IRIS_WCN3620) |
| 1442 |
wcn->hw->wiphy->bands[NL80211_BAND_5GHZ] = &wcn_band_5ghz; |
| 1443 |
|
| 1444 |
if (wcn->rf_id == RF_IRIS_WCN3680) |
| 1445 |
wcn36xx_set_ieee80211_vht_caps(&wcn_band_5ghz.vht_cap); |
| 1446 |
|
| 1447 |
wcn->hw->wiphy->max_scan_ssids = WCN36XX_MAX_SCAN_SSIDS; |
| 1448 |
wcn->hw->wiphy->max_scan_ie_len = WCN36XX_MAX_SCAN_IE_LEN; |
| 1449 |
|
| 1450 |
wcn->hw->wiphy->cipher_suites = cipher_suites; |
| 1451 |
wcn->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); |
| 1452 |
|
| 1453 |
#ifdef CONFIG_PM |
| 1454 |
wcn->hw->wiphy->wowlan = &wowlan_support; |
| 1455 |
#endif |
| 1456 |
|
| 1457 |
wcn->hw->max_listen_interval = 200; |
| 1458 |
|
| 1459 |
wcn->hw->queues = 4; |
| 1460 |
|
| 1461 |
SET_IEEE80211_DEV(wcn->hw, wcn->dev); |
| 1462 |
|
| 1463 |
wcn->hw->sta_data_size = sizeof(struct wcn36xx_sta); |
| 1464 |
wcn->hw->vif_data_size = sizeof(struct wcn36xx_vif); |
| 1465 |
|
| 1466 |
wiphy_ext_feature_set(wcn->hw->wiphy, |
| 1467 |
NL80211_EXT_FEATURE_CQM_RSSI_LIST); |
| 1468 |
|
| 1469 |
return 0; |
| 1470 |
} |
| 1471 |
|
| 1472 |
static int wcn36xx_platform_get_resources(struct wcn36xx *wcn, |
| 1473 |
struct platform_device *pdev) |
| 1474 |
{ |
| 1475 |
struct device_node *mmio_node; |
| 1476 |
struct device_node *iris_node; |
| 1477 |
int index; |
| 1478 |
int ret; |
| 1479 |
|
| 1480 |
/* Set TX IRQ */ |
| 1481 |
ret = platform_get_irq_byname(pdev, "tx"); |
| 1482 |
if (ret < 0) |
| 1483 |
return ret; |
| 1484 |
wcn->tx_irq = ret; |
| 1485 |
|
| 1486 |
/* Set RX IRQ */ |
| 1487 |
ret = platform_get_irq_byname(pdev, "rx"); |
| 1488 |
if (ret < 0) |
| 1489 |
return ret; |
| 1490 |
wcn->rx_irq = ret; |
| 1491 |
|
| 1492 |
/* Acquire SMSM tx enable handle */ |
| 1493 |
wcn->tx_enable_state = qcom_smem_state_get(&pdev->dev, |
| 1494 |
"tx-enable", &wcn->tx_enable_state_bit); |
| 1495 |
if (IS_ERR(wcn->tx_enable_state)) { |
| 1496 |
wcn36xx_err("failed to get tx-enable state\n"); |
| 1497 |
return PTR_ERR(wcn->tx_enable_state); |
| 1498 |
} |
| 1499 |
|
| 1500 |
/* Acquire SMSM tx rings empty handle */ |
| 1501 |
wcn->tx_rings_empty_state = qcom_smem_state_get(&pdev->dev, |
| 1502 |
"tx-rings-empty", &wcn->tx_rings_empty_state_bit); |
| 1503 |
if (IS_ERR(wcn->tx_rings_empty_state)) { |
| 1504 |
wcn36xx_err("failed to get tx-rings-empty state\n"); |
| 1505 |
return PTR_ERR(wcn->tx_rings_empty_state); |
| 1506 |
} |
| 1507 |
|
| 1508 |
mmio_node = of_parse_phandle(pdev->dev.parent->of_node, "qcom,mmio", 0); |
| 1509 |
if (!mmio_node) { |
| 1510 |
wcn36xx_err("failed to acquire qcom,mmio reference\n"); |
| 1511 |
return -EINVAL; |
| 1512 |
} |
| 1513 |
|
| 1514 |
wcn->is_pronto = !!of_device_is_compatible(mmio_node, "qcom,pronto"); |
| 1515 |
wcn->is_pronto_v3 = !!of_device_is_compatible(mmio_node, "qcom,pronto-v3-pil"); |
| 1516 |
|
| 1517 |
/* Map the CCU memory */ |
| 1518 |
index = of_property_match_string(mmio_node, "reg-names", "ccu"); |
| 1519 |
wcn->ccu_base = of_iomap(mmio_node, index); |
| 1520 |
if (!wcn->ccu_base) { |
| 1521 |
wcn36xx_err("failed to map ccu memory\n"); |
| 1522 |
ret = -ENOMEM; |
| 1523 |
goto put_mmio_node; |
| 1524 |
} |
| 1525 |
|
| 1526 |
/* Map the DXE memory */ |
| 1527 |
index = of_property_match_string(mmio_node, "reg-names", "dxe"); |
| 1528 |
wcn->dxe_base = of_iomap(mmio_node, index); |
| 1529 |
if (!wcn->dxe_base) { |
| 1530 |
wcn36xx_err("failed to map dxe memory\n"); |
| 1531 |
ret = -ENOMEM; |
| 1532 |
goto unmap_ccu; |
| 1533 |
} |
| 1534 |
|
| 1535 |
/* External RF module */ |
| 1536 |
iris_node = of_get_child_by_name(mmio_node, "iris"); |
| 1537 |
if (iris_node) { |
| 1538 |
if (of_device_is_compatible(iris_node, "qcom,wcn3620")) |
| 1539 |
wcn->rf_id = RF_IRIS_WCN3620; |
| 1540 |
if (of_device_is_compatible(iris_node, "qcom,wcn3660") || |
| 1541 |
of_device_is_compatible(iris_node, "qcom,wcn3660b")) |
| 1542 |
wcn->rf_id = RF_IRIS_WCN3660; |
| 1543 |
if (of_device_is_compatible(iris_node, "qcom,wcn3680")) |
| 1544 |
wcn->rf_id = RF_IRIS_WCN3680; |
| 1545 |
of_node_put(iris_node); |
| 1546 |
} |
| 1547 |
|
| 1548 |
of_node_put(mmio_node); |
| 1549 |
return 0; |
| 1550 |
|
| 1551 |
unmap_ccu: |
| 1552 |
iounmap(wcn->ccu_base); |
| 1553 |
put_mmio_node: |
| 1554 |
of_node_put(mmio_node); |
| 1555 |
return ret; |
| 1556 |
} |
| 1557 |
|
| 1558 |
static int wcn36xx_probe(struct platform_device *pdev) |
| 1559 |
{ |
| 1560 |
struct ieee80211_hw *hw; |
| 1561 |
struct wcn36xx *wcn; |
| 1562 |
void *wcnss; |
| 1563 |
int ret; |
| 1564 |
const u8 *addr; |
| 1565 |
int n_channels; |
| 1566 |
|
| 1567 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "platform probe\n"); |
| 1568 |
|
| 1569 |
wcnss = dev_get_drvdata(pdev->dev.parent); |
| 1570 |
|
| 1571 |
hw = ieee80211_alloc_hw(sizeof(struct wcn36xx), &wcn36xx_ops); |
| 1572 |
if (!hw) { |
| 1573 |
wcn36xx_err("failed to alloc hw\n"); |
| 1574 |
ret = -ENOMEM; |
| 1575 |
goto out_err; |
| 1576 |
} |
| 1577 |
platform_set_drvdata(pdev, hw); |
| 1578 |
wcn = hw->priv; |
| 1579 |
wcn->hw = hw; |
| 1580 |
wcn->dev = &pdev->dev; |
| 1581 |
wcn->first_boot = true; |
| 1582 |
mutex_init(&wcn->conf_mutex); |
| 1583 |
mutex_init(&wcn->hal_mutex); |
| 1584 |
mutex_init(&wcn->scan_lock); |
| 1585 |
__skb_queue_head_init(&wcn->amsdu); |
| 1586 |
|
| 1587 |
wcn->hal_buf = devm_kmalloc(wcn->dev, WCN36XX_HAL_BUF_SIZE, GFP_KERNEL); |
| 1588 |
if (!wcn->hal_buf) { |
| 1589 |
ret = -ENOMEM; |
| 1590 |
goto out_wq; |
| 1591 |
} |
| 1592 |
|
| 1593 |
n_channels = wcn_band_2ghz.n_channels + wcn_band_5ghz.n_channels; |
| 1594 |
wcn->chan_survey = devm_kcalloc(wcn->dev, |
| 1595 |
n_channels, |
| 1596 |
sizeof(struct wcn36xx_chan_survey), |
| 1597 |
GFP_KERNEL); |
| 1598 |
if (!wcn->chan_survey) { |
| 1599 |
ret = -ENOMEM; |
| 1600 |
goto out_wq; |
| 1601 |
} |
| 1602 |
|
| 1603 |
ret = dma_set_mask_and_coherent(wcn->dev, DMA_BIT_MASK(32)); |
| 1604 |
if (ret < 0) { |
| 1605 |
wcn36xx_err("failed to set DMA mask: %d\n", ret); |
| 1606 |
goto out_wq; |
| 1607 |
} |
| 1608 |
|
| 1609 |
wcn->nv_file = WLAN_NV_FILE; |
| 1610 |
ret = of_property_read_string(wcn->dev->parent->of_node, "firmware-name", &wcn->nv_file); |
| 1611 |
if (ret < 0 && ret != -EINVAL) { |
| 1612 |
wcn36xx_err("failed to read \"firmware-name\" property: %d\n", ret); |
| 1613 |
goto out_wq; |
| 1614 |
} |
| 1615 |
|
| 1616 |
wcn->smd_channel = qcom_wcnss_open_channel(wcnss, "WLAN_CTRL", wcn36xx_smd_rsp_process, hw); |
| 1617 |
if (IS_ERR(wcn->smd_channel)) { |
| 1618 |
wcn36xx_err("failed to open WLAN_CTRL channel\n"); |
| 1619 |
ret = PTR_ERR(wcn->smd_channel); |
| 1620 |
goto out_wq; |
| 1621 |
} |
| 1622 |
|
| 1623 |
addr = of_get_property(pdev->dev.of_node, "local-mac-address", &ret); |
| 1624 |
if (addr && ret != ETH_ALEN) { |
| 1625 |
wcn36xx_err("invalid local-mac-address\n"); |
| 1626 |
ret = -EINVAL; |
| 1627 |
goto out_destroy_ept; |
| 1628 |
} else if (addr) { |
| 1629 |
wcn36xx_info("mac address: %pM\n", addr); |
| 1630 |
SET_IEEE80211_PERM_ADDR(wcn->hw, addr); |
| 1631 |
} |
| 1632 |
|
| 1633 |
ret = wcn36xx_platform_get_resources(wcn, pdev); |
| 1634 |
if (ret) |
| 1635 |
goto out_destroy_ept; |
| 1636 |
|
| 1637 |
wcn36xx_init_ieee80211(wcn); |
| 1638 |
ret = ieee80211_register_hw(wcn->hw); |
| 1639 |
if (ret) |
| 1640 |
goto out_unmap; |
| 1641 |
|
| 1642 |
return 0; |
| 1643 |
|
| 1644 |
out_unmap: |
| 1645 |
iounmap(wcn->ccu_base); |
| 1646 |
iounmap(wcn->dxe_base); |
| 1647 |
out_destroy_ept: |
| 1648 |
rpmsg_destroy_ept(wcn->smd_channel); |
| 1649 |
out_wq: |
| 1650 |
ieee80211_free_hw(hw); |
| 1651 |
out_err: |
| 1652 |
return ret; |
| 1653 |
} |
| 1654 |
|
| 1655 |
static void wcn36xx_remove(struct platform_device *pdev) |
| 1656 |
{ |
| 1657 |
struct ieee80211_hw *hw = platform_get_drvdata(pdev); |
| 1658 |
struct wcn36xx *wcn = hw->priv; |
| 1659 |
wcn36xx_dbg(WCN36XX_DBG_MAC, "platform remove\n"); |
| 1660 |
|
| 1661 |
release_firmware(wcn->nv); |
| 1662 |
|
| 1663 |
ieee80211_unregister_hw(hw); |
| 1664 |
|
| 1665 |
qcom_smem_state_put(wcn->tx_enable_state); |
| 1666 |
qcom_smem_state_put(wcn->tx_rings_empty_state); |
| 1667 |
|
| 1668 |
rpmsg_destroy_ept(wcn->smd_channel); |
| 1669 |
|
| 1670 |
iounmap(wcn->dxe_base); |
| 1671 |
iounmap(wcn->ccu_base); |
| 1672 |
|
| 1673 |
__skb_queue_purge(&wcn->amsdu); |
| 1674 |
|
| 1675 |
mutex_destroy(&wcn->hal_mutex); |
| 1676 |
ieee80211_free_hw(hw); |
| 1677 |
} |
| 1678 |
|
| 1679 |
static const struct of_device_id wcn36xx_of_match[] = { |
| 1680 |
{ .compatible = "qcom,wcnss-wlan" }, |
| 1681 |
{} |
| 1682 |
}; |
| 1683 |
MODULE_DEVICE_TABLE(of, wcn36xx_of_match); |
| 1684 |
|
| 1685 |
static struct platform_driver wcn36xx_driver = { |
| 1686 |
.probe = wcn36xx_probe, |
| 1687 |
.remove = wcn36xx_remove, |
| 1688 |
.driver = { |
| 1689 |
.name = "wcn36xx", |
| 1690 |
.of_match_table = wcn36xx_of_match, |
| 1691 |
}, |
| 1692 |
}; |
| 1693 |
|
| 1694 |
module_platform_driver(wcn36xx_driver); |
| 1695 |
|
| 1696 |
MODULE_DESCRIPTION("Qualcomm Atheros WCN3660/3680 wireless driver"); |
| 1697 |
MODULE_LICENSE("Dual BSD/GPL"); |
| 1698 |
MODULE_AUTHOR("Eugene Krasnikov [email protected]"); |
| 1699 |
MODULE_FIRMWARE(WLAN_NV_FILE); |