sta_event.c 25.8 KB
Newer Older
1 2 3
/*
 * Marvell Wireless LAN device driver: station event handling
 *
4
 * Copyright (C) 2011-2014, Marvell International Ltd.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */

#include "decl.h"
#include "ioctl.h"
#include "util.h"
#include "fw.h"
#include "main.h"
#include "wmm.h"
#include "11n.h"

/*
 * This function resets the connection state.
 *
 * The function is invoked after receiving a disconnect event from firmware,
 * and performs the following actions -
 *      - Set media status to disconnected
 *      - Clean up Tx and Rx packets
 *      - Resets SNR/NF/RSSI value in driver
 *      - Resets security configurations in driver
 *      - Enables auto data rate
 *      - Saves the previous SSID and BSSID so that they can
 *        be used for re-association, if required
 *      - Erases current SSID and BSSID information
 *      - Sends a disconnect event to upper layers/applications.
 */
43 44
void mwifiex_reset_connect_state(struct mwifiex_private *priv, u16 reason_code,
				 bool from_ap)
45 46 47 48 49 50
{
	struct mwifiex_adapter *adapter = priv->adapter;

	if (!priv->media_connected)
		return;

51 52
	mwifiex_dbg(adapter, INFO,
		    "info: handles disconnect event\n");
53 54 55 56

	priv->media_connected = false;

	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 62
		mwifiex_disable_all_tdls_links(priv);

63 64 65 66
		if (priv->adapter->auto_tdls)
			mwifiex_clean_auto_tdls(priv);
	}

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	/* Free Tx and Rx packets, report disconnect to upper layer */
	mwifiex_clean_txrx(priv);

	/* Reset SNR/NF/RSSI values */
	priv->data_rssi_last = 0;
	priv->data_nf_last = 0;
	priv->data_rssi_avg = 0;
	priv->data_nf_avg = 0;
	priv->bcn_rssi_last = 0;
	priv->bcn_nf_last = 0;
	priv->bcn_rssi_avg = 0;
	priv->bcn_nf_avg = 0;
	priv->rxpd_rate = 0;
	priv->rxpd_htinfo = 0;
	priv->sec_info.wpa_enabled = false;
	priv->sec_info.wpa2_enabled = false;
	priv->wpa_ie_len = 0;

	priv->sec_info.wapi_enabled = false;
	priv->wapi_ie_len = 0;
	priv->sec_info.wapi_key_on = false;

89
	priv->sec_info.encryption_mode = 0;
90 91 92 93 94

	/* Enable auto data rate */
	priv->is_data_rate_auto = true;
	priv->data_rate = 0;

95 96 97
	priv->assoc_resp_ht_param = 0;
	priv->ht_param_present = false;

98 99 100 101
	if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
	     GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) && priv->hist_data)
		mwifiex_hist_data_reset(priv);

102
	if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
103 104 105 106 107 108 109 110 111
		priv->adhoc_state = ADHOC_IDLE;
		priv->adhoc_is_link_sensed = false;
	}

	/*
	 * Memorize the previous SSID and BSSID so
	 * it could be used for re-assoc
	 */

112 113 114
	mwifiex_dbg(adapter, INFO,
		    "info: previous SSID=%s, SSID len=%u\n",
		    priv->prev_ssid.ssid, priv->prev_ssid.ssid_len);
115

116 117 118 119
	mwifiex_dbg(adapter, INFO,
		    "info: current SSID=%s, SSID len=%u\n",
		    priv->curr_bss_params.bss_descriptor.ssid.ssid,
		    priv->curr_bss_params.bss_descriptor.ssid.ssid_len);
120 121 122

	memcpy(&priv->prev_ssid,
	       &priv->curr_bss_params.bss_descriptor.ssid,
123
	       sizeof(struct cfg80211_ssid));
124 125 126 127 128 129 130 131 132 133

	memcpy(priv->prev_bssid,
	       priv->curr_bss_params.bss_descriptor.mac_address, ETH_ALEN);

	/* Need to erase the current SSID and BSSID info */
	memset(&priv->curr_bss_params, 0x00, sizeof(priv->curr_bss_params));

	adapter->tx_lock_flag = false;
	adapter->pps_uapsd_mode = false;

134
	if (adapter->is_cmd_timedout && adapter->curr_cmd)
135 136
		return;
	priv->media_connected = false;
137 138 139
	mwifiex_dbg(adapter, MSG,
		    "info: successfully disconnected from %pM: reason code %d\n",
		    priv->cfg_bssid, reason_code);
140 141
	if (priv->bss_mode == NL80211_IFTYPE_STATION ||
	    priv->bss_mode == NL80211_IFTYPE_P2P_CLIENT) {
142
		cfg80211_disconnected(priv->netdev, reason_code, NULL, 0,
143
				      !from_ap, GFP_KERNEL);
144
	}
145
	eth_zero_addr(priv->cfg_bssid);
146

147
	mwifiex_stop_net_dev_queue(priv->netdev, adapter);
148 149
	if (netif_carrier_ok(priv->netdev))
		netif_carrier_off(priv->netdev);
150 151 152

	mwifiex_send_cmd(priv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG,
			 HostCmd_ACT_GEN_REMOVE, 0, NULL, false);
153 154
}

155 156 157
static int mwifiex_parse_tdls_event(struct mwifiex_private *priv,
				    struct sk_buff *event_skb)
{
158
	int ret = 0;
159 160 161 162
	struct mwifiex_adapter *adapter = priv->adapter;
	struct mwifiex_sta_node *sta_ptr;
	struct mwifiex_tdls_generic_event *tdls_evt =
			(void *)event_skb->data + sizeof(adapter->event_cause);
163
	u8 *mac = tdls_evt->peer_mac;
164 165 166 167

	/* reserved 2 bytes are not mandatory in tdls event */
	if (event_skb->len < (sizeof(struct mwifiex_tdls_generic_event) -
			      sizeof(u16) - sizeof(adapter->event_cause))) {
168
		mwifiex_dbg(adapter, ERROR, "Invalid event length!\n");
169 170 171 172 173
		return -1;
	}

	sta_ptr = mwifiex_get_sta_entry(priv, tdls_evt->peer_mac);
	if (!sta_ptr) {
174
		mwifiex_dbg(adapter, ERROR, "cannot get sta entry!\n");
175 176 177 178 179 180 181 182 183 184 185
		return -1;
	}

	switch (le16_to_cpu(tdls_evt->type)) {
	case TDLS_EVENT_LINK_TEAR_DOWN:
		cfg80211_tdls_oper_request(priv->netdev,
					   tdls_evt->peer_mac,
					   NL80211_TDLS_TEARDOWN,
					   le16_to_cpu(tdls_evt->u.reason_code),
					   GFP_KERNEL);
		break;
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
	case TDLS_EVENT_CHAN_SWITCH_RESULT:
		mwifiex_dbg(adapter, EVENT, "tdls channel switch result :\n");
		mwifiex_dbg(adapter, EVENT,
			    "status=0x%x, reason=0x%x cur_chan=%d\n",
			    tdls_evt->u.switch_result.status,
			    tdls_evt->u.switch_result.reason,
			    tdls_evt->u.switch_result.cur_chan);

		/* tdls channel switch failed */
		if (tdls_evt->u.switch_result.status != 0) {
			switch (tdls_evt->u.switch_result.cur_chan) {
			case TDLS_BASE_CHANNEL:
				sta_ptr->tdls_status = TDLS_IN_BASE_CHAN;
				break;
			case TDLS_OFF_CHANNEL:
				sta_ptr->tdls_status = TDLS_IN_OFF_CHAN;
				break;
			default:
				break;
			}
			return ret;
		}

		/* tdls channel switch success */
		switch (tdls_evt->u.switch_result.cur_chan) {
		case TDLS_BASE_CHANNEL:
			if (sta_ptr->tdls_status == TDLS_IN_BASE_CHAN)
				break;
			mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac,
								  false);
			sta_ptr->tdls_status = TDLS_IN_BASE_CHAN;
			break;
		case TDLS_OFF_CHANNEL:
			if (sta_ptr->tdls_status == TDLS_IN_OFF_CHAN)
				break;
			mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac,
								  true);
			sta_ptr->tdls_status = TDLS_IN_OFF_CHAN;
			break;
		default:
			break;
		}

		break;
	case TDLS_EVENT_START_CHAN_SWITCH:
		mwifiex_dbg(adapter, EVENT, "tdls start channel switch...\n");
		sta_ptr->tdls_status = TDLS_CHAN_SWITCHING;
		break;
	case TDLS_EVENT_CHAN_SWITCH_STOPPED:
		mwifiex_dbg(adapter, EVENT,
			    "tdls chan switch stopped, reason=%d\n",
			    tdls_evt->u.cs_stop_reason);
		break;
239 240 241 242
	default:
		break;
	}

243
	return ret;
244 245
}

246 247
static void mwifiex_process_uap_tx_pause(struct mwifiex_private *priv,
					 struct mwifiex_ie_types_header *tlv)
248
{
249
	struct mwifiex_tx_pause_tlv *tp;
250 251 252
	struct mwifiex_sta_node *sta_ptr;
	unsigned long flags;

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
	tp = (void *)tlv;
	mwifiex_dbg(priv->adapter, EVENT,
		    "uap tx_pause: %pM pause=%d, pkts=%d\n",
		    tp->peermac, tp->tx_pause,
		    tp->pkt_cnt);

	if (ether_addr_equal(tp->peermac, priv->netdev->dev_addr)) {
		if (tp->tx_pause)
			priv->port_open = false;
		else
			priv->port_open = true;
	} else if (is_multicast_ether_addr(tp->peermac)) {
		mwifiex_update_ralist_tx_pause(priv, tp->peermac, tp->tx_pause);
	} else {
		spin_lock_irqsave(&priv->sta_list_spinlock, flags);
		sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac);
		spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);

		if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) {
			sta_ptr->tx_pause = tp->tx_pause;
			mwifiex_update_ralist_tx_pause(priv, tp->peermac,
						       tp->tx_pause);
		}
	}
}

static void mwifiex_process_sta_tx_pause(struct mwifiex_private *priv,
					 struct mwifiex_ie_types_header *tlv)
{
	struct mwifiex_tx_pause_tlv *tp;
	struct mwifiex_sta_node *sta_ptr;
	int status;
	unsigned long flags;

	tp = (void *)tlv;
	mwifiex_dbg(priv->adapter, EVENT,
		    "sta tx_pause: %pM pause=%d, pkts=%d\n",
		    tp->peermac, tp->tx_pause,
		    tp->pkt_cnt);

	if (ether_addr_equal(tp->peermac, priv->cfg_bssid)) {
		if (tp->tx_pause)
			priv->port_open = false;
		else
			priv->port_open = true;
	} else {
		if (!ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info))
			return;

		status = mwifiex_get_tdls_link_status(priv, tp->peermac);
		if (mwifiex_is_tdls_link_setup(status)) {
			spin_lock_irqsave(&priv->sta_list_spinlock, flags);
			sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac);
			spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);

			if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) {
				sta_ptr->tx_pause = tp->tx_pause;
				mwifiex_update_ralist_tx_pause(priv,
							       tp->peermac,
							       tp->tx_pause);
			}
		}
	}
}

318 319 320 321
void mwifiex_process_multi_chan_event(struct mwifiex_private *priv,
				      struct sk_buff *event_skb)
{
	struct mwifiex_ie_types_multi_chan_info *chan_info;
322 323 324 325 326 327
	struct mwifiex_ie_types_mc_group_info *grp_info;
	struct mwifiex_adapter *adapter = priv->adapter;
	struct mwifiex_ie_types_header *tlv;
	u16 tlv_buf_left, tlv_type, tlv_len;
	int intf_num, bss_type, bss_num, i;
	struct mwifiex_private *intf_priv;
328

329
	tlv_buf_left = event_skb->len - sizeof(u32);
330 331
	chan_info = (void *)event_skb->data + sizeof(u32);

332 333 334
	if (le16_to_cpu(chan_info->header.type) != TLV_TYPE_MULTI_CHAN_INFO ||
	    tlv_buf_left < sizeof(struct mwifiex_ie_types_multi_chan_info)) {
		mwifiex_dbg(adapter, ERROR,
335 336 337 338
			    "unknown TLV in chan_info event\n");
		return;
	}

339 340 341
	adapter->usb_mc_status = le16_to_cpu(chan_info->status);
	mwifiex_dbg(adapter, EVENT, "multi chan operation %s\n",
		    adapter->usb_mc_status ? "started" : "over");
342

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	tlv_buf_left -= sizeof(struct mwifiex_ie_types_multi_chan_info);
	tlv = (struct mwifiex_ie_types_header *)chan_info->tlv_buffer;

	while (tlv_buf_left >= (int)sizeof(struct mwifiex_ie_types_header)) {
		tlv_type = le16_to_cpu(tlv->type);
		tlv_len  = le16_to_cpu(tlv->len);
		if ((sizeof(struct mwifiex_ie_types_header) + tlv_len) >
		    tlv_buf_left) {
			mwifiex_dbg(adapter, ERROR, "wrong tlv: tlvLen=%d,\t"
				    "tlvBufLeft=%d\n", tlv_len, tlv_buf_left);
			break;
		}
		if (tlv_type != TLV_TYPE_MC_GROUP_INFO) {
			mwifiex_dbg(adapter, ERROR, "wrong tlv type: 0x%x\n",
				    tlv_type);
			break;
		}

		grp_info = (struct mwifiex_ie_types_mc_group_info *)tlv;
		intf_num = grp_info->intf_num;
		for (i = 0; i < intf_num; i++) {
			bss_type = grp_info->bss_type_numlist[i] >> 4;
			bss_num = grp_info->bss_type_numlist[i] & BSS_NUM_MASK;
			intf_priv = mwifiex_get_priv_by_id(adapter, bss_num,
							   bss_type);
			if (!intf_priv) {
				mwifiex_dbg(adapter, ERROR,
					    "Invalid bss_type bss_num\t"
					    "in multi channel event\n");
				continue;
			}
			if (adapter->iface_type == MWIFIEX_USB) {
				u8 ep;

				ep = grp_info->hid_num.usb_ep_num;
				if (ep == MWIFIEX_USB_EP_DATA ||
				    ep == MWIFIEX_USB_EP_DATA_CH2)
					intf_priv->usb_port = ep;
			}
		}

		tlv_buf_left -= sizeof(struct mwifiex_ie_types_header) +
				tlv_len;
		tlv = (void *)((u8 *)tlv + tlv_len +
			       sizeof(struct mwifiex_ie_types_header));
388
	}
389

390 391 392 393 394
	if (adapter->iface_type == MWIFIEX_USB) {
		adapter->tx_lock_flag = true;
		adapter->usb_mc_setup = true;
		mwifiex_multi_chan_resync(adapter);
	}
395 396
}

397 398 399 400 401 402
void mwifiex_process_tx_pause_event(struct mwifiex_private *priv,
				    struct sk_buff *event_skb)
{
	struct mwifiex_ie_types_header *tlv;
	u16 tlv_type, tlv_len;
	int tlv_buf_left;
403

404 405 406 407
	if (!priv->media_connected) {
		mwifiex_dbg(priv->adapter, ERROR,
			    "tx_pause event while disconnected; bss_role=%d\n",
			    priv->bss_role);
408
		return;
409
	}
410 411 412

	tlv_buf_left = event_skb->len - sizeof(u32);
	tlv = (void *)event_skb->data + sizeof(u32);
413

414 415 416 417
	while (tlv_buf_left >= (int)sizeof(struct mwifiex_ie_types_header)) {
		tlv_type = le16_to_cpu(tlv->type);
		tlv_len  = le16_to_cpu(tlv->len);
		if ((sizeof(struct mwifiex_ie_types_header) + tlv_len) >
418
		    tlv_buf_left) {
419 420 421 422 423 424
			mwifiex_dbg(priv->adapter, ERROR,
				    "wrong tlv: tlvLen=%d, tlvBufLeft=%d\n",
				    tlv_len, tlv_buf_left);
			break;
		}
		if (tlv_type == TLV_TYPE_TX_PAUSE) {
425 426 427 428
			if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA)
				mwifiex_process_sta_tx_pause(priv, tlv);
			else
				mwifiex_process_uap_tx_pause(priv, tlv);
429 430 431 432 433 434 435
		}

		tlv_buf_left -= sizeof(struct mwifiex_ie_types_header) +
				tlv_len;
		tlv = (void *)((u8 *)tlv + tlv_len +
			       sizeof(struct mwifiex_ie_types_header));
	}
436

437 438
}

439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
/*
* This function handles coex events generated by firmware
*/
void mwifiex_bt_coex_wlan_param_update_event(struct mwifiex_private *priv,
					     struct sk_buff *event_skb)
{
	struct mwifiex_adapter *adapter = priv->adapter;
	struct mwifiex_ie_types_header *tlv;
	struct mwifiex_ie_types_btcoex_aggr_win_size *winsizetlv;
	struct mwifiex_ie_types_btcoex_scan_time *scantlv;
	s32 len = event_skb->len - sizeof(u32);
	u8 *cur_ptr = event_skb->data + sizeof(u32);
	u16 tlv_type, tlv_len;

	while (len >= sizeof(struct mwifiex_ie_types_header)) {
		tlv = (struct mwifiex_ie_types_header *)cur_ptr;
		tlv_len = le16_to_cpu(tlv->len);
		tlv_type = le16_to_cpu(tlv->type);

		if ((tlv_len + sizeof(struct mwifiex_ie_types_header)) > len)
			break;
		switch (tlv_type) {
		case TLV_BTCOEX_WL_AGGR_WINSIZE:
			winsizetlv =
			    (struct mwifiex_ie_types_btcoex_aggr_win_size *)tlv;
			adapter->coex_win_size = winsizetlv->coex_win_size;
			adapter->coex_tx_win_size =
				winsizetlv->tx_win_size;
			adapter->coex_rx_win_size =
				winsizetlv->rx_win_size;
			mwifiex_coex_ampdu_rxwinsize(adapter);
			mwifiex_update_ampdu_txwinsize(adapter);
			break;

		case TLV_BTCOEX_WL_SCANTIME:
			scantlv =
			    (struct mwifiex_ie_types_btcoex_scan_time *)tlv;
			adapter->coex_scan = scantlv->coex_scan;
			adapter->coex_min_scan_time = scantlv->min_scan_time;
			adapter->coex_max_scan_time = scantlv->max_scan_time;
			break;

		default:
			break;
		}

		len -= tlv_len + sizeof(struct mwifiex_ie_types_header);
		cur_ptr += tlv_len +
			sizeof(struct mwifiex_ie_types_header);
	}

	dev_dbg(adapter->dev, "coex_scan=%d min_scan=%d coex_win=%d, tx_win=%d rx_win=%d\n",
		adapter->coex_scan, adapter->coex_min_scan_time,
		adapter->coex_win_size, adapter->coex_tx_win_size,
		adapter->coex_rx_win_size);
}

496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
/*
 * This function handles events generated by firmware.
 *
 * This is a generic function and handles all events.
 *
 * Event specific routines are called by this function based
 * upon the generated event cause.
 *
 * For the following events, the function just forwards them to upper
 * layers, optionally recording the change -
 *      - EVENT_LINK_SENSED
 *      - EVENT_MIC_ERR_UNICAST
 *      - EVENT_MIC_ERR_MULTICAST
 *      - EVENT_PORT_RELEASE
 *      - EVENT_RSSI_LOW
 *      - EVENT_SNR_LOW
 *      - EVENT_MAX_FAIL
 *      - EVENT_RSSI_HIGH
 *      - EVENT_SNR_HIGH
 *      - EVENT_DATA_RSSI_LOW
 *      - EVENT_DATA_SNR_LOW
 *      - EVENT_DATA_RSSI_HIGH
 *      - EVENT_DATA_SNR_HIGH
 *      - EVENT_LINK_QUALITY
 *      - EVENT_PRE_BEACON_LOST
 *      - EVENT_IBSS_COALESCED
 *      - EVENT_WEP_ICV_ERR
 *      - EVENT_BW_CHANGE
 *      - EVENT_HOSTWAKE_STAIE
  *
 * For the following events, no action is taken -
 *      - EVENT_MIB_CHANGED
 *      - EVENT_INIT_DONE
 *      - EVENT_DUMMY_HOST_WAKEUP_SIGNAL
 *
 * Rest of the supported events requires driver handling -
 *      - EVENT_DEAUTHENTICATED
 *      - EVENT_DISASSOCIATED
 *      - EVENT_LINK_LOST
 *      - EVENT_PS_SLEEP
 *      - EVENT_PS_AWAKE
 *      - EVENT_DEEP_SLEEP_AWAKE
 *      - EVENT_HS_ACT_REQ
 *      - EVENT_ADHOC_BCN_LOST
 *      - EVENT_BG_SCAN_REPORT
 *      - EVENT_WMM_STATUS_CHANGE
 *      - EVENT_ADDBA
 *      - EVENT_DELBA
 *      - EVENT_BA_STREAM_TIEMOUT
 *      - EVENT_AMSDU_AGGR_CTRL
 */
int mwifiex_process_sta_event(struct mwifiex_private *priv)
{
	struct mwifiex_adapter *adapter = priv->adapter;
550
	int ret = 0;
551
	u32 eventcause = adapter->event_cause;
552
	u16 ctrl, reason_code;
553 554 555

	switch (eventcause) {
	case EVENT_DUMMY_HOST_WAKEUP_SIGNAL:
556 557
		mwifiex_dbg(adapter, ERROR,
			    "invalid EVENT: DUMMY_HOST_WAKEUP_SIGNAL, ignore it\n");
558 559
		break;
	case EVENT_LINK_SENSED:
560
		mwifiex_dbg(adapter, EVENT, "event: LINK_SENSED\n");
561 562
		if (!netif_carrier_ok(priv->netdev))
			netif_carrier_on(priv->netdev);
563
		mwifiex_wake_up_net_dev_queue(priv->netdev, adapter);
564 565 566
		break;

	case EVENT_DEAUTHENTICATED:
567
		mwifiex_dbg(adapter, EVENT, "event: Deauthenticated\n");
568
		if (priv->wps.session_enable) {
569 570
			mwifiex_dbg(adapter, INFO,
				    "info: receive deauth event in wps session\n");
571 572
			break;
		}
573
		adapter->dbg.num_event_deauth++;
574 575 576
		if (priv->media_connected) {
			reason_code =
				le16_to_cpu(*(__le16 *)adapter->event_body);
577
			mwifiex_reset_connect_state(priv, reason_code, true);
578
		}
579 580 581
		break;

	case EVENT_DISASSOCIATED:
582
		mwifiex_dbg(adapter, EVENT, "event: Disassociated\n");
583
		if (priv->wps.session_enable) {
584 585
			mwifiex_dbg(adapter, INFO,
				    "info: receive disassoc event in wps session\n");
586 587
			break;
		}
588
		adapter->dbg.num_event_disassoc++;
589 590 591
		if (priv->media_connected) {
			reason_code =
				le16_to_cpu(*(__le16 *)adapter->event_body);
592
			mwifiex_reset_connect_state(priv, reason_code, true);
593
		}
594 595 596
		break;

	case EVENT_LINK_LOST:
597
		mwifiex_dbg(adapter, EVENT, "event: Link lost\n");
598
		adapter->dbg.num_event_link_lost++;
599 600 601
		if (priv->media_connected) {
			reason_code =
				le16_to_cpu(*(__le16 *)adapter->event_body);
602
			mwifiex_reset_connect_state(priv, reason_code, true);
603
		}
604 605 606
		break;

	case EVENT_PS_SLEEP:
607
		mwifiex_dbg(adapter, EVENT, "info: EVENT: SLEEP\n");
608 609 610 611 612 613 614

		adapter->ps_state = PS_STATE_PRE_SLEEP;

		mwifiex_check_ps_cond(adapter);
		break;

	case EVENT_PS_AWAKE:
615
		mwifiex_dbg(adapter, EVENT, "info: EVENT: AWAKE\n");
616 617 618
		if (!adapter->pps_uapsd_mode &&
		    (priv->port_open ||
		     (priv->bss_mode == NL80211_IFTYPE_ADHOC)) &&
619
		    priv->media_connected && adapter->sleep_period.period) {
620 621 622
			adapter->pps_uapsd_mode = true;
			mwifiex_dbg(adapter, EVENT,
				    "event: PPS/UAPSD mode activated\n");
623 624 625 626
		}
		adapter->tx_lock_flag = false;
		if (adapter->pps_uapsd_mode && adapter->gen_null_pkt) {
			if (mwifiex_check_last_packet_indication(priv)) {
627 628 629
				if (adapter->data_sent ||
				    (adapter->if_ops.is_port_ready &&
				     !adapter->if_ops.is_port_ready(priv))) {
630 631 632
					adapter->ps_state = PS_STATE_AWAKE;
					adapter->pm_wakeup_card_req = false;
					adapter->pm_wakeup_fw_try = false;
633
					del_timer(&adapter->wakeup_timer);
634 635 636 637 638 639
					break;
				}
				if (!mwifiex_send_null_packet
					(priv,
					 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
					 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET))
640 641 642 643 644 645 646 647
						adapter->ps_state =
							PS_STATE_SLEEP;
					return 0;
			}
		}
		adapter->ps_state = PS_STATE_AWAKE;
		adapter->pm_wakeup_card_req = false;
		adapter->pm_wakeup_fw_try = false;
648
		del_timer(&adapter->wakeup_timer);
649 650 651 652 653

		break;

	case EVENT_DEEP_SLEEP_AWAKE:
		adapter->if_ops.wakeup_complete(adapter);
654
		mwifiex_dbg(adapter, EVENT, "event: DS_AWAKE\n");
655 656 657 658 659
		if (adapter->is_deep_sleep)
			adapter->is_deep_sleep = false;
		break;

	case EVENT_HS_ACT_REQ:
660
		mwifiex_dbg(adapter, EVENT, "event: HS_ACT_REQ\n");
661 662
		ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_HS_CFG_ENH,
				       0, 0, NULL, false);
663 664 665
		break;

	case EVENT_MIC_ERR_UNICAST:
666
		mwifiex_dbg(adapter, EVENT, "event: UNICAST MIC ERROR\n");
667 668 669
		cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid,
					     NL80211_KEYTYPE_PAIRWISE,
					     -1, NULL, GFP_KERNEL);
670 671 672
		break;

	case EVENT_MIC_ERR_MULTICAST:
673
		mwifiex_dbg(adapter, EVENT, "event: MULTICAST MIC ERROR\n");
674 675 676
		cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid,
					     NL80211_KEYTYPE_GROUP,
					     -1, NULL, GFP_KERNEL);
677 678 679 680 681 682
		break;
	case EVENT_MIB_CHANGED:
	case EVENT_INIT_DONE:
		break;

	case EVENT_ADHOC_BCN_LOST:
683
		mwifiex_dbg(adapter, EVENT, "event: ADHOC_BCN_LOST\n");
684 685
		priv->adhoc_is_link_sensed = false;
		mwifiex_clean_txrx(priv);
686
		mwifiex_stop_net_dev_queue(priv->netdev, adapter);
687 688 689 690 691
		if (netif_carrier_ok(priv->netdev))
			netif_carrier_off(priv->netdev);
		break;

	case EVENT_BG_SCAN_REPORT:
692
		mwifiex_dbg(adapter, EVENT, "event: BGS_REPORT\n");
693 694
		ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_BG_SCAN_QUERY,
				       HostCmd_ACT_GEN_GET, 0, NULL, false);
695 696
		break;

697 698 699 700 701 702 703
	case EVENT_BG_SCAN_STOPPED:
		dev_dbg(adapter->dev, "event: BGS_STOPPED\n");
		cfg80211_sched_scan_stopped(priv->wdev.wiphy);
		if (priv->sched_scanning)
			priv->sched_scanning = false;
		break;

704
	case EVENT_PORT_RELEASE:
705
		mwifiex_dbg(adapter, EVENT, "event: PORT RELEASE\n");
706
		priv->port_open = true;
707 708
		break;

709
	case EVENT_EXT_SCAN_REPORT:
710
		mwifiex_dbg(adapter, EVENT, "event: EXT_SCAN Report\n");
711 712 713 714 715 716
		if (adapter->ext_scan)
			ret = mwifiex_handle_event_ext_scan_report(priv,
						adapter->event_skb->data);

		break;

717
	case EVENT_WMM_STATUS_CHANGE:
718
		mwifiex_dbg(adapter, EVENT, "event: WMM status changed\n");
719 720
		ret = mwifiex_send_cmd(priv, HostCmd_CMD_WMM_GET_STATUS,
				       0, 0, NULL, false);
721 722 723
		break;

	case EVENT_RSSI_LOW:
724 725 726
		cfg80211_cqm_rssi_notify(priv->netdev,
					 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
					 GFP_KERNEL);
727 728
		mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO,
				 HostCmd_ACT_GEN_GET, 0, NULL, false);
729
		priv->subsc_evt_rssi_state = RSSI_LOW_RECVD;
730
		mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_LOW\n");
731 732
		break;
	case EVENT_SNR_LOW:
733
		mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_LOW\n");
734 735
		break;
	case EVENT_MAX_FAIL:
736
		mwifiex_dbg(adapter, EVENT, "event: MAX_FAIL\n");
737 738
		break;
	case EVENT_RSSI_HIGH:
739 740 741
		cfg80211_cqm_rssi_notify(priv->netdev,
					 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
					 GFP_KERNEL);
742 743
		mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO,
				 HostCmd_ACT_GEN_GET, 0, NULL, false);
744
		priv->subsc_evt_rssi_state = RSSI_HIGH_RECVD;
745
		mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_HIGH\n");
746 747
		break;
	case EVENT_SNR_HIGH:
748
		mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_HIGH\n");
749 750
		break;
	case EVENT_DATA_RSSI_LOW:
751
		mwifiex_dbg(adapter, EVENT, "event: Data RSSI_LOW\n");
752 753
		break;
	case EVENT_DATA_SNR_LOW:
754
		mwifiex_dbg(adapter, EVENT, "event: Data SNR_LOW\n");
755 756
		break;
	case EVENT_DATA_RSSI_HIGH:
757
		mwifiex_dbg(adapter, EVENT, "event: Data RSSI_HIGH\n");
758 759
		break;
	case EVENT_DATA_SNR_HIGH:
760
		mwifiex_dbg(adapter, EVENT, "event: Data SNR_HIGH\n");
761 762
		break;
	case EVENT_LINK_QUALITY:
763
		mwifiex_dbg(adapter, EVENT, "event: Link Quality\n");
764 765
		break;
	case EVENT_PRE_BEACON_LOST:
766
		mwifiex_dbg(adapter, EVENT, "event: Pre-Beacon Lost\n");
767 768
		break;
	case EVENT_IBSS_COALESCED:
769
		mwifiex_dbg(adapter, EVENT, "event: IBSS_COALESCED\n");
770
		ret = mwifiex_send_cmd(priv,
771
				HostCmd_CMD_802_11_IBSS_COALESCING_STATUS,
772
				HostCmd_ACT_GEN_GET, 0, NULL, false);
773 774
		break;
	case EVENT_ADDBA:
775
		mwifiex_dbg(adapter, EVENT, "event: ADDBA Request\n");
776 777 778
		mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_RSP,
				 HostCmd_ACT_GEN_SET, 0,
				 adapter->event_body, false);
779 780
		break;
	case EVENT_DELBA:
781
		mwifiex_dbg(adapter, EVENT, "event: DELBA Request\n");
782 783 784
		mwifiex_11n_delete_ba_stream(priv, adapter->event_body);
		break;
	case EVENT_BA_STREAM_TIEMOUT:
785
		mwifiex_dbg(adapter, EVENT, "event:  BA Stream timeout\n");
786 787 788 789 790 791
		mwifiex_11n_ba_stream_timeout(priv,
					      (struct host_cmd_ds_11n_batimeout
					       *)
					      adapter->event_body);
		break;
	case EVENT_AMSDU_AGGR_CTRL:
792
		ctrl = le16_to_cpu(*(__le16 *)adapter->event_body);
793 794
		mwifiex_dbg(adapter, EVENT,
			    "event: AMSDU_AGGR_CTRL %d\n", ctrl);
795

796
		adapter->tx_buf_size =
797
				min_t(u16, adapter->curr_tx_buf_size, ctrl);
798 799
		mwifiex_dbg(adapter, EVENT, "event: tx_buf_size %d\n",
			    adapter->tx_buf_size);
800 801 802
		break;

	case EVENT_WEP_ICV_ERR:
803
		mwifiex_dbg(adapter, EVENT, "event: WEP ICV error\n");
804 805 806
		break;

	case EVENT_BW_CHANGE:
807
		mwifiex_dbg(adapter, EVENT, "event: BW Change\n");
808 809 810
		break;

	case EVENT_HOSTWAKE_STAIE:
811 812
		mwifiex_dbg(adapter, EVENT,
			    "event: HOSTWAKE_STAIE %d\n", eventcause);
813
		break;
814

815
	case EVENT_REMAIN_ON_CHAN_EXPIRED:
816 817
		mwifiex_dbg(adapter, EVENT,
			    "event: Remain on channel expired\n");
818
		cfg80211_remain_on_channel_expired(&priv->wdev,
819 820 821 822 823 824 825 826
						   priv->roc_cfg.cookie,
						   &priv->roc_cfg.chan,
						   GFP_ATOMIC);

		memset(&priv->roc_cfg, 0x00, sizeof(struct mwifiex_roc_cfg));

		break;

827
	case EVENT_CHANNEL_SWITCH_ANN:
828
		mwifiex_dbg(adapter, EVENT, "event: Channel Switch Announcement\n");
829 830 831
		priv->csa_expire_time =
				jiffies + msecs_to_jiffies(DFS_CHAN_MOVE_TIME);
		priv->csa_chan = priv->curr_bss_params.bss_descriptor.channel;
832
		ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_DEAUTHENTICATE,
833
			HostCmd_ACT_GEN_SET, 0,
834 835
			priv->curr_bss_params.bss_descriptor.mac_address,
			false);
836 837
		break;

838 839 840 841
	case EVENT_TDLS_GENERIC_EVENT:
		ret = mwifiex_parse_tdls_event(priv, adapter->event_skb);
		break;

842 843
	case EVENT_TX_DATA_PAUSE:
		mwifiex_dbg(adapter, EVENT, "event: TX DATA PAUSE\n");
844
		mwifiex_process_tx_pause_event(priv, adapter->event_skb);
845 846
		break;

847 848 849 850 851
	case EVENT_MULTI_CHAN_INFO:
		mwifiex_dbg(adapter, EVENT, "event: multi-chan info\n");
		mwifiex_process_multi_chan_event(priv, adapter->event_skb);
		break;

852
	case EVENT_TX_STATUS_REPORT:
853
		mwifiex_dbg(adapter, EVENT, "event: TX_STATUS Report\n");
854 855 856
		mwifiex_parse_tx_status_event(priv, adapter->event_body);
		break;

857
	case EVENT_CHANNEL_REPORT_RDY:
858
		mwifiex_dbg(adapter, EVENT, "event: Channel Report\n");
859 860 861
		ret = mwifiex_11h_handle_chanrpt_ready(priv,
						       adapter->event_skb);
		break;
862
	case EVENT_RADAR_DETECTED:
863
		mwifiex_dbg(adapter, EVENT, "event: Radar detected\n");
864 865 866
		ret = mwifiex_11h_handle_radar_detected(priv,
							adapter->event_skb);
		break;
867 868 869 870
	case EVENT_BT_COEX_WLAN_PARA_CHANGE:
		dev_dbg(adapter->dev, "EVENT: BT coex wlan param update\n");
		mwifiex_bt_coex_wlan_param_update_event(priv,
							adapter->event_skb);
871
		break;
872
	default:
873 874
		mwifiex_dbg(adapter, ERROR, "event: unknown event id: %#x\n",
			    eventcause);
875 876 877 878 879
		break;
	}

	return ret;
}