| 1 |
// SPDX-License-Identifier: GPL-2.0-only |
| 2 |
/* |
| 3 |
* NXP Wireless LAN device driver: station event handling |
| 4 |
* |
| 5 |
* Copyright 2011-2020 NXP |
| 6 |
*/ |
| 7 |
|
| 8 |
#include "decl.h" |
| 9 |
#include "ioctl.h" |
| 10 |
#include "util.h" |
| 11 |
#include "fw.h" |
| 12 |
#include "main.h" |
| 13 |
#include "wmm.h" |
| 14 |
#include "11n.h" |
| 15 |
|
| 16 |
#define MWIFIEX_IBSS_CONNECT_EVT_FIX_SIZE 12 |
| 17 |
|
| 18 |
static int mwifiex_check_ibss_peer_capabilities(struct mwifiex_private *priv, |
| 19 |
struct mwifiex_sta_node *sta_ptr, |
| 20 |
struct sk_buff *event) |
| 21 |
{ |
| 22 |
int evt_len, ele_len; |
| 23 |
u8 *curr; |
| 24 |
struct ieee_types_header *ele_hdr; |
| 25 |
struct mwifiex_ie_types_mgmt_frame *tlv_mgmt_frame; |
| 26 |
const struct ieee80211_ht_cap *ht_cap; |
| 27 |
const struct ieee80211_vht_cap *vht_cap; |
| 28 |
|
| 29 |
skb_pull(event, MWIFIEX_IBSS_CONNECT_EVT_FIX_SIZE); |
| 30 |
evt_len = event->len; |
| 31 |
curr = event->data; |
| 32 |
|
| 33 |
mwifiex_dbg_dump(priv->adapter, EVT_D, "ibss peer capabilities:", |
| 34 |
event->data, event->len); |
| 35 |
|
| 36 |
skb_push(event, MWIFIEX_IBSS_CONNECT_EVT_FIX_SIZE); |
| 37 |
|
| 38 |
tlv_mgmt_frame = (void *)curr; |
| 39 |
if (evt_len >= sizeof(*tlv_mgmt_frame) && |
| 40 |
le16_to_cpu(tlv_mgmt_frame->header.type) == |
| 41 |
TLV_TYPE_UAP_MGMT_FRAME) { |
| 42 |
/* Locate curr pointer to the start of beacon tlv, |
| 43 |
* timestamp 8 bytes, beacon intervel 2 bytes, |
| 44 |
* capability info 2 bytes, totally 12 byte beacon header |
| 45 |
*/ |
| 46 |
evt_len = le16_to_cpu(tlv_mgmt_frame->header.len); |
| 47 |
curr += (sizeof(*tlv_mgmt_frame) + 12); |
| 48 |
} else { |
| 49 |
mwifiex_dbg(priv->adapter, MSG, |
| 50 |
"management frame tlv not found!\n"); |
| 51 |
return 0; |
| 52 |
} |
| 53 |
|
| 54 |
while (evt_len >= sizeof(*ele_hdr)) { |
| 55 |
ele_hdr = (struct ieee_types_header *)curr; |
| 56 |
ele_len = ele_hdr->len; |
| 57 |
|
| 58 |
if (evt_len < ele_len + sizeof(*ele_hdr)) |
| 59 |
break; |
| 60 |
|
| 61 |
switch (ele_hdr->element_id) { |
| 62 |
case WLAN_EID_HT_CAPABILITY: |
| 63 |
sta_ptr->is_11n_enabled = true; |
| 64 |
ht_cap = (void *)(ele_hdr + 2); |
| 65 |
sta_ptr->max_amsdu = le16_to_cpu(ht_cap->cap_info) & |
| 66 |
IEEE80211_HT_CAP_MAX_AMSDU ? |
| 67 |
MWIFIEX_TX_DATA_BUF_SIZE_8K : |
| 68 |
MWIFIEX_TX_DATA_BUF_SIZE_4K; |
| 69 |
mwifiex_dbg(priv->adapter, INFO, |
| 70 |
"11n enabled!, max_amsdu : %d\n", |
| 71 |
sta_ptr->max_amsdu); |
| 72 |
break; |
| 73 |
|
| 74 |
case WLAN_EID_VHT_CAPABILITY: |
| 75 |
sta_ptr->is_11ac_enabled = true; |
| 76 |
vht_cap = (void *)(ele_hdr + 2); |
| 77 |
/* check VHT MAXMPDU capability */ |
| 78 |
switch (le32_to_cpu(vht_cap->vht_cap_info) & 0x3) { |
| 79 |
case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454: |
| 80 |
sta_ptr->max_amsdu = |
| 81 |
MWIFIEX_TX_DATA_BUF_SIZE_12K; |
| 82 |
break; |
| 83 |
case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991: |
| 84 |
sta_ptr->max_amsdu = |
| 85 |
MWIFIEX_TX_DATA_BUF_SIZE_8K; |
| 86 |
break; |
| 87 |
case IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895: |
| 88 |
sta_ptr->max_amsdu = |
| 89 |
MWIFIEX_TX_DATA_BUF_SIZE_4K; |
| 90 |
break; |
| 91 |
default: |
| 92 |
break; |
| 93 |
} |
| 94 |
|
| 95 |
mwifiex_dbg(priv->adapter, INFO, |
| 96 |
"11ac enabled!, max_amsdu : %d\n", |
| 97 |
sta_ptr->max_amsdu); |
| 98 |
break; |
| 99 |
default: |
| 100 |
break; |
| 101 |
} |
| 102 |
|
| 103 |
curr += (ele_len + sizeof(*ele_hdr)); |
| 104 |
evt_len -= (ele_len + sizeof(*ele_hdr)); |
| 105 |
} |
| 106 |
|
| 107 |
return 0; |
| 108 |
} |
| 109 |
|
| 110 |
/* |
| 111 |
* This function resets the connection state. |
| 112 |
* |
| 113 |
* The function is invoked after receiving a disconnect event from firmware, |
| 114 |
* and performs the following actions - |
| 115 |
* - Set media status to disconnected |
| 116 |
* - Clean up Tx and Rx packets |
| 117 |
* - Resets SNR/NF/RSSI value in driver |
| 118 |
* - Resets security configurations in driver |
| 119 |
* - Enables auto data rate |
| 120 |
* - Saves the previous SSID and BSSID so that they can |
| 121 |
* be used for re-association, if required |
| 122 |
* - Erases current SSID and BSSID information |
| 123 |
* - Sends a disconnect event to upper layers/applications. |
| 124 |
*/ |
| 125 |
void mwifiex_reset_connect_state(struct mwifiex_private *priv, u16 reason_code, |
| 126 |
bool from_ap) |
| 127 |
{ |
| 128 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 129 |
|
| 130 |
if (!priv->media_connected) |
| 131 |
return; |
| 132 |
|
| 133 |
mwifiex_dbg(adapter, INFO, |
| 134 |
"info: handles disconnect event\n"); |
| 135 |
|
| 136 |
priv->media_connected = false; |
| 137 |
|
| 138 |
priv->auth_flag = 0; |
| 139 |
priv->auth_alg = WLAN_AUTH_NONE; |
| 140 |
|
| 141 |
priv->scan_block = false; |
| 142 |
priv->port_open = false; |
| 143 |
|
| 144 |
if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) && |
| 145 |
ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info)) { |
| 146 |
mwifiex_disable_all_tdls_links(priv); |
| 147 |
|
| 148 |
if (priv->adapter->auto_tdls) |
| 149 |
mwifiex_clean_auto_tdls(priv); |
| 150 |
} |
| 151 |
|
| 152 |
/* Free Tx and Rx packets, report disconnect to upper layer */ |
| 153 |
mwifiex_clean_txrx(priv); |
| 154 |
|
| 155 |
/* Reset SNR/NF/RSSI values */ |
| 156 |
priv->data_rssi_last = 0; |
| 157 |
priv->data_nf_last = 0; |
| 158 |
priv->data_rssi_avg = 0; |
| 159 |
priv->data_nf_avg = 0; |
| 160 |
priv->bcn_rssi_last = 0; |
| 161 |
priv->bcn_nf_last = 0; |
| 162 |
priv->bcn_rssi_avg = 0; |
| 163 |
priv->bcn_nf_avg = 0; |
| 164 |
priv->rxpd_rate = 0; |
| 165 |
priv->rxpd_htinfo = 0; |
| 166 |
priv->sec_info.wpa_enabled = false; |
| 167 |
priv->sec_info.wpa2_enabled = false; |
| 168 |
priv->wpa_ie_len = 0; |
| 169 |
|
| 170 |
priv->sec_info.wapi_enabled = false; |
| 171 |
priv->wapi_ie_len = 0; |
| 172 |
priv->sec_info.wapi_key_on = false; |
| 173 |
|
| 174 |
priv->sec_info.encryption_mode = 0; |
| 175 |
|
| 176 |
/* Enable auto data rate */ |
| 177 |
priv->is_data_rate_auto = true; |
| 178 |
priv->data_rate = 0; |
| 179 |
|
| 180 |
priv->ht_param_present = false; |
| 181 |
|
| 182 |
if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA || |
| 183 |
GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) && priv->hist_data) |
| 184 |
mwifiex_hist_data_reset(priv); |
| 185 |
|
| 186 |
if (priv->bss_mode == NL80211_IFTYPE_ADHOC) |
| 187 |
priv->adhoc_state = ADHOC_IDLE; |
| 188 |
|
| 189 |
/* |
| 190 |
* Memorize the previous SSID and BSSID so |
| 191 |
* it could be used for re-assoc |
| 192 |
*/ |
| 193 |
|
| 194 |
mwifiex_dbg(adapter, INFO, |
| 195 |
"info: previous SSID=%s, SSID len=%u\n", |
| 196 |
priv->prev_ssid.ssid, priv->prev_ssid.ssid_len); |
| 197 |
|
| 198 |
mwifiex_dbg(adapter, INFO, |
| 199 |
"info: current SSID=%s, SSID len=%u\n", |
| 200 |
priv->curr_bss_params.bss_descriptor.ssid.ssid, |
| 201 |
priv->curr_bss_params.bss_descriptor.ssid.ssid_len); |
| 202 |
|
| 203 |
memcpy(&priv->prev_ssid, |
| 204 |
&priv->curr_bss_params.bss_descriptor.ssid, |
| 205 |
sizeof(struct cfg80211_ssid)); |
| 206 |
|
| 207 |
memcpy(priv->prev_bssid, |
| 208 |
priv->curr_bss_params.bss_descriptor.mac_address, ETH_ALEN); |
| 209 |
|
| 210 |
/* Need to erase the current SSID and BSSID info */ |
| 211 |
memset(&priv->curr_bss_params, 0x00, sizeof(priv->curr_bss_params)); |
| 212 |
|
| 213 |
adapter->tx_lock_flag = false; |
| 214 |
adapter->pps_uapsd_mode = false; |
| 215 |
|
| 216 |
if (test_bit(MWIFIEX_IS_CMD_TIMEDOUT, &adapter->work_flags) && |
| 217 |
adapter->curr_cmd) |
| 218 |
return; |
| 219 |
priv->media_connected = false; |
| 220 |
mwifiex_dbg(adapter, MSG, |
| 221 |
"info: successfully disconnected from %pM: reason code %d\n", |
| 222 |
priv->cfg_bssid, reason_code); |
| 223 |
if (priv->bss_mode == NL80211_IFTYPE_STATION || |
| 224 |
priv->bss_mode == NL80211_IFTYPE_P2P_CLIENT) { |
| 225 |
if (adapter->host_mlme_enabled && adapter->host_mlme_link_lost) |
| 226 |
mwifiex_host_mlme_disconnect(adapter->priv_link_lost, |
| 227 |
reason_code, NULL); |
| 228 |
else |
| 229 |
cfg80211_disconnected(priv->netdev, reason_code, NULL, |
| 230 |
0, !from_ap, GFP_KERNEL); |
| 231 |
} |
| 232 |
eth_zero_addr(priv->cfg_bssid); |
| 233 |
|
| 234 |
mwifiex_stop_net_dev_queue(priv->netdev, adapter); |
| 235 |
if (netif_carrier_ok(priv->netdev)) |
| 236 |
netif_carrier_off(priv->netdev); |
| 237 |
|
| 238 |
if (!ISSUPP_FIRMWARE_SUPPLICANT(priv->adapter->fw_cap_info)) |
| 239 |
return; |
| 240 |
|
| 241 |
mwifiex_send_cmd(priv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG, |
| 242 |
HostCmd_ACT_GEN_REMOVE, 0, NULL, false); |
| 243 |
} |
| 244 |
|
| 245 |
static int mwifiex_parse_tdls_event(struct mwifiex_private *priv, |
| 246 |
struct sk_buff *event_skb) |
| 247 |
{ |
| 248 |
int ret = 0; |
| 249 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 250 |
struct mwifiex_sta_node *sta_ptr; |
| 251 |
struct mwifiex_tdls_generic_event *tdls_evt = |
| 252 |
(void *)event_skb->data + sizeof(adapter->event_cause); |
| 253 |
u8 *mac = tdls_evt->peer_mac; |
| 254 |
|
| 255 |
/* reserved 2 bytes are not mandatory in tdls event */ |
| 256 |
if (event_skb->len < (sizeof(struct mwifiex_tdls_generic_event) - |
| 257 |
sizeof(u16) - sizeof(adapter->event_cause))) { |
| 258 |
mwifiex_dbg(adapter, ERROR, "Invalid event length!\n"); |
| 259 |
return -1; |
| 260 |
} |
| 261 |
|
| 262 |
sta_ptr = mwifiex_get_sta_entry(priv, tdls_evt->peer_mac); |
| 263 |
if (!sta_ptr) { |
| 264 |
mwifiex_dbg(adapter, ERROR, "cannot get sta entry!\n"); |
| 265 |
return -1; |
| 266 |
} |
| 267 |
|
| 268 |
switch (le16_to_cpu(tdls_evt->type)) { |
| 269 |
case TDLS_EVENT_LINK_TEAR_DOWN: |
| 270 |
cfg80211_tdls_oper_request(priv->netdev, |
| 271 |
tdls_evt->peer_mac, |
| 272 |
NL80211_TDLS_TEARDOWN, |
| 273 |
le16_to_cpu(tdls_evt->u.reason_code), |
| 274 |
GFP_KERNEL); |
| 275 |
break; |
| 276 |
case TDLS_EVENT_CHAN_SWITCH_RESULT: |
| 277 |
mwifiex_dbg(adapter, EVENT, "tdls channel switch result :\n"); |
| 278 |
mwifiex_dbg(adapter, EVENT, |
| 279 |
"status=0x%x, reason=0x%x cur_chan=%d\n", |
| 280 |
tdls_evt->u.switch_result.status, |
| 281 |
tdls_evt->u.switch_result.reason, |
| 282 |
tdls_evt->u.switch_result.cur_chan); |
| 283 |
|
| 284 |
/* tdls channel switch failed */ |
| 285 |
if (tdls_evt->u.switch_result.status != 0) { |
| 286 |
switch (tdls_evt->u.switch_result.cur_chan) { |
| 287 |
case TDLS_BASE_CHANNEL: |
| 288 |
sta_ptr->tdls_status = TDLS_IN_BASE_CHAN; |
| 289 |
break; |
| 290 |
case TDLS_OFF_CHANNEL: |
| 291 |
sta_ptr->tdls_status = TDLS_IN_OFF_CHAN; |
| 292 |
break; |
| 293 |
default: |
| 294 |
break; |
| 295 |
} |
| 296 |
return ret; |
| 297 |
} |
| 298 |
|
| 299 |
/* tdls channel switch success */ |
| 300 |
switch (tdls_evt->u.switch_result.cur_chan) { |
| 301 |
case TDLS_BASE_CHANNEL: |
| 302 |
if (sta_ptr->tdls_status == TDLS_IN_BASE_CHAN) |
| 303 |
break; |
| 304 |
mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac, |
| 305 |
false); |
| 306 |
sta_ptr->tdls_status = TDLS_IN_BASE_CHAN; |
| 307 |
break; |
| 308 |
case TDLS_OFF_CHANNEL: |
| 309 |
if (sta_ptr->tdls_status == TDLS_IN_OFF_CHAN) |
| 310 |
break; |
| 311 |
mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac, |
| 312 |
true); |
| 313 |
sta_ptr->tdls_status = TDLS_IN_OFF_CHAN; |
| 314 |
break; |
| 315 |
default: |
| 316 |
break; |
| 317 |
} |
| 318 |
|
| 319 |
break; |
| 320 |
case TDLS_EVENT_START_CHAN_SWITCH: |
| 321 |
mwifiex_dbg(adapter, EVENT, "tdls start channel switch...\n"); |
| 322 |
sta_ptr->tdls_status = TDLS_CHAN_SWITCHING; |
| 323 |
break; |
| 324 |
case TDLS_EVENT_CHAN_SWITCH_STOPPED: |
| 325 |
mwifiex_dbg(adapter, EVENT, |
| 326 |
"tdls chan switch stopped, reason=%d\n", |
| 327 |
tdls_evt->u.cs_stop_reason); |
| 328 |
break; |
| 329 |
default: |
| 330 |
break; |
| 331 |
} |
| 332 |
|
| 333 |
return ret; |
| 334 |
} |
| 335 |
|
| 336 |
static void mwifiex_process_uap_tx_pause(struct mwifiex_private *priv, |
| 337 |
struct mwifiex_ie_types_header *tlv) |
| 338 |
{ |
| 339 |
struct mwifiex_tx_pause_tlv *tp; |
| 340 |
struct mwifiex_sta_node *sta_ptr; |
| 341 |
|
| 342 |
tp = (void *)tlv; |
| 343 |
mwifiex_dbg(priv->adapter, EVENT, |
| 344 |
"uap tx_pause: %pM pause=%d, pkts=%d\n", |
| 345 |
tp->peermac, tp->tx_pause, |
| 346 |
tp->pkt_cnt); |
| 347 |
|
| 348 |
if (ether_addr_equal(tp->peermac, priv->netdev->dev_addr)) { |
| 349 |
if (tp->tx_pause) |
| 350 |
priv->port_open = false; |
| 351 |
else |
| 352 |
priv->port_open = true; |
| 353 |
} else if (is_multicast_ether_addr(tp->peermac)) { |
| 354 |
mwifiex_update_ralist_tx_pause(priv, tp->peermac, tp->tx_pause); |
| 355 |
} else { |
| 356 |
spin_lock_bh(&priv->sta_list_spinlock); |
| 357 |
sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac); |
| 358 |
if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) { |
| 359 |
sta_ptr->tx_pause = tp->tx_pause; |
| 360 |
spin_unlock_bh(&priv->sta_list_spinlock); |
| 361 |
mwifiex_update_ralist_tx_pause(priv, tp->peermac, |
| 362 |
tp->tx_pause); |
| 363 |
} else { |
| 364 |
spin_unlock_bh(&priv->sta_list_spinlock); |
| 365 |
} |
| 366 |
} |
| 367 |
} |
| 368 |
|
| 369 |
static void mwifiex_process_sta_tx_pause(struct mwifiex_private *priv, |
| 370 |
struct mwifiex_ie_types_header *tlv) |
| 371 |
{ |
| 372 |
struct mwifiex_tx_pause_tlv *tp; |
| 373 |
struct mwifiex_sta_node *sta_ptr; |
| 374 |
int status; |
| 375 |
|
| 376 |
tp = (void *)tlv; |
| 377 |
mwifiex_dbg(priv->adapter, EVENT, |
| 378 |
"sta tx_pause: %pM pause=%d, pkts=%d\n", |
| 379 |
tp->peermac, tp->tx_pause, |
| 380 |
tp->pkt_cnt); |
| 381 |
|
| 382 |
if (ether_addr_equal(tp->peermac, priv->cfg_bssid)) { |
| 383 |
if (tp->tx_pause) |
| 384 |
priv->port_open = false; |
| 385 |
else |
| 386 |
priv->port_open = true; |
| 387 |
} else { |
| 388 |
if (!ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info)) |
| 389 |
return; |
| 390 |
|
| 391 |
status = mwifiex_get_tdls_link_status(priv, tp->peermac); |
| 392 |
if (mwifiex_is_tdls_link_setup(status)) { |
| 393 |
spin_lock_bh(&priv->sta_list_spinlock); |
| 394 |
sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac); |
| 395 |
if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) { |
| 396 |
sta_ptr->tx_pause = tp->tx_pause; |
| 397 |
spin_unlock_bh(&priv->sta_list_spinlock); |
| 398 |
mwifiex_update_ralist_tx_pause(priv, |
| 399 |
tp->peermac, |
| 400 |
tp->tx_pause); |
| 401 |
} else { |
| 402 |
spin_unlock_bh(&priv->sta_list_spinlock); |
| 403 |
} |
| 404 |
} |
| 405 |
} |
| 406 |
} |
| 407 |
|
| 408 |
void mwifiex_process_multi_chan_event(struct mwifiex_private *priv, |
| 409 |
struct sk_buff *event_skb) |
| 410 |
{ |
| 411 |
struct mwifiex_ie_types_multi_chan_info *chan_info; |
| 412 |
struct mwifiex_ie_types_mc_group_info *grp_info; |
| 413 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 414 |
struct mwifiex_ie_types_header *tlv; |
| 415 |
u16 tlv_buf_left, tlv_type, tlv_len; |
| 416 |
int intf_num, bss_type, bss_num, i; |
| 417 |
struct mwifiex_private *intf_priv; |
| 418 |
|
| 419 |
tlv_buf_left = event_skb->len - sizeof(u32); |
| 420 |
chan_info = (void *)event_skb->data + sizeof(u32); |
| 421 |
|
| 422 |
if (le16_to_cpu(chan_info->header.type) != TLV_TYPE_MULTI_CHAN_INFO || |
| 423 |
tlv_buf_left < sizeof(struct mwifiex_ie_types_multi_chan_info)) { |
| 424 |
mwifiex_dbg(adapter, ERROR, |
| 425 |
"unknown TLV in chan_info event\n"); |
| 426 |
return; |
| 427 |
} |
| 428 |
|
| 429 |
adapter->usb_mc_status = le16_to_cpu(chan_info->status); |
| 430 |
mwifiex_dbg(adapter, EVENT, "multi chan operation %s\n", |
| 431 |
adapter->usb_mc_status ? "started" : "over"); |
| 432 |
|
| 433 |
tlv_buf_left -= sizeof(struct mwifiex_ie_types_multi_chan_info); |
| 434 |
tlv = (struct mwifiex_ie_types_header *)chan_info->tlv_buffer; |
| 435 |
|
| 436 |
while (tlv_buf_left >= (int)sizeof(struct mwifiex_ie_types_header)) { |
| 437 |
tlv_type = le16_to_cpu(tlv->type); |
| 438 |
tlv_len = le16_to_cpu(tlv->len); |
| 439 |
if ((sizeof(struct mwifiex_ie_types_header) + tlv_len) > |
| 440 |
tlv_buf_left) { |
| 441 |
mwifiex_dbg(adapter, ERROR, "wrong tlv: tlvLen=%d,\t" |
| 442 |
"tlvBufLeft=%d\n", tlv_len, tlv_buf_left); |
| 443 |
break; |
| 444 |
} |
| 445 |
if (tlv_type != TLV_TYPE_MC_GROUP_INFO) { |
| 446 |
mwifiex_dbg(adapter, ERROR, "wrong tlv type: 0x%x\n", |
| 447 |
tlv_type); |
| 448 |
break; |
| 449 |
} |
| 450 |
|
| 451 |
grp_info = (struct mwifiex_ie_types_mc_group_info *)tlv; |
| 452 |
intf_num = grp_info->intf_num; |
| 453 |
for (i = 0; i < intf_num; i++) { |
| 454 |
bss_type = grp_info->bss_type_numlist[i] >> 4; |
| 455 |
bss_num = grp_info->bss_type_numlist[i] & BSS_NUM_MASK; |
| 456 |
intf_priv = mwifiex_get_priv_by_id(adapter, bss_num, |
| 457 |
bss_type); |
| 458 |
if (!intf_priv) { |
| 459 |
mwifiex_dbg(adapter, ERROR, |
| 460 |
"Invalid bss_type bss_num\t" |
| 461 |
"in multi channel event\n"); |
| 462 |
continue; |
| 463 |
} |
| 464 |
if (adapter->iface_type == MWIFIEX_USB) { |
| 465 |
u8 ep; |
| 466 |
|
| 467 |
ep = grp_info->hid_num.usb_ep_num; |
| 468 |
if (ep == MWIFIEX_USB_EP_DATA || |
| 469 |
ep == MWIFIEX_USB_EP_DATA_CH2) |
| 470 |
intf_priv->usb_port = ep; |
| 471 |
} |
| 472 |
} |
| 473 |
|
| 474 |
tlv_buf_left -= sizeof(struct mwifiex_ie_types_header) + |
| 475 |
tlv_len; |
| 476 |
tlv = (void *)((u8 *)tlv + tlv_len + |
| 477 |
sizeof(struct mwifiex_ie_types_header)); |
| 478 |
} |
| 479 |
|
| 480 |
if (adapter->iface_type == MWIFIEX_USB) { |
| 481 |
adapter->tx_lock_flag = true; |
| 482 |
adapter->usb_mc_setup = true; |
| 483 |
mwifiex_multi_chan_resync(adapter); |
| 484 |
} |
| 485 |
} |
| 486 |
|
| 487 |
void mwifiex_process_tx_pause_event(struct mwifiex_private *priv, |
| 488 |
struct sk_buff *event_skb) |
| 489 |
{ |
| 490 |
struct mwifiex_ie_types_header *tlv; |
| 491 |
u16 tlv_type, tlv_len; |
| 492 |
int tlv_buf_left; |
| 493 |
|
| 494 |
if (!priv->media_connected) { |
| 495 |
mwifiex_dbg(priv->adapter, ERROR, |
| 496 |
"tx_pause event while disconnected; bss_role=%d\n", |
| 497 |
priv->bss_role); |
| 498 |
return; |
| 499 |
} |
| 500 |
|
| 501 |
tlv_buf_left = event_skb->len - sizeof(u32); |
| 502 |
tlv = (void *)event_skb->data + sizeof(u32); |
| 503 |
|
| 504 |
while (tlv_buf_left >= (int)sizeof(struct mwifiex_ie_types_header)) { |
| 505 |
tlv_type = le16_to_cpu(tlv->type); |
| 506 |
tlv_len = le16_to_cpu(tlv->len); |
| 507 |
if ((sizeof(struct mwifiex_ie_types_header) + tlv_len) > |
| 508 |
tlv_buf_left) { |
| 509 |
mwifiex_dbg(priv->adapter, ERROR, |
| 510 |
"wrong tlv: tlvLen=%d, tlvBufLeft=%d\n", |
| 511 |
tlv_len, tlv_buf_left); |
| 512 |
break; |
| 513 |
} |
| 514 |
if (tlv_type == TLV_TYPE_TX_PAUSE) { |
| 515 |
if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) |
| 516 |
mwifiex_process_sta_tx_pause(priv, tlv); |
| 517 |
else |
| 518 |
mwifiex_process_uap_tx_pause(priv, tlv); |
| 519 |
} |
| 520 |
|
| 521 |
tlv_buf_left -= sizeof(struct mwifiex_ie_types_header) + |
| 522 |
tlv_len; |
| 523 |
tlv = (void *)((u8 *)tlv + tlv_len + |
| 524 |
sizeof(struct mwifiex_ie_types_header)); |
| 525 |
} |
| 526 |
|
| 527 |
} |
| 528 |
|
| 529 |
/* |
| 530 |
* This function handles coex events generated by firmware |
| 531 |
*/ |
| 532 |
void mwifiex_bt_coex_wlan_param_update_event(struct mwifiex_private *priv, |
| 533 |
struct sk_buff *event_skb) |
| 534 |
{ |
| 535 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 536 |
struct mwifiex_ie_types_header *tlv; |
| 537 |
struct mwifiex_ie_types_btcoex_aggr_win_size *winsizetlv; |
| 538 |
struct mwifiex_ie_types_btcoex_scan_time *scantlv; |
| 539 |
s32 len = event_skb->len - sizeof(u32); |
| 540 |
u8 *cur_ptr = event_skb->data + sizeof(u32); |
| 541 |
u16 tlv_type, tlv_len; |
| 542 |
|
| 543 |
while (len >= sizeof(struct mwifiex_ie_types_header)) { |
| 544 |
tlv = (struct mwifiex_ie_types_header *)cur_ptr; |
| 545 |
tlv_len = le16_to_cpu(tlv->len); |
| 546 |
tlv_type = le16_to_cpu(tlv->type); |
| 547 |
|
| 548 |
if ((tlv_len + sizeof(struct mwifiex_ie_types_header)) > len) |
| 549 |
break; |
| 550 |
switch (tlv_type) { |
| 551 |
case TLV_BTCOEX_WL_AGGR_WINSIZE: |
| 552 |
winsizetlv = |
| 553 |
(struct mwifiex_ie_types_btcoex_aggr_win_size *)tlv; |
| 554 |
adapter->coex_win_size = winsizetlv->coex_win_size; |
| 555 |
adapter->coex_tx_win_size = |
| 556 |
winsizetlv->tx_win_size; |
| 557 |
adapter->coex_rx_win_size = |
| 558 |
winsizetlv->rx_win_size; |
| 559 |
mwifiex_coex_ampdu_rxwinsize(adapter); |
| 560 |
mwifiex_update_ampdu_txwinsize(adapter); |
| 561 |
break; |
| 562 |
|
| 563 |
case TLV_BTCOEX_WL_SCANTIME: |
| 564 |
scantlv = |
| 565 |
(struct mwifiex_ie_types_btcoex_scan_time *)tlv; |
| 566 |
adapter->coex_scan = scantlv->coex_scan; |
| 567 |
adapter->coex_min_scan_time = le16_to_cpu(scantlv->min_scan_time); |
| 568 |
adapter->coex_max_scan_time = le16_to_cpu(scantlv->max_scan_time); |
| 569 |
break; |
| 570 |
|
| 571 |
default: |
| 572 |
break; |
| 573 |
} |
| 574 |
|
| 575 |
len -= tlv_len + sizeof(struct mwifiex_ie_types_header); |
| 576 |
cur_ptr += tlv_len + |
| 577 |
sizeof(struct mwifiex_ie_types_header); |
| 578 |
} |
| 579 |
|
| 580 |
dev_dbg(adapter->dev, "coex_scan=%d min_scan=%d coex_win=%d, tx_win=%d rx_win=%d\n", |
| 581 |
adapter->coex_scan, adapter->coex_min_scan_time, |
| 582 |
adapter->coex_win_size, adapter->coex_tx_win_size, |
| 583 |
adapter->coex_rx_win_size); |
| 584 |
} |
| 585 |
|
| 586 |
static void |
| 587 |
mwifiex_fw_dump_info_event(struct mwifiex_private *priv, |
| 588 |
struct sk_buff *event_skb) |
| 589 |
{ |
| 590 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 591 |
struct mwifiex_fw_dump_header *fw_dump_hdr = |
| 592 |
(void *)adapter->event_body; |
| 593 |
|
| 594 |
if (adapter->iface_type != MWIFIEX_USB) { |
| 595 |
mwifiex_dbg(adapter, MSG, |
| 596 |
"event is not on usb interface, ignore it\n"); |
| 597 |
return; |
| 598 |
} |
| 599 |
|
| 600 |
if (!adapter->devdump_data) { |
| 601 |
/* When receive the first event, allocate device dump |
| 602 |
* buffer, dump driver info. |
| 603 |
*/ |
| 604 |
adapter->devdump_data = vzalloc(MWIFIEX_FW_DUMP_SIZE); |
| 605 |
if (!adapter->devdump_data) { |
| 606 |
mwifiex_dbg(adapter, ERROR, |
| 607 |
"vzalloc devdump data failure!\n"); |
| 608 |
return; |
| 609 |
} |
| 610 |
|
| 611 |
mwifiex_drv_info_dump(adapter); |
| 612 |
|
| 613 |
/* If no proceeded event arrive in 10s, upload device |
| 614 |
* dump data, this will be useful if the end of |
| 615 |
* transmission event get lost, in this cornel case, |
| 616 |
* user would still get partial of the dump. |
| 617 |
*/ |
| 618 |
schedule_delayed_work(&adapter->devdump_work, |
| 619 |
msecs_to_jiffies(MWIFIEX_TIMER_10S)); |
| 620 |
} |
| 621 |
|
| 622 |
/* Overflow check */ |
| 623 |
if (adapter->devdump_len + event_skb->len >= MWIFIEX_FW_DUMP_SIZE) |
| 624 |
goto upload_dump; |
| 625 |
|
| 626 |
memmove(adapter->devdump_data + adapter->devdump_len, |
| 627 |
adapter->event_skb->data, event_skb->len); |
| 628 |
adapter->devdump_len += event_skb->len; |
| 629 |
|
| 630 |
if (le16_to_cpu(fw_dump_hdr->type) == FW_DUMP_INFO_ENDED) { |
| 631 |
mwifiex_dbg(adapter, MSG, |
| 632 |
"receive end of transmission flag event!\n"); |
| 633 |
goto upload_dump; |
| 634 |
} |
| 635 |
return; |
| 636 |
|
| 637 |
upload_dump: |
| 638 |
cancel_delayed_work_sync(&adapter->devdump_work); |
| 639 |
mwifiex_upload_device_dump(adapter); |
| 640 |
} |
| 641 |
|
| 642 |
/* |
| 643 |
* This function handles events generated by firmware. |
| 644 |
* |
| 645 |
* This is a generic function and handles all events. |
| 646 |
* |
| 647 |
* Event specific routines are called by this function based |
| 648 |
* upon the generated event cause. |
| 649 |
* |
| 650 |
* For the following events, the function just forwards them to upper |
| 651 |
* layers, optionally recording the change - |
| 652 |
* - EVENT_LINK_SENSED |
| 653 |
* - EVENT_MIC_ERR_UNICAST |
| 654 |
* - EVENT_MIC_ERR_MULTICAST |
| 655 |
* - EVENT_PORT_RELEASE |
| 656 |
* - EVENT_RSSI_LOW |
| 657 |
* - EVENT_SNR_LOW |
| 658 |
* - EVENT_MAX_FAIL |
| 659 |
* - EVENT_RSSI_HIGH |
| 660 |
* - EVENT_SNR_HIGH |
| 661 |
* - EVENT_DATA_RSSI_LOW |
| 662 |
* - EVENT_DATA_SNR_LOW |
| 663 |
* - EVENT_DATA_RSSI_HIGH |
| 664 |
* - EVENT_DATA_SNR_HIGH |
| 665 |
* - EVENT_LINK_QUALITY |
| 666 |
* - EVENT_PRE_BEACON_LOST |
| 667 |
* - EVENT_IBSS_COALESCED |
| 668 |
* - EVENT_IBSS_STA_CONNECT |
| 669 |
* - EVENT_IBSS_STA_DISCONNECT |
| 670 |
* - EVENT_WEP_ICV_ERR |
| 671 |
* - EVENT_BW_CHANGE |
| 672 |
* - EVENT_HOSTWAKE_STAIE |
| 673 |
* |
| 674 |
* For the following events, no action is taken - |
| 675 |
* - EVENT_MIB_CHANGED |
| 676 |
* - EVENT_INIT_DONE |
| 677 |
* - EVENT_DUMMY_HOST_WAKEUP_SIGNAL |
| 678 |
* |
| 679 |
* Rest of the supported events requires driver handling - |
| 680 |
* - EVENT_DEAUTHENTICATED |
| 681 |
* - EVENT_DISASSOCIATED |
| 682 |
* - EVENT_LINK_LOST |
| 683 |
* - EVENT_PS_SLEEP |
| 684 |
* - EVENT_PS_AWAKE |
| 685 |
* - EVENT_DEEP_SLEEP_AWAKE |
| 686 |
* - EVENT_HS_ACT_REQ |
| 687 |
* - EVENT_ADHOC_BCN_LOST |
| 688 |
* - EVENT_BG_SCAN_REPORT |
| 689 |
* - EVENT_WMM_STATUS_CHANGE |
| 690 |
* - EVENT_ADDBA |
| 691 |
* - EVENT_DELBA |
| 692 |
* - EVENT_BA_STREAM_TIEMOUT |
| 693 |
* - EVENT_AMSDU_AGGR_CTRL |
| 694 |
* - EVENT_FW_DUMP_INFO |
| 695 |
*/ |
| 696 |
int mwifiex_process_sta_event(struct mwifiex_private *priv) |
| 697 |
{ |
| 698 |
struct mwifiex_adapter *adapter = priv->adapter; |
| 699 |
int ret = 0, i; |
| 700 |
u32 eventcause = adapter->event_cause; |
| 701 |
u16 ctrl, reason_code; |
| 702 |
u8 ibss_sta_addr[ETH_ALEN]; |
| 703 |
struct mwifiex_sta_node *sta_ptr; |
| 704 |
|
| 705 |
switch (eventcause) { |
| 706 |
case EVENT_DUMMY_HOST_WAKEUP_SIGNAL: |
| 707 |
mwifiex_dbg(adapter, ERROR, |
| 708 |
"invalid EVENT: DUMMY_HOST_WAKEUP_SIGNAL, ignore it\n"); |
| 709 |
break; |
| 710 |
case EVENT_LINK_SENSED: |
| 711 |
mwifiex_dbg(adapter, EVENT, "event: LINK_SENSED\n"); |
| 712 |
if (!netif_carrier_ok(priv->netdev)) |
| 713 |
netif_carrier_on(priv->netdev); |
| 714 |
mwifiex_wake_up_net_dev_queue(priv->netdev, adapter); |
| 715 |
break; |
| 716 |
|
| 717 |
case EVENT_DEAUTHENTICATED: |
| 718 |
mwifiex_dbg(adapter, EVENT, "event: Deauthenticated\n"); |
| 719 |
if (priv->wps.session_enable) { |
| 720 |
mwifiex_dbg(adapter, INFO, |
| 721 |
"info: receive deauth event in wps session\n"); |
| 722 |
break; |
| 723 |
} |
| 724 |
adapter->dbg.num_event_deauth++; |
| 725 |
if (priv->media_connected) { |
| 726 |
reason_code = |
| 727 |
get_unaligned_le16(adapter->event_body); |
| 728 |
mwifiex_reset_connect_state(priv, reason_code, true); |
| 729 |
} |
| 730 |
break; |
| 731 |
|
| 732 |
case EVENT_DISASSOCIATED: |
| 733 |
mwifiex_dbg(adapter, EVENT, "event: Disassociated\n"); |
| 734 |
if (priv->wps.session_enable) { |
| 735 |
mwifiex_dbg(adapter, INFO, |
| 736 |
"info: receive disassoc event in wps session\n"); |
| 737 |
break; |
| 738 |
} |
| 739 |
adapter->dbg.num_event_disassoc++; |
| 740 |
if (priv->media_connected) { |
| 741 |
reason_code = |
| 742 |
get_unaligned_le16(adapter->event_body); |
| 743 |
mwifiex_reset_connect_state(priv, reason_code, true); |
| 744 |
} |
| 745 |
break; |
| 746 |
|
| 747 |
case EVENT_LINK_LOST: |
| 748 |
mwifiex_dbg(adapter, EVENT, "event: Link lost\n"); |
| 749 |
adapter->dbg.num_event_link_lost++; |
| 750 |
if (priv->media_connected) { |
| 751 |
reason_code = |
| 752 |
get_unaligned_le16(adapter->event_body); |
| 753 |
if (adapter->host_mlme_enabled) { |
| 754 |
adapter->priv_link_lost = priv; |
| 755 |
adapter->host_mlme_link_lost = true; |
| 756 |
queue_work(adapter->host_mlme_workqueue, |
| 757 |
&adapter->host_mlme_work); |
| 758 |
} else { |
| 759 |
mwifiex_reset_connect_state(priv, reason_code, |
| 760 |
true); |
| 761 |
} |
| 762 |
} |
| 763 |
break; |
| 764 |
|
| 765 |
case EVENT_PS_SLEEP: |
| 766 |
mwifiex_dbg(adapter, EVENT, "info: EVENT: SLEEP\n"); |
| 767 |
|
| 768 |
adapter->ps_state = PS_STATE_PRE_SLEEP; |
| 769 |
|
| 770 |
mwifiex_check_ps_cond(adapter); |
| 771 |
break; |
| 772 |
|
| 773 |
case EVENT_PS_AWAKE: |
| 774 |
mwifiex_dbg(adapter, EVENT, "info: EVENT: AWAKE\n"); |
| 775 |
if (!adapter->pps_uapsd_mode && |
| 776 |
(priv->port_open || |
| 777 |
(priv->bss_mode == NL80211_IFTYPE_ADHOC)) && |
| 778 |
priv->media_connected && adapter->sleep_period.period) { |
| 779 |
adapter->pps_uapsd_mode = true; |
| 780 |
mwifiex_dbg(adapter, EVENT, |
| 781 |
"event: PPS/UAPSD mode activated\n"); |
| 782 |
} |
| 783 |
adapter->tx_lock_flag = false; |
| 784 |
if (adapter->pps_uapsd_mode && adapter->gen_null_pkt) { |
| 785 |
if (mwifiex_check_last_packet_indication(priv)) { |
| 786 |
if (adapter->data_sent || |
| 787 |
(adapter->if_ops.is_port_ready && |
| 788 |
!adapter->if_ops.is_port_ready(priv))) { |
| 789 |
adapter->ps_state = PS_STATE_AWAKE; |
| 790 |
adapter->pm_wakeup_card_req = false; |
| 791 |
adapter->pm_wakeup_fw_try = false; |
| 792 |
timer_delete(&adapter->wakeup_timer); |
| 793 |
break; |
| 794 |
} |
| 795 |
if (!mwifiex_send_null_packet |
| 796 |
(priv, |
| 797 |
MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET | |
| 798 |
MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) |
| 799 |
adapter->ps_state = |
| 800 |
PS_STATE_SLEEP; |
| 801 |
return 0; |
| 802 |
} |
| 803 |
} |
| 804 |
adapter->ps_state = PS_STATE_AWAKE; |
| 805 |
adapter->pm_wakeup_card_req = false; |
| 806 |
adapter->pm_wakeup_fw_try = false; |
| 807 |
timer_delete(&adapter->wakeup_timer); |
| 808 |
|
| 809 |
break; |
| 810 |
|
| 811 |
case EVENT_DEEP_SLEEP_AWAKE: |
| 812 |
adapter->if_ops.wakeup_complete(adapter); |
| 813 |
mwifiex_dbg(adapter, EVENT, "event: DS_AWAKE\n"); |
| 814 |
if (adapter->is_deep_sleep) |
| 815 |
adapter->is_deep_sleep = false; |
| 816 |
break; |
| 817 |
|
| 818 |
case EVENT_HS_ACT_REQ: |
| 819 |
mwifiex_dbg(adapter, EVENT, "event: HS_ACT_REQ\n"); |
| 820 |
ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_HS_CFG_ENH, |
| 821 |
0, 0, NULL, false); |
| 822 |
break; |
| 823 |
|
| 824 |
case EVENT_MIC_ERR_UNICAST: |
| 825 |
mwifiex_dbg(adapter, EVENT, "event: UNICAST MIC ERROR\n"); |
| 826 |
cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid, |
| 827 |
NL80211_KEYTYPE_PAIRWISE, |
| 828 |
-1, NULL, GFP_KERNEL); |
| 829 |
break; |
| 830 |
|
| 831 |
case EVENT_MIC_ERR_MULTICAST: |
| 832 |
mwifiex_dbg(adapter, EVENT, "event: MULTICAST MIC ERROR\n"); |
| 833 |
cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid, |
| 834 |
NL80211_KEYTYPE_GROUP, |
| 835 |
-1, NULL, GFP_KERNEL); |
| 836 |
break; |
| 837 |
case EVENT_MIB_CHANGED: |
| 838 |
case EVENT_INIT_DONE: |
| 839 |
break; |
| 840 |
|
| 841 |
case EVENT_ADHOC_BCN_LOST: |
| 842 |
mwifiex_dbg(adapter, EVENT, "event: ADHOC_BCN_LOST\n"); |
| 843 |
mwifiex_clean_txrx(priv); |
| 844 |
mwifiex_stop_net_dev_queue(priv->netdev, adapter); |
| 845 |
if (netif_carrier_ok(priv->netdev)) |
| 846 |
netif_carrier_off(priv->netdev); |
| 847 |
break; |
| 848 |
|
| 849 |
case EVENT_BG_SCAN_REPORT: |
| 850 |
mwifiex_dbg(adapter, EVENT, "event: BGS_REPORT\n"); |
| 851 |
ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_BG_SCAN_QUERY, |
| 852 |
HostCmd_ACT_GEN_GET, 0, NULL, false); |
| 853 |
break; |
| 854 |
|
| 855 |
case EVENT_BG_SCAN_STOPPED: |
| 856 |
dev_dbg(adapter->dev, "event: BGS_STOPPED\n"); |
| 857 |
cfg80211_sched_scan_stopped(priv->wdev.wiphy, 0); |
| 858 |
if (priv->sched_scanning) |
| 859 |
priv->sched_scanning = false; |
| 860 |
break; |
| 861 |
|
| 862 |
case EVENT_PORT_RELEASE: |
| 863 |
mwifiex_dbg(adapter, EVENT, "event: PORT RELEASE\n"); |
| 864 |
priv->port_open = true; |
| 865 |
break; |
| 866 |
|
| 867 |
case EVENT_EXT_SCAN_REPORT: |
| 868 |
mwifiex_dbg(adapter, EVENT, "event: EXT_SCAN Report\n"); |
| 869 |
/* We intend to skip this event during suspend, but handle |
| 870 |
* it in interface disabled case |
| 871 |
*/ |
| 872 |
if (adapter->ext_scan && (!priv->scan_aborting || |
| 873 |
!netif_running(priv->netdev))) |
| 874 |
ret = mwifiex_handle_event_ext_scan_report(priv, |
| 875 |
adapter->event_skb->data); |
| 876 |
|
| 877 |
break; |
| 878 |
|
| 879 |
case EVENT_WMM_STATUS_CHANGE: |
| 880 |
mwifiex_dbg(adapter, EVENT, "event: WMM status changed\n"); |
| 881 |
ret = mwifiex_send_cmd(priv, HostCmd_CMD_WMM_GET_STATUS, |
| 882 |
0, 0, NULL, false); |
| 883 |
break; |
| 884 |
|
| 885 |
case EVENT_RSSI_LOW: |
| 886 |
cfg80211_cqm_rssi_notify(priv->netdev, |
| 887 |
NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW, |
| 888 |
0, GFP_KERNEL); |
| 889 |
mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO, |
| 890 |
HostCmd_ACT_GEN_GET, 0, NULL, false); |
| 891 |
priv->subsc_evt_rssi_state = RSSI_LOW_RECVD; |
| 892 |
mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_LOW\n"); |
| 893 |
break; |
| 894 |
case EVENT_SNR_LOW: |
| 895 |
mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_LOW\n"); |
| 896 |
break; |
| 897 |
case EVENT_MAX_FAIL: |
| 898 |
mwifiex_dbg(adapter, EVENT, "event: MAX_FAIL\n"); |
| 899 |
break; |
| 900 |
case EVENT_RSSI_HIGH: |
| 901 |
cfg80211_cqm_rssi_notify(priv->netdev, |
| 902 |
NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH, |
| 903 |
0, GFP_KERNEL); |
| 904 |
mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO, |
| 905 |
HostCmd_ACT_GEN_GET, 0, NULL, false); |
| 906 |
priv->subsc_evt_rssi_state = RSSI_HIGH_RECVD; |
| 907 |
mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_HIGH\n"); |
| 908 |
break; |
| 909 |
case EVENT_SNR_HIGH: |
| 910 |
mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_HIGH\n"); |
| 911 |
break; |
| 912 |
case EVENT_DATA_RSSI_LOW: |
| 913 |
mwifiex_dbg(adapter, EVENT, "event: Data RSSI_LOW\n"); |
| 914 |
break; |
| 915 |
case EVENT_DATA_SNR_LOW: |
| 916 |
mwifiex_dbg(adapter, EVENT, "event: Data SNR_LOW\n"); |
| 917 |
break; |
| 918 |
case EVENT_DATA_RSSI_HIGH: |
| 919 |
mwifiex_dbg(adapter, EVENT, "event: Data RSSI_HIGH\n"); |
| 920 |
break; |
| 921 |
case EVENT_DATA_SNR_HIGH: |
| 922 |
mwifiex_dbg(adapter, EVENT, "event: Data SNR_HIGH\n"); |
| 923 |
break; |
| 924 |
case EVENT_LINK_QUALITY: |
| 925 |
mwifiex_dbg(adapter, EVENT, "event: Link Quality\n"); |
| 926 |
break; |
| 927 |
case EVENT_PRE_BEACON_LOST: |
| 928 |
mwifiex_dbg(adapter, EVENT, "event: Pre-Beacon Lost\n"); |
| 929 |
break; |
| 930 |
case EVENT_IBSS_COALESCED: |
| 931 |
mwifiex_dbg(adapter, EVENT, "event: IBSS_COALESCED\n"); |
| 932 |
ret = mwifiex_send_cmd(priv, |
| 933 |
HostCmd_CMD_802_11_IBSS_COALESCING_STATUS, |
| 934 |
HostCmd_ACT_GEN_GET, 0, NULL, false); |
| 935 |
break; |
| 936 |
case EVENT_IBSS_STA_CONNECT: |
| 937 |
ether_addr_copy(ibss_sta_addr, adapter->event_body + 2); |
| 938 |
mwifiex_dbg(adapter, EVENT, "event: IBSS_STA_CONNECT %pM\n", |
| 939 |
ibss_sta_addr); |
| 940 |
sta_ptr = mwifiex_add_sta_entry(priv, ibss_sta_addr); |
| 941 |
if (sta_ptr && adapter->adhoc_11n_enabled) { |
| 942 |
mwifiex_check_ibss_peer_capabilities(priv, sta_ptr, |
| 943 |
adapter->event_skb); |
| 944 |
if (sta_ptr->is_11n_enabled) |
| 945 |
for (i = 0; i < MAX_NUM_TID; i++) |
| 946 |
sta_ptr->ampdu_sta[i] = |
| 947 |
priv->aggr_prio_tbl[i].ampdu_user; |
| 948 |
else |
| 949 |
for (i = 0; i < MAX_NUM_TID; i++) |
| 950 |
sta_ptr->ampdu_sta[i] = |
| 951 |
BA_STREAM_NOT_ALLOWED; |
| 952 |
memset(sta_ptr->rx_seq, 0xff, sizeof(sta_ptr->rx_seq)); |
| 953 |
} |
| 954 |
|
| 955 |
break; |
| 956 |
case EVENT_IBSS_STA_DISCONNECT: |
| 957 |
ether_addr_copy(ibss_sta_addr, adapter->event_body + 2); |
| 958 |
mwifiex_dbg(adapter, EVENT, "event: IBSS_STA_DISCONNECT %pM\n", |
| 959 |
ibss_sta_addr); |
| 960 |
sta_ptr = mwifiex_get_sta_entry(priv, ibss_sta_addr); |
| 961 |
if (sta_ptr && sta_ptr->is_11n_enabled) { |
| 962 |
mwifiex_11n_del_rx_reorder_tbl_by_ta(priv, |
| 963 |
ibss_sta_addr); |
| 964 |
mwifiex_del_tx_ba_stream_tbl_by_ra(priv, ibss_sta_addr); |
| 965 |
} |
| 966 |
mwifiex_wmm_del_peer_ra_list(priv, ibss_sta_addr); |
| 967 |
mwifiex_del_sta_entry(priv, ibss_sta_addr); |
| 968 |
break; |
| 969 |
case EVENT_ADDBA: |
| 970 |
mwifiex_dbg(adapter, EVENT, "event: ADDBA Request\n"); |
| 971 |
mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_RSP, |
| 972 |
HostCmd_ACT_GEN_SET, 0, |
| 973 |
adapter->event_body, false); |
| 974 |
break; |
| 975 |
case EVENT_DELBA: |
| 976 |
mwifiex_dbg(adapter, EVENT, "event: DELBA Request\n"); |
| 977 |
mwifiex_11n_delete_ba_stream(priv, adapter->event_body); |
| 978 |
break; |
| 979 |
case EVENT_BA_STREAM_TIEMOUT: |
| 980 |
mwifiex_dbg(adapter, EVENT, "event: BA Stream timeout\n"); |
| 981 |
mwifiex_11n_ba_stream_timeout(priv, |
| 982 |
(struct host_cmd_ds_11n_batimeout |
| 983 |
*) |
| 984 |
adapter->event_body); |
| 985 |
break; |
| 986 |
case EVENT_AMSDU_AGGR_CTRL: |
| 987 |
ctrl = get_unaligned_le16(adapter->event_body); |
| 988 |
mwifiex_dbg(adapter, EVENT, |
| 989 |
"event: AMSDU_AGGR_CTRL %d\n", ctrl); |
| 990 |
|
| 991 |
adapter->tx_buf_size = |
| 992 |
min_t(u16, adapter->curr_tx_buf_size, ctrl); |
| 993 |
mwifiex_dbg(adapter, EVENT, "event: tx_buf_size %d\n", |
| 994 |
adapter->tx_buf_size); |
| 995 |
break; |
| 996 |
|
| 997 |
case EVENT_WEP_ICV_ERR: |
| 998 |
mwifiex_dbg(adapter, EVENT, "event: WEP ICV error\n"); |
| 999 |
break; |
| 1000 |
|
| 1001 |
case EVENT_BW_CHANGE: |
| 1002 |
mwifiex_dbg(adapter, EVENT, "event: BW Change\n"); |
| 1003 |
break; |
| 1004 |
|
| 1005 |
case EVENT_HOSTWAKE_STAIE: |
| 1006 |
mwifiex_dbg(adapter, EVENT, |
| 1007 |
"event: HOSTWAKE_STAIE %d\n", eventcause); |
| 1008 |
break; |
| 1009 |
|
| 1010 |
case EVENT_REMAIN_ON_CHAN_EXPIRED: |
| 1011 |
mwifiex_dbg(adapter, EVENT, |
| 1012 |
"event: Remain on channel expired\n"); |
| 1013 |
|
| 1014 |
if (adapter->host_mlme_enabled && |
| 1015 |
(priv->auth_flag & HOST_MLME_AUTH_PENDING)) { |
| 1016 |
priv->auth_flag = 0; |
| 1017 |
priv->auth_alg = WLAN_AUTH_NONE; |
| 1018 |
} else { |
| 1019 |
cfg80211_remain_on_channel_expired(&priv->wdev, |
| 1020 |
priv->roc_cfg.cookie, |
| 1021 |
&priv->roc_cfg.chan, |
| 1022 |
GFP_ATOMIC); |
| 1023 |
} |
| 1024 |
|
| 1025 |
memset(&priv->roc_cfg, 0x00, sizeof(struct mwifiex_roc_cfg)); |
| 1026 |
|
| 1027 |
break; |
| 1028 |
|
| 1029 |
case EVENT_CHANNEL_SWITCH_ANN: |
| 1030 |
mwifiex_dbg(adapter, EVENT, "event: Channel Switch Announcement\n"); |
| 1031 |
priv->csa_expire_time = |
| 1032 |
jiffies + msecs_to_jiffies(DFS_CHAN_MOVE_TIME); |
| 1033 |
priv->csa_chan = priv->curr_bss_params.bss_descriptor.channel; |
| 1034 |
ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_DEAUTHENTICATE, |
| 1035 |
HostCmd_ACT_GEN_SET, 0, |
| 1036 |
priv->curr_bss_params.bss_descriptor.mac_address, |
| 1037 |
false); |
| 1038 |
break; |
| 1039 |
|
| 1040 |
case EVENT_TDLS_GENERIC_EVENT: |
| 1041 |
ret = mwifiex_parse_tdls_event(priv, adapter->event_skb); |
| 1042 |
break; |
| 1043 |
|
| 1044 |
case EVENT_TX_DATA_PAUSE: |
| 1045 |
mwifiex_dbg(adapter, EVENT, "event: TX DATA PAUSE\n"); |
| 1046 |
mwifiex_process_tx_pause_event(priv, adapter->event_skb); |
| 1047 |
break; |
| 1048 |
|
| 1049 |
case EVENT_MULTI_CHAN_INFO: |
| 1050 |
mwifiex_dbg(adapter, EVENT, "event: multi-chan info\n"); |
| 1051 |
mwifiex_process_multi_chan_event(priv, adapter->event_skb); |
| 1052 |
break; |
| 1053 |
|
| 1054 |
case EVENT_TX_STATUS_REPORT: |
| 1055 |
mwifiex_dbg(adapter, EVENT, "event: TX_STATUS Report\n"); |
| 1056 |
mwifiex_parse_tx_status_event(priv, adapter->event_body); |
| 1057 |
break; |
| 1058 |
|
| 1059 |
case EVENT_CHANNEL_REPORT_RDY: |
| 1060 |
mwifiex_dbg(adapter, EVENT, "event: Channel Report\n"); |
| 1061 |
ret = mwifiex_11h_handle_chanrpt_ready(priv, |
| 1062 |
adapter->event_skb); |
| 1063 |
break; |
| 1064 |
case EVENT_RADAR_DETECTED: |
| 1065 |
mwifiex_dbg(adapter, EVENT, "event: Radar detected\n"); |
| 1066 |
ret = mwifiex_11h_handle_radar_detected(priv, |
| 1067 |
adapter->event_skb); |
| 1068 |
break; |
| 1069 |
case EVENT_BT_COEX_WLAN_PARA_CHANGE: |
| 1070 |
dev_dbg(adapter->dev, "EVENT: BT coex wlan param update\n"); |
| 1071 |
if (adapter->ignore_btcoex_events) |
| 1072 |
break; |
| 1073 |
|
| 1074 |
mwifiex_bt_coex_wlan_param_update_event(priv, |
| 1075 |
adapter->event_skb); |
| 1076 |
break; |
| 1077 |
case EVENT_RXBA_SYNC: |
| 1078 |
dev_dbg(adapter->dev, "EVENT: RXBA_SYNC\n"); |
| 1079 |
mwifiex_11n_rxba_sync_event(priv, adapter->event_body, |
| 1080 |
adapter->event_skb->len - |
| 1081 |
sizeof(eventcause)); |
| 1082 |
break; |
| 1083 |
case EVENT_FW_DUMP_INFO: |
| 1084 |
mwifiex_dbg(adapter, EVENT, "event: firmware debug info\n"); |
| 1085 |
mwifiex_fw_dump_info_event(priv, adapter->event_skb); |
| 1086 |
break; |
| 1087 |
/* Debugging event; not used, but let's not print an ERROR for it. */ |
| 1088 |
case EVENT_UNKNOWN_DEBUG: |
| 1089 |
mwifiex_dbg(adapter, EVENT, "event: debug\n"); |
| 1090 |
break; |
| 1091 |
default: |
| 1092 |
mwifiex_dbg(adapter, ERROR, "event: unknown event id: %#x\n", |
| 1093 |
eventcause); |
| 1094 |
break; |
| 1095 |
} |
| 1096 |
|
| 1097 |
return ret; |
| 1098 |
} |