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