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