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