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