sta_event.c

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