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