drivers/net/wireless/marvell/mwifiex/sta_event.c

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