1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#define _RTW_MLME_EXT_C_
16
17#include <linux/ieee80211.h>
18#include <asm/unaligned.h>
19
20#include <osdep_service.h>
21#include <drv_types.h>
22#include <wifi.h>
23#include <rtw_mlme_ext.h>
24#include <wlan_bssdef.h>
25#include <mlme_osdep.h>
26#include <recv_osdep.h>
27
28static u8 null_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
29
30
31
32
33unsigned char RTW_WPA_OUI[] = {0x00, 0x50, 0xf2, 0x01};
34unsigned char WMM_OUI[] = {0x00, 0x50, 0xf2, 0x02};
35unsigned char WPS_OUI[] = {0x00, 0x50, 0xf2, 0x04};
36unsigned char P2P_OUI[] = {0x50, 0x6F, 0x9A, 0x09};
37unsigned char WFD_OUI[] = {0x50, 0x6F, 0x9A, 0x0A};
38
39unsigned char WMM_INFO_OUI[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
40unsigned char WMM_PARA_OUI[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
41
42unsigned char WPA_TKIP_CIPHER[4] = {0x00, 0x50, 0xf2, 0x02};
43unsigned char RSN_TKIP_CIPHER[4] = {0x00, 0x0f, 0xac, 0x02};
44
45extern unsigned char REALTEK_96B_IE[];
46
47
48
49
50unsigned char MCS_rate_1R[16] = {0xff, 0x00, 0x0, 0x0, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
51
52
53
54
55static struct rt_channel_plan_2g RTW_ChannelPlan2G[RT_CHANNEL_DOMAIN_2G_MAX] = {
56 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 13},
57 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 13},
58 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 11},
59 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 14},
60 {{10, 11, 12, 13}, 4},
61 {{}, 0},
62};
63
64static struct rt_channel_plan_map RTW_ChannelPlanMap[RT_CHANNEL_DOMAIN_MAX] = {
65
66 {0x02},
67 {0x02},
68 {0x01},
69 {0x01},
70 {0x01},
71 {0x03},
72 {0x03},
73 {0x01},
74 {0x03},
75 {0x03},
76 {0x00},
77 {0x02},
78 {0x01},
79 {0x02},
80 {0x02},
81 {0x02},
82 {0x01},
83 {0x02},
84 {0x01},
85 {0x00},
86 {0x02},
87 {0x00},
88 {0x00},
89 {0x03},
90 {0x05},
91 {0x02},
92 {0x00},
93 {0x00},
94 {0x00},
95 {0x00},
96 {0x00},
97 {0x05},
98
99 {0x00},
100 {0x01},
101 {0x02},
102 {0x03},
103 {0x04},
104 {0x02},
105 {0x00},
106 {0x03},
107 {0x00},
108 {0x00},
109 {0x00},
110 {0x00},
111 {0x00},
112 {0x00},
113 {0x00},
114 {0x00},
115 {0x00},
116 {0x00},
117 {0x00},
118 {0x00},
119 {0x02},
120 {0x00},
121 {0x00},
122 {0x03},
123 {0x03},
124 {0x02},
125 {0x00},
126 {0x00},
127 {0x00},
128 {0x00},
129 {0x00},
130 {0x00},
131 {0x02},
132 {0x03},
133};
134
135static const struct rt_channel_plan_map RTW_CHANNEL_PLAN_MAP_REALTEK_DEFINE = {
136 0x03
137};
138
139
140
141
142
143
144
145
146int rtw_ch_set_search_ch(struct rt_channel_info *ch_set, const u32 ch)
147{
148 int i;
149
150 for (i = 0; ch_set[i].ChannelNum != 0; i++) {
151 if (ch == ch_set[i].ChannelNum)
152 break;
153 }
154
155 if (i >= ch_set[i].ChannelNum)
156 return -1;
157 return i;
158}
159
160struct xmit_frame *alloc_mgtxmitframe(struct xmit_priv *pxmitpriv)
161{
162 struct xmit_frame *pmgntframe;
163 struct xmit_buf *pxmitbuf;
164
165 pmgntframe = rtw_alloc_xmitframe(pxmitpriv);
166 if (!pmgntframe) {
167 DBG_88E("%s, alloc xmitframe fail\n", __func__);
168 return NULL;
169 }
170
171 pxmitbuf = rtw_alloc_xmitbuf_ext(pxmitpriv);
172 if (!pxmitbuf) {
173 DBG_88E("%s, alloc xmitbuf fail\n", __func__);
174 rtw_free_xmitframe(pxmitpriv, pmgntframe);
175 return NULL;
176 }
177 pmgntframe->frame_tag = MGNT_FRAMETAG;
178 pmgntframe->pxmitbuf = pxmitbuf;
179 pmgntframe->buf_addr = pxmitbuf->pbuf;
180 pxmitbuf->priv_data = pmgntframe;
181 return pmgntframe;
182}
183
184
185
186
187
188
189
190void update_mgnt_tx_rate(struct adapter *padapter, u8 rate)
191{
192 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
193
194 pmlmeext->tx_rate = rate;
195 DBG_88E("%s(): rate = %x\n", __func__, rate);
196}
197
198void update_mgntframe_attrib(struct adapter *padapter, struct pkt_attrib *pattrib)
199{
200 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
201
202 memset((u8 *)(pattrib), 0, sizeof(struct pkt_attrib));
203
204 pattrib->hdrlen = 24;
205 pattrib->nr_frags = 1;
206 pattrib->priority = 7;
207 pattrib->mac_id = 0;
208 pattrib->qsel = 0x12;
209
210 pattrib->pktlen = 0;
211
212 if (pmlmeext->cur_wireless_mode & WIRELESS_11B)
213 pattrib->raid = 6;
214 else
215 pattrib->raid = 5;
216
217 pattrib->encrypt = _NO_PRIVACY_;
218 pattrib->bswenc = false;
219
220 pattrib->qos_en = false;
221 pattrib->ht_en = false;
222 pattrib->bwmode = HT_CHANNEL_WIDTH_20;
223 pattrib->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
224 pattrib->sgi = false;
225
226 pattrib->seqnum = pmlmeext->mgnt_seq;
227
228 pattrib->retry_ctrl = true;
229}
230
231static void dump_mgntframe(struct adapter *padapter,
232 struct xmit_frame *pmgntframe)
233{
234 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
235 return;
236
237 rtw_hal_mgnt_xmit(padapter, pmgntframe);
238}
239
240static s32 dump_mgntframe_and_wait(struct adapter *padapter,
241 struct xmit_frame *pmgntframe,
242 int timeout_ms)
243{
244 s32 ret = _FAIL;
245 struct xmit_buf *pxmitbuf = pmgntframe->pxmitbuf;
246 struct submit_ctx sctx;
247
248 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
249 return ret;
250
251 rtw_sctx_init(&sctx, timeout_ms);
252 pxmitbuf->sctx = &sctx;
253
254 ret = rtw_hal_mgnt_xmit(padapter, pmgntframe);
255
256 if (ret == _SUCCESS)
257 ret = rtw_sctx_wait(&sctx);
258
259 return ret;
260}
261
262static s32 dump_mgntframe_and_wait_ack(struct adapter *padapter,
263 struct xmit_frame *pmgntframe)
264{
265 s32 ret = _FAIL;
266 u32 timeout_ms = 500;
267 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
268
269 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
270 return -1;
271
272 if (mutex_lock_interruptible(&pxmitpriv->ack_tx_mutex))
273 return _FAIL;
274 pxmitpriv->ack_tx = true;
275
276 pmgntframe->ack_report = 1;
277 if (rtw_hal_mgnt_xmit(padapter, pmgntframe) == _SUCCESS)
278 ret = rtw_ack_tx_wait(pxmitpriv, timeout_ms);
279
280 pxmitpriv->ack_tx = false;
281 mutex_unlock(&pxmitpriv->ack_tx_mutex);
282
283 return ret;
284}
285
286static int update_hidden_ssid(u8 *ies, u32 ies_len, u8 hidden_ssid_mode)
287{
288 u8 *ssid_ie;
289 uint ssid_len_ori;
290 int len_diff = 0;
291
292 ssid_ie = rtw_get_ie(ies, WLAN_EID_SSID, &ssid_len_ori, ies_len);
293
294 if (ssid_ie && ssid_len_ori > 0) {
295 switch (hidden_ssid_mode) {
296 case 1: {
297 u8 *next_ie = ssid_ie + 2 + ssid_len_ori;
298 u32 remain_len = 0;
299
300 remain_len = ies_len - (next_ie - ies);
301
302 ssid_ie[1] = 0;
303 memcpy(ssid_ie+2, next_ie, remain_len);
304 len_diff -= ssid_len_ori;
305
306 break;
307 }
308 case 2:
309 memset(&ssid_ie[2], 0, ssid_len_ori);
310 break;
311 default:
312 break;
313 }
314 }
315
316 return len_diff;
317}
318
319static void issue_beacon(struct adapter *padapter, int timeout_ms)
320{
321 struct xmit_frame *pmgntframe;
322 struct pkt_attrib *pattrib;
323 unsigned char *pframe;
324 struct ieee80211_hdr *pwlanhdr;
325 __le16 *fctrl;
326 unsigned int rate_len;
327 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
328 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
329 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
330 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
331 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
332 u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
333
334 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
335 if (!pmgntframe) {
336 DBG_88E("%s, alloc mgnt frame fail\n", __func__);
337 return;
338 }
339#if defined(CONFIG_88EU_AP_MODE)
340 spin_lock_bh(&pmlmepriv->bcn_update_lock);
341#endif
342
343
344 pattrib = &pmgntframe->attrib;
345 update_mgntframe_attrib(padapter, pattrib);
346 pattrib->qsel = 0x10;
347
348 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
349
350 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
351 pwlanhdr = (struct ieee80211_hdr *)pframe;
352
353
354 fctrl = &pwlanhdr->frame_control;
355 *(fctrl) = 0;
356
357 ether_addr_copy(pwlanhdr->addr1, bc_addr);
358 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
359 ether_addr_copy(pwlanhdr->addr3, cur_network->MacAddress);
360
361 SetSeqNum(pwlanhdr, 0);
362
363 SetFrameSubType(pframe, WIFI_BEACON);
364
365 pframe += sizeof(struct ieee80211_hdr_3addr);
366 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
367
368 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) {
369 int len_diff;
370 u8 *wps_ie;
371 uint wps_ielen;
372 u8 sr = 0;
373
374 memcpy(pframe, cur_network->IEs, cur_network->IELength);
375 len_diff = update_hidden_ssid(
376 pframe+_BEACON_IE_OFFSET_
377 , cur_network->IELength-_BEACON_IE_OFFSET_
378 , pmlmeinfo->hidden_ssid_mode
379 );
380 pframe += (cur_network->IELength+len_diff);
381 pattrib->pktlen += (cur_network->IELength+len_diff);
382 wps_ie = rtw_get_wps_ie(pmgntframe->buf_addr+TXDESC_OFFSET+sizeof(struct ieee80211_hdr_3addr)+_BEACON_IE_OFFSET_,
383 pattrib->pktlen-sizeof(struct ieee80211_hdr_3addr)-_BEACON_IE_OFFSET_, NULL, &wps_ielen);
384 if (wps_ie && wps_ielen > 0)
385 rtw_get_wps_attr_content(wps_ie, wps_ielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL);
386 if (sr != 0)
387 set_fwstate(pmlmepriv, WIFI_UNDER_WPS);
388 else
389 _clr_fwstate_(pmlmepriv, WIFI_UNDER_WPS);
390
391 goto _issue_bcn;
392 }
393
394
395
396
397 pframe += 8;
398 pattrib->pktlen += 8;
399
400
401
402 memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
403
404 pframe += 2;
405 pattrib->pktlen += 2;
406
407
408
409 memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
410
411 pframe += 2;
412 pattrib->pktlen += 2;
413
414
415 pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pattrib->pktlen);
416
417
418 rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
419 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, min_t(unsigned int, rate_len, 8), cur_network->SupportedRates, &pattrib->pktlen);
420
421
422 pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pattrib->pktlen);
423
424 {
425 u8 erpinfo = 0;
426 u32 ATIMWindow;
427
428 ATIMWindow = 0;
429 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pattrib->pktlen);
430
431
432 pframe = rtw_set_ie(pframe, _ERPINFO_IE_, 1, &erpinfo, &pattrib->pktlen);
433 }
434
435
436 if (rate_len > 8)
437 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pattrib->pktlen);
438
439_issue_bcn:
440
441#if defined(CONFIG_88EU_AP_MODE)
442 pmlmepriv->update_bcn = false;
443
444 spin_unlock_bh(&pmlmepriv->bcn_update_lock);
445#endif
446
447 if ((pattrib->pktlen + TXDESC_SIZE) > 512) {
448 DBG_88E("beacon frame too large\n");
449 return;
450 }
451
452 pattrib->last_txcmdsz = pattrib->pktlen;
453
454
455 if (timeout_ms > 0)
456 dump_mgntframe_and_wait(padapter, pmgntframe, timeout_ms);
457 else
458 dump_mgntframe(padapter, pmgntframe);
459}
460
461static void issue_probersp(struct adapter *padapter, unsigned char *da)
462{
463 struct xmit_frame *pmgntframe;
464 struct pkt_attrib *pattrib;
465 unsigned char *pframe;
466 struct ieee80211_hdr *pwlanhdr;
467 __le16 *fctrl;
468 unsigned char *mac, *bssid;
469 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
470#if defined(CONFIG_88EU_AP_MODE)
471 u8 *pwps_ie;
472 uint wps_ielen;
473 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
474#endif
475 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
476 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
477 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
478 unsigned int rate_len;
479
480 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
481 if (!pmgntframe) {
482 DBG_88E("%s, alloc mgnt frame fail\n", __func__);
483 return;
484 }
485
486
487 pattrib = &pmgntframe->attrib;
488 update_mgntframe_attrib(padapter, pattrib);
489
490 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
491
492 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
493 pwlanhdr = (struct ieee80211_hdr *)pframe;
494
495 mac = myid(&(padapter->eeprompriv));
496 bssid = cur_network->MacAddress;
497
498 fctrl = &pwlanhdr->frame_control;
499 *(fctrl) = 0;
500 ether_addr_copy(pwlanhdr->addr1, da);
501 ether_addr_copy(pwlanhdr->addr2, mac);
502 ether_addr_copy(pwlanhdr->addr3, bssid);
503
504 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
505 pmlmeext->mgnt_seq++;
506 SetFrameSubType(fctrl, WIFI_PROBERSP);
507
508 pattrib->hdrlen = sizeof(struct ieee80211_hdr_3addr);
509 pattrib->pktlen = pattrib->hdrlen;
510 pframe += pattrib->hdrlen;
511
512 if (cur_network->IELength > MAX_IE_SZ)
513 return;
514
515#if defined(CONFIG_88EU_AP_MODE)
516 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) {
517 pwps_ie = rtw_get_wps_ie(cur_network->IEs+_FIXED_IE_LENGTH_, cur_network->IELength-_FIXED_IE_LENGTH_, NULL, &wps_ielen);
518
519
520 if ((pmlmepriv->wps_probe_resp_ie != NULL) && pwps_ie && (wps_ielen > 0)) {
521 uint wps_offset, remainder_ielen;
522 u8 *premainder_ie;
523
524 wps_offset = (uint)(pwps_ie - cur_network->IEs);
525
526 premainder_ie = pwps_ie + wps_ielen;
527
528 remainder_ielen = cur_network->IELength - wps_offset - wps_ielen;
529
530 memcpy(pframe, cur_network->IEs, wps_offset);
531 pframe += wps_offset;
532 pattrib->pktlen += wps_offset;
533
534 wps_ielen = (uint)pmlmepriv->wps_probe_resp_ie[1];
535 if ((wps_offset+wps_ielen+2) <= MAX_IE_SZ) {
536 memcpy(pframe, pmlmepriv->wps_probe_resp_ie, wps_ielen+2);
537 pframe += wps_ielen+2;
538 pattrib->pktlen += wps_ielen+2;
539 }
540
541 if ((wps_offset+wps_ielen+2+remainder_ielen) <= MAX_IE_SZ) {
542 memcpy(pframe, premainder_ie, remainder_ielen);
543 pframe += remainder_ielen;
544 pattrib->pktlen += remainder_ielen;
545 }
546 } else {
547 memcpy(pframe, cur_network->IEs, cur_network->IELength);
548 pframe += cur_network->IELength;
549 pattrib->pktlen += cur_network->IELength;
550 }
551 } else
552#endif
553 {
554
555 pframe += 8;
556 pattrib->pktlen += 8;
557
558
559
560 memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
561
562 pframe += 2;
563 pattrib->pktlen += 2;
564
565
566
567 memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
568
569 pframe += 2;
570 pattrib->pktlen += 2;
571
572
573
574
575 pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pattrib->pktlen);
576
577
578 rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
579 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, min_t(unsigned int, rate_len, 8), cur_network->SupportedRates, &pattrib->pktlen);
580
581
582 pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pattrib->pktlen);
583
584 if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) {
585 u8 erpinfo = 0;
586 u32 ATIMWindow;
587
588
589 ATIMWindow = 0;
590 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pattrib->pktlen);
591
592
593 pframe = rtw_set_ie(pframe, _ERPINFO_IE_, 1, &erpinfo, &pattrib->pktlen);
594 }
595
596
597
598 if (rate_len > 8)
599 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pattrib->pktlen);
600
601 }
602
603 pattrib->last_txcmdsz = pattrib->pktlen;
604
605 dump_mgntframe(padapter, pmgntframe);
606}
607
608static int issue_probereq(struct adapter *padapter,
609 struct ndis_802_11_ssid *pssid, u8 *da,
610 bool wait_ack)
611{
612 int ret = _FAIL;
613 struct xmit_frame *pmgntframe;
614 struct pkt_attrib *pattrib;
615 unsigned char *pframe;
616 struct ieee80211_hdr *pwlanhdr;
617 __le16 *fctrl;
618 unsigned char *mac;
619 unsigned char bssrate[NumRates];
620 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
621 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
622 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
623 int bssrate_len = 0;
624 u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
625
626 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+%s\n", __func__));
627
628 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
629 if (!pmgntframe)
630 goto exit;
631
632
633 pattrib = &pmgntframe->attrib;
634 update_mgntframe_attrib(padapter, pattrib);
635
636
637 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
638
639 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
640 pwlanhdr = (struct ieee80211_hdr *)pframe;
641
642 mac = myid(&(padapter->eeprompriv));
643
644 fctrl = &pwlanhdr->frame_control;
645 *(fctrl) = 0;
646
647 if (da) {
648
649 ether_addr_copy(pwlanhdr->addr1, da);
650 ether_addr_copy(pwlanhdr->addr3, da);
651 } else {
652
653 ether_addr_copy(pwlanhdr->addr1, bc_addr);
654 ether_addr_copy(pwlanhdr->addr3, bc_addr);
655 }
656
657 ether_addr_copy(pwlanhdr->addr2, mac);
658
659 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
660 pmlmeext->mgnt_seq++;
661 SetFrameSubType(pframe, WIFI_PROBEREQ);
662
663 pframe += sizeof(struct ieee80211_hdr_3addr);
664 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
665
666 if (pssid)
667 pframe = rtw_set_ie(pframe, _SSID_IE_, pssid->SsidLength, pssid->Ssid, &(pattrib->pktlen));
668 else
669 pframe = rtw_set_ie(pframe, _SSID_IE_, 0, NULL, &(pattrib->pktlen));
670
671 get_rate_set(padapter, bssrate, &bssrate_len);
672
673 if (bssrate_len > 8) {
674 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, bssrate, &(pattrib->pktlen));
675 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
676 } else {
677 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, bssrate_len, bssrate, &(pattrib->pktlen));
678 }
679
680
681 if (pmlmepriv->wps_probe_req_ie_len > 0 && pmlmepriv->wps_probe_req_ie) {
682 memcpy(pframe, pmlmepriv->wps_probe_req_ie, pmlmepriv->wps_probe_req_ie_len);
683 pframe += pmlmepriv->wps_probe_req_ie_len;
684 pattrib->pktlen += pmlmepriv->wps_probe_req_ie_len;
685 }
686
687 pattrib->last_txcmdsz = pattrib->pktlen;
688
689 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
690 ("issuing probe_req, tx_len=%d\n", pattrib->last_txcmdsz));
691
692 if (wait_ack) {
693 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
694 } else {
695 dump_mgntframe(padapter, pmgntframe);
696 ret = _SUCCESS;
697 }
698
699exit:
700 return ret;
701}
702
703static int issue_probereq_ex(struct adapter *padapter,
704 struct ndis_802_11_ssid *pssid, u8 *da,
705 int try_cnt, int wait_ms)
706{
707 int ret;
708 int i = 0;
709 unsigned long start = jiffies;
710
711 do {
712 ret = issue_probereq(padapter, pssid, da, wait_ms > 0);
713
714 i++;
715
716 if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
717 break;
718
719 if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
720 msleep(wait_ms);
721
722 } while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
723
724 if (ret != _FAIL) {
725 ret = _SUCCESS;
726 goto exit;
727 }
728
729 if (try_cnt && wait_ms) {
730 if (da)
731 DBG_88E(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
732 FUNC_ADPT_ARG(padapter), da, rtw_get_oper_ch(padapter),
733 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
734 jiffies_to_msecs(jiffies - start));
735 else
736 DBG_88E(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
737 FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
738 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
739 jiffies_to_msecs(jiffies - start));
740 }
741exit:
742 return ret;
743}
744
745
746static void issue_auth(struct adapter *padapter, struct sta_info *psta,
747 unsigned short status)
748{
749 struct xmit_frame *pmgntframe;
750 struct pkt_attrib *pattrib;
751 unsigned char *pframe;
752 struct ieee80211_hdr *pwlanhdr;
753 __le16 *fctrl;
754 unsigned int val32;
755 u16 val16;
756#ifdef CONFIG_88EU_AP_MODE
757 __le16 le_val16;
758#endif
759 int use_shared_key = 0;
760 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
761 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
762 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
763 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
764
765 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
766 if (pmgntframe == NULL)
767 return;
768
769
770 pattrib = &pmgntframe->attrib;
771 update_mgntframe_attrib(padapter, pattrib);
772
773 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
774
775 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
776 pwlanhdr = (struct ieee80211_hdr *)pframe;
777
778 fctrl = &pwlanhdr->frame_control;
779 *(fctrl) = 0;
780
781 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
782 pmlmeext->mgnt_seq++;
783 SetFrameSubType(pframe, WIFI_AUTH);
784
785 pframe += sizeof(struct ieee80211_hdr_3addr);
786 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
787
788
789 if (psta) {
790#ifdef CONFIG_88EU_AP_MODE
791
792 ether_addr_copy(pwlanhdr->addr1, psta->hwaddr);
793 ether_addr_copy(pwlanhdr->addr2,
794 myid(&(padapter->eeprompriv)));
795 ether_addr_copy(pwlanhdr->addr3,
796 myid(&(padapter->eeprompriv)));
797
798
799
800 val16 = (u16)psta->authalg;
801
802 if (status != _STATS_SUCCESSFUL_)
803 val16 = 0;
804
805 if (val16) {
806 le_val16 = cpu_to_le16(val16);
807 use_shared_key = 1;
808 } else {
809 le_val16 = 0;
810 }
811
812 pframe = rtw_set_fixed_ie(pframe, _AUTH_ALGM_NUM_, &le_val16,
813 &pattrib->pktlen);
814
815
816 val16 = (u16)psta->auth_seq;
817 le_val16 = cpu_to_le16(val16);
818 pframe = rtw_set_fixed_ie(pframe, _AUTH_SEQ_NUM_, &le_val16,
819 &pattrib->pktlen);
820
821
822 val16 = status;
823 le_val16 = cpu_to_le16(val16);
824 pframe = rtw_set_fixed_ie(pframe, _STATUS_CODE_,
825 &le_val16, &pattrib->pktlen);
826
827
828 if ((psta->auth_seq == 2) && (psta->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1))
829 pframe = rtw_set_ie(pframe, _CHLGETXT_IE_, 128, psta->chg_txt, &(pattrib->pktlen));
830#endif
831 } else {
832 __le32 le_tmp32;
833 __le16 le_tmp16;
834
835 ether_addr_copy(pwlanhdr->addr1, pnetwork->MacAddress);
836 ether_addr_copy(pwlanhdr->addr2, myid(&padapter->eeprompriv));
837 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
838
839
840 val16 = (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared) ? 1 : 0;
841 if (val16)
842 use_shared_key = 1;
843
844
845 if ((pmlmeinfo->auth_seq == 3) && (pmlmeinfo->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1)) {
846 val32 = (pmlmeinfo->iv++) | (pmlmeinfo->key_index << 30);
847 le_tmp32 = cpu_to_le32(val32);
848 pframe = rtw_set_fixed_ie(pframe, 4, &le_tmp32,
849 &pattrib->pktlen);
850
851 pattrib->iv_len = 4;
852 }
853
854 le_tmp16 = cpu_to_le16(val16);
855 pframe = rtw_set_fixed_ie(pframe, _AUTH_ALGM_NUM_, &le_tmp16,
856 &pattrib->pktlen);
857
858
859 val16 = pmlmeinfo->auth_seq;
860 le_tmp16 = cpu_to_le16(val16);
861 pframe = rtw_set_fixed_ie(pframe, _AUTH_SEQ_NUM_, &le_tmp16,
862 &pattrib->pktlen);
863
864
865
866 le_tmp16 = cpu_to_le16(status);
867 pframe = rtw_set_fixed_ie(pframe, _STATUS_CODE_, &le_tmp16,
868 &pattrib->pktlen);
869
870
871 if ((pmlmeinfo->auth_seq == 3) && (pmlmeinfo->state & WIFI_FW_AUTH_STATE) && (use_shared_key == 1)) {
872 pframe = rtw_set_ie(pframe, _CHLGETXT_IE_, 128, pmlmeinfo->chg_txt, &(pattrib->pktlen));
873
874 SetPrivacy(fctrl);
875
876 pattrib->hdrlen = sizeof(struct ieee80211_hdr_3addr);
877
878 pattrib->encrypt = _WEP40_;
879
880 pattrib->icv_len = 4;
881
882 pattrib->pktlen += pattrib->icv_len;
883 }
884 }
885
886 pattrib->last_txcmdsz = pattrib->pktlen;
887
888 rtw_wep_encrypt(padapter, (u8 *)pmgntframe);
889 DBG_88E("%s\n", __func__);
890 dump_mgntframe(padapter, pmgntframe);
891}
892
893
894#ifdef CONFIG_88EU_AP_MODE
895static void issue_asocrsp(struct adapter *padapter, unsigned short status,
896 struct sta_info *pstat, int pkt_type)
897{
898 struct xmit_frame *pmgntframe;
899 struct ieee80211_hdr *pwlanhdr;
900 struct pkt_attrib *pattrib;
901 unsigned char *pbuf, *pframe;
902 unsigned short val;
903 __le16 *fctrl;
904 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
905 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
906 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
907 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
908 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
909 u8 *ie = pnetwork->IEs;
910 __le16 lestatus, leval;
911
912 DBG_88E("%s\n", __func__);
913
914 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
915 if (!pmgntframe)
916 return;
917
918
919 pattrib = &pmgntframe->attrib;
920 update_mgntframe_attrib(padapter, pattrib);
921
922
923 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
924
925 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
926 pwlanhdr = (struct ieee80211_hdr *)pframe;
927
928 fctrl = &pwlanhdr->frame_control;
929 *(fctrl) = 0;
930
931 ether_addr_copy((void *)GetAddr1Ptr(pwlanhdr), pstat->hwaddr);
932 ether_addr_copy((void *)GetAddr2Ptr(pwlanhdr),
933 myid(&(padapter->eeprompriv)));
934 ether_addr_copy((void *)GetAddr3Ptr(pwlanhdr), pnetwork->MacAddress);
935
936
937 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
938 pmlmeext->mgnt_seq++;
939 if ((pkt_type == WIFI_ASSOCRSP) || (pkt_type == WIFI_REASSOCRSP))
940 SetFrameSubType(pwlanhdr, pkt_type);
941 else
942 return;
943
944 pattrib->hdrlen = sizeof(struct ieee80211_hdr_3addr);
945 pattrib->pktlen += pattrib->hdrlen;
946 pframe += pattrib->hdrlen;
947
948
949 val = *(unsigned short *)rtw_get_capability_from_ie(ie);
950
951 pframe = rtw_set_fixed_ie(pframe, _CAPABILITY_, &val, &pattrib->pktlen);
952
953 lestatus = cpu_to_le16(status);
954 pframe = rtw_set_fixed_ie(pframe, _STATUS_CODE_, &lestatus,
955 &pattrib->pktlen);
956
957 leval = cpu_to_le16(pstat->aid | BIT(14) | BIT(15));
958 pframe = rtw_set_fixed_ie(pframe, _ASOC_ID_, &leval, &pattrib->pktlen);
959
960 if (pstat->bssratelen <= 8) {
961 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, pstat->bssratelen, pstat->bssrateset, &(pattrib->pktlen));
962 } else {
963 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, pstat->bssrateset, &(pattrib->pktlen));
964 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (pstat->bssratelen-8), pstat->bssrateset+8, &(pattrib->pktlen));
965 }
966
967 if ((pstat->flags & WLAN_STA_HT) && (pmlmepriv->htpriv.ht_option)) {
968 uint ie_len = 0;
969
970
971 pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_CAPABILITY_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
972 if (pbuf && ie_len > 0) {
973 memcpy(pframe, pbuf, ie_len+2);
974 pframe += (ie_len+2);
975 pattrib->pktlen += (ie_len+2);
976 }
977
978
979 pbuf = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_ADD_INFO_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_));
980 if (pbuf && ie_len > 0) {
981 memcpy(pframe, pbuf, ie_len+2);
982 pframe += (ie_len+2);
983 pattrib->pktlen += (ie_len+2);
984 }
985 }
986
987
988 if ((pstat->flags & WLAN_STA_WME) && (pmlmepriv->qospriv.qos_option)) {
989 uint ie_len = 0;
990 unsigned char WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
991
992 for (pbuf = ie + _BEACON_IE_OFFSET_;; pbuf += (ie_len + 2)) {
993 pbuf = rtw_get_ie(pbuf, _VENDOR_SPECIFIC_IE_, &ie_len, (pnetwork->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2)));
994 if (pbuf && !memcmp(pbuf+2, WMM_PARA_IE, 6)) {
995 memcpy(pframe, pbuf, ie_len+2);
996 pframe += (ie_len+2);
997 pattrib->pktlen += (ie_len+2);
998 break;
999 }
1000
1001 if ((pbuf == NULL) || (ie_len == 0))
1002 break;
1003 }
1004 }
1005
1006 if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_REALTEK)
1007 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 6, REALTEK_96B_IE, &(pattrib->pktlen));
1008
1009
1010 if (pmlmepriv->wps_assoc_resp_ie && pmlmepriv->wps_assoc_resp_ie_len > 0) {
1011 memcpy(pframe, pmlmepriv->wps_assoc_resp_ie, pmlmepriv->wps_assoc_resp_ie_len);
1012
1013 pframe += pmlmepriv->wps_assoc_resp_ie_len;
1014 pattrib->pktlen += pmlmepriv->wps_assoc_resp_ie_len;
1015 }
1016
1017 pattrib->last_txcmdsz = pattrib->pktlen;
1018 dump_mgntframe(padapter, pmgntframe);
1019}
1020#endif
1021
1022static void issue_assocreq(struct adapter *padapter)
1023{
1024 int ret = _FAIL;
1025 struct xmit_frame *pmgntframe;
1026 struct pkt_attrib *pattrib;
1027 unsigned char *pframe, *p;
1028 struct ieee80211_hdr *pwlanhdr;
1029 __le16 *fctrl;
1030 unsigned int i, j, ie_len, index = 0;
1031 unsigned char bssrate[NumRates], sta_bssrate[NumRates];
1032 struct ndis_802_11_var_ie *pIE;
1033 struct registry_priv *pregpriv = &padapter->registrypriv;
1034 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1035 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1036 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1037 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1038 int bssrate_len = 0, sta_bssrate_len = 0;
1039 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1040
1041 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1042 if (!pmgntframe)
1043 goto exit;
1044
1045
1046 pattrib = &pmgntframe->attrib;
1047 update_mgntframe_attrib(padapter, pattrib);
1048
1049 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1050 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1051 pwlanhdr = (struct ieee80211_hdr *)pframe;
1052
1053 fctrl = &pwlanhdr->frame_control;
1054 *(fctrl) = 0;
1055 ether_addr_copy(pwlanhdr->addr1, pnetwork->MacAddress);
1056 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1057 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
1058
1059 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1060 pmlmeext->mgnt_seq++;
1061 SetFrameSubType(pframe, WIFI_ASSOCREQ);
1062
1063 pframe += sizeof(struct ieee80211_hdr_3addr);
1064 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
1065
1066
1067
1068 memcpy(pframe, rtw_get_capability_from_ie(pmlmeinfo->network.IEs), 2);
1069
1070 pframe += 2;
1071 pattrib->pktlen += 2;
1072
1073
1074
1075 put_unaligned_le16(3, pframe);
1076 pframe += 2;
1077 pattrib->pktlen += 2;
1078
1079
1080 pframe = rtw_set_ie(pframe, _SSID_IE_, pmlmeinfo->network.Ssid.SsidLength, pmlmeinfo->network.Ssid.Ssid, &(pattrib->pktlen));
1081
1082
1083
1084
1085 get_rate_set(padapter, sta_bssrate, &sta_bssrate_len);
1086
1087 if (pmlmeext->cur_channel == 14)
1088 sta_bssrate_len = 4;
1089
1090 for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
1091 if (pmlmeinfo->network.SupportedRates[i] == 0)
1092 break;
1093 DBG_88E("network.SupportedRates[%d]=%02X\n", i, pmlmeinfo->network.SupportedRates[i]);
1094 }
1095
1096 for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
1097 if (pmlmeinfo->network.SupportedRates[i] == 0)
1098 break;
1099
1100
1101 for (j = 0; j < sta_bssrate_len; j++) {
1102
1103 if ((pmlmeinfo->network.SupportedRates[i]|IEEE80211_BASIC_RATE_MASK)
1104 == (sta_bssrate[j]|IEEE80211_BASIC_RATE_MASK))
1105 break;
1106 }
1107
1108 if (j == sta_bssrate_len) {
1109
1110 DBG_88E("%s(): the rate[%d]=%02X is not supported by STA!\n", __func__, i, pmlmeinfo->network.SupportedRates[i]);
1111 } else {
1112
1113 bssrate[index++] = pmlmeinfo->network.SupportedRates[i];
1114 }
1115 }
1116
1117 bssrate_len = index;
1118 DBG_88E("bssrate_len=%d\n", bssrate_len);
1119
1120 if (bssrate_len == 0) {
1121 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1122 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1123 goto exit;
1124 }
1125
1126
1127 if (bssrate_len > 8) {
1128 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, 8, bssrate, &(pattrib->pktlen));
1129 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
1130 } else {
1131 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, bssrate_len, bssrate, &(pattrib->pktlen));
1132 }
1133
1134
1135 p = rtw_get_ie((pmlmeinfo->network.IEs + sizeof(struct ndis_802_11_fixed_ie)), _RSN_IE_2_, &ie_len, (pmlmeinfo->network.IELength - sizeof(struct ndis_802_11_fixed_ie)));
1136 if (p)
1137 pframe = rtw_set_ie(pframe, _RSN_IE_2_, ie_len, (p + 2), &(pattrib->pktlen));
1138
1139
1140 if (padapter->mlmepriv.htpriv.ht_option) {
1141 p = rtw_get_ie((pmlmeinfo->network.IEs + sizeof(struct ndis_802_11_fixed_ie)), _HT_CAPABILITY_IE_, &ie_len, (pmlmeinfo->network.IELength - sizeof(struct ndis_802_11_fixed_ie)));
1142 if ((p != NULL) && (!(is_ap_in_tkip(padapter)))) {
1143 memcpy(&pmlmeinfo->HT_caps, p + 2, sizeof(struct ieee80211_ht_cap));
1144
1145
1146 if (pregpriv->cbw40_enable == 0)
1147 pmlmeinfo->HT_caps.cap_info &= cpu_to_le16(~(BIT(6) | BIT(1)));
1148 else
1149 pmlmeinfo->HT_caps.cap_info |= cpu_to_le16(BIT(1));
1150
1151
1152 pmlmeinfo->HT_caps.cap_info |= cpu_to_le16(0x000c);
1153
1154 if (pregpriv->rx_stbc)
1155 pmlmeinfo->HT_caps.cap_info |= cpu_to_le16(0x0100);
1156 memcpy((u8 *)&pmlmeinfo->HT_caps.mcs, MCS_rate_1R, 16);
1157 pframe = rtw_set_ie(pframe, _HT_CAPABILITY_IE_, ie_len, (u8 *)(&(pmlmeinfo->HT_caps)), &(pattrib->pktlen));
1158 }
1159 }
1160
1161
1162 for (i = sizeof(struct ndis_802_11_fixed_ie); i < pmlmeinfo->network.IELength; i += (pIE->Length + 2)) {
1163 pIE = (struct ndis_802_11_var_ie *)(pmlmeinfo->network.IEs + i);
1164
1165 switch (pIE->ElementID) {
1166 case _VENDOR_SPECIFIC_IE_:
1167 if ((!memcmp(pIE->data, RTW_WPA_OUI, 4)) ||
1168 (!memcmp(pIE->data, WMM_OUI, 4)) ||
1169 (!memcmp(pIE->data, WPS_OUI, 4))) {
1170 if (!padapter->registrypriv.wifi_spec) {
1171
1172
1173
1174 if (!memcmp(pIE->data, WPS_OUI, 4))
1175 pIE->Length = 14;
1176 }
1177 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, pIE->Length, pIE->data, &(pattrib->pktlen));
1178 }
1179 break;
1180 default:
1181 break;
1182 }
1183 }
1184
1185 if (pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_REALTEK)
1186 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 6, REALTEK_96B_IE, &(pattrib->pktlen));
1187
1188 pattrib->last_txcmdsz = pattrib->pktlen;
1189 dump_mgntframe(padapter, pmgntframe);
1190
1191 ret = _SUCCESS;
1192
1193exit:
1194 if (ret == _SUCCESS)
1195 rtw_buf_update(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len, (u8 *)pwlanhdr, pattrib->pktlen);
1196 else
1197 rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len);
1198}
1199
1200
1201static int _issue_nulldata(struct adapter *padapter, unsigned char *da,
1202 unsigned int power_mode, bool wait_ack)
1203{
1204 int ret = _FAIL;
1205 struct xmit_frame *pmgntframe;
1206 struct pkt_attrib *pattrib;
1207 unsigned char *pframe;
1208 struct ieee80211_hdr *pwlanhdr;
1209 __le16 *fctrl;
1210 struct xmit_priv *pxmitpriv;
1211 struct mlme_ext_priv *pmlmeext;
1212 struct mlme_ext_info *pmlmeinfo;
1213 struct wlan_bssid_ex *pnetwork;
1214
1215 if (!padapter)
1216 goto exit;
1217
1218 pxmitpriv = &(padapter->xmitpriv);
1219 pmlmeext = &(padapter->mlmeextpriv);
1220 pmlmeinfo = &(pmlmeext->mlmext_info);
1221 pnetwork = &(pmlmeinfo->network);
1222
1223 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1224 if (!pmgntframe)
1225 goto exit;
1226
1227
1228 pattrib = &pmgntframe->attrib;
1229 update_mgntframe_attrib(padapter, pattrib);
1230 pattrib->retry_ctrl = false;
1231
1232 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1233
1234 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1235 pwlanhdr = (struct ieee80211_hdr *)pframe;
1236
1237 fctrl = &pwlanhdr->frame_control;
1238 *(fctrl) = 0;
1239
1240 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
1241 SetFrDs(fctrl);
1242 else if ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE)
1243 SetToDs(fctrl);
1244
1245 if (power_mode)
1246 SetPwrMgt(fctrl);
1247
1248 ether_addr_copy(pwlanhdr->addr1, da);
1249 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1250 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
1251
1252 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1253 pmlmeext->mgnt_seq++;
1254 SetFrameSubType(pframe, WIFI_DATA_NULL);
1255
1256 pframe += sizeof(struct ieee80211_hdr_3addr);
1257 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
1258
1259 pattrib->last_txcmdsz = pattrib->pktlen;
1260
1261 if (wait_ack) {
1262 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
1263 } else {
1264 dump_mgntframe(padapter, pmgntframe);
1265 ret = _SUCCESS;
1266 }
1267
1268exit:
1269 return ret;
1270}
1271
1272
1273
1274
1275int issue_nulldata(struct adapter *padapter, unsigned char *da,
1276 unsigned int power_mode, int try_cnt, int wait_ms)
1277{
1278 int ret;
1279 int i = 0;
1280 unsigned long start = jiffies;
1281 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1282 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1283 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1284
1285
1286 if (da == NULL)
1287 da = pnetwork->MacAddress;
1288
1289 do {
1290 ret = _issue_nulldata(padapter, da, power_mode, wait_ms > 0);
1291
1292 i++;
1293
1294 if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
1295 break;
1296
1297 if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
1298 msleep(wait_ms);
1299 } while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
1300
1301 if (ret != _FAIL) {
1302 ret = _SUCCESS;
1303 goto exit;
1304 }
1305
1306 if (try_cnt && wait_ms) {
1307 if (da)
1308 DBG_88E(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
1309 FUNC_ADPT_ARG(padapter), da, rtw_get_oper_ch(padapter),
1310 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1311 jiffies_to_msecs(jiffies - start));
1312 else
1313 DBG_88E(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
1314 FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
1315 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1316 jiffies_to_msecs(jiffies - start));
1317 }
1318exit:
1319 return ret;
1320}
1321
1322
1323static int _issue_qos_nulldata(struct adapter *padapter, unsigned char *da,
1324 u16 tid, bool wait_ack)
1325{
1326 int ret = _FAIL;
1327 struct xmit_frame *pmgntframe;
1328 struct pkt_attrib *pattrib;
1329 unsigned char *pframe;
1330 struct ieee80211_hdr *pwlanhdr;
1331 __le16 *fctrl;
1332 unsigned short *qc;
1333 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1334 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1335 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1336 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1337
1338 DBG_88E("%s\n", __func__);
1339
1340 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1341 if (!pmgntframe)
1342 goto exit;
1343
1344
1345 pattrib = &pmgntframe->attrib;
1346 update_mgntframe_attrib(padapter, pattrib);
1347
1348 pattrib->hdrlen += 2;
1349 pattrib->qos_en = true;
1350 pattrib->eosp = 1;
1351 pattrib->ack_policy = 0;
1352 pattrib->mdata = 0;
1353
1354 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1355
1356 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1357 pwlanhdr = (struct ieee80211_hdr *)pframe;
1358
1359 fctrl = &pwlanhdr->frame_control;
1360 *(fctrl) = 0;
1361
1362 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
1363 SetFrDs(fctrl);
1364 else if ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE)
1365 SetToDs(fctrl);
1366
1367 if (pattrib->mdata)
1368 SetMData(fctrl);
1369
1370 qc = (unsigned short *)(pframe + pattrib->hdrlen - 2);
1371
1372 SetPriority(qc, tid);
1373
1374 SetEOSP(qc, pattrib->eosp);
1375
1376 SetAckpolicy(qc, pattrib->ack_policy);
1377
1378 ether_addr_copy(pwlanhdr->addr1, da);
1379 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1380 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
1381
1382 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1383 pmlmeext->mgnt_seq++;
1384 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
1385
1386 pframe += sizeof(struct ieee80211_qos_hdr);
1387 pattrib->pktlen = sizeof(struct ieee80211_qos_hdr);
1388
1389 pattrib->last_txcmdsz = pattrib->pktlen;
1390
1391 if (wait_ack) {
1392 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
1393 } else {
1394 dump_mgntframe(padapter, pmgntframe);
1395 ret = _SUCCESS;
1396 }
1397
1398exit:
1399 return ret;
1400}
1401
1402
1403
1404int issue_qos_nulldata(struct adapter *padapter, unsigned char *da,
1405 u16 tid, int try_cnt, int wait_ms)
1406{
1407 int ret;
1408 int i = 0;
1409 unsigned long start = jiffies;
1410 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1411 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1412 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1413
1414
1415 if (da == NULL)
1416 da = pnetwork->MacAddress;
1417
1418 do {
1419 ret = _issue_qos_nulldata(padapter, da, tid, wait_ms > 0);
1420
1421 i++;
1422
1423 if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
1424 break;
1425
1426 if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
1427 msleep(wait_ms);
1428 } while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
1429
1430 if (ret != _FAIL) {
1431 ret = _SUCCESS;
1432 goto exit;
1433 }
1434
1435 if (try_cnt && wait_ms) {
1436 if (da)
1437 DBG_88E(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
1438 FUNC_ADPT_ARG(padapter), da, rtw_get_oper_ch(padapter),
1439 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1440 jiffies_to_msecs(jiffies - start));
1441 else
1442 DBG_88E(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
1443 FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
1444 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1445 jiffies_to_msecs(jiffies - start));
1446 }
1447exit:
1448 return ret;
1449}
1450
1451static int _issue_deauth(struct adapter *padapter, unsigned char *da,
1452 unsigned short reason, bool wait_ack)
1453{
1454 struct xmit_frame *pmgntframe;
1455 struct pkt_attrib *pattrib;
1456 unsigned char *pframe;
1457 struct ieee80211_hdr *pwlanhdr;
1458 __le16 *fctrl;
1459 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1460 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1461 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1462 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1463 int ret = _FAIL;
1464 __le16 le_tmp;
1465
1466 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1467 if (pmgntframe == NULL)
1468 goto exit;
1469
1470
1471 pattrib = &pmgntframe->attrib;
1472 update_mgntframe_attrib(padapter, pattrib);
1473 pattrib->retry_ctrl = false;
1474
1475 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1476
1477 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1478 pwlanhdr = (struct ieee80211_hdr *)pframe;
1479
1480 fctrl = &pwlanhdr->frame_control;
1481 *(fctrl) = 0;
1482
1483 ether_addr_copy(pwlanhdr->addr1, da);
1484 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1485 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
1486
1487 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1488 pmlmeext->mgnt_seq++;
1489 SetFrameSubType(pframe, WIFI_DEAUTH);
1490
1491 pframe += sizeof(struct ieee80211_hdr_3addr);
1492 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
1493
1494 le_tmp = cpu_to_le16(reason);
1495 pframe = rtw_set_fixed_ie(pframe, _RSON_CODE_, &le_tmp,
1496 &pattrib->pktlen);
1497
1498 pattrib->last_txcmdsz = pattrib->pktlen;
1499
1500
1501 if (wait_ack) {
1502 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
1503 } else {
1504 dump_mgntframe(padapter, pmgntframe);
1505 ret = _SUCCESS;
1506 }
1507
1508exit:
1509 return ret;
1510}
1511
1512int issue_deauth(struct adapter *padapter, unsigned char *da,
1513 unsigned short reason)
1514{
1515 DBG_88E("%s to %pM\n", __func__, da);
1516 return _issue_deauth(padapter, da, reason, false);
1517}
1518
1519static int issue_deauth_ex(struct adapter *padapter, u8 *da,
1520 unsigned short reason, int try_cnt,
1521 int wait_ms)
1522{
1523 int ret;
1524 int i = 0;
1525 unsigned long start = jiffies;
1526
1527 do {
1528 ret = _issue_deauth(padapter, da, reason, wait_ms > 0);
1529
1530 i++;
1531
1532 if (padapter->bDriverStopped || padapter->bSurpriseRemoved)
1533 break;
1534
1535 if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
1536 msleep(wait_ms);
1537 } while ((i < try_cnt) && ((ret == _FAIL) || (wait_ms == 0)));
1538
1539 if (ret != _FAIL) {
1540 ret = _SUCCESS;
1541 goto exit;
1542 }
1543
1544 if (try_cnt && wait_ms) {
1545 if (da)
1546 DBG_88E(FUNC_ADPT_FMT" to %pM, ch:%u%s, %d/%d in %u ms\n",
1547 FUNC_ADPT_ARG(padapter), da, rtw_get_oper_ch(padapter),
1548 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1549 jiffies_to_msecs(jiffies - start));
1550 else
1551 DBG_88E(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
1552 FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
1553 ret == _SUCCESS ? ", acked" : "", i, try_cnt,
1554 jiffies_to_msecs(jiffies - start));
1555 }
1556exit:
1557 return ret;
1558}
1559
1560static void issue_action_BA(struct adapter *padapter, unsigned char *raddr,
1561 unsigned char action, unsigned short status)
1562{
1563 u8 category = RTW_WLAN_CATEGORY_BACK;
1564 u16 start_seq;
1565 u16 BA_para_set;
1566 u16 reason_code;
1567 u16 BA_timeout_value;
1568 __le16 le_tmp;
1569 u16 BA_starting_seqctrl = 0;
1570 enum ht_cap_ampdu_factor max_rx_ampdu_factor;
1571 struct xmit_frame *pmgntframe;
1572 struct pkt_attrib *pattrib;
1573 u8 *pframe;
1574 struct ieee80211_hdr *pwlanhdr;
1575 __le16 *fctrl;
1576 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1577 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1578 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1579 struct sta_info *psta;
1580 struct sta_priv *pstapriv = &padapter->stapriv;
1581 struct registry_priv *pregpriv = &padapter->registrypriv;
1582 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1583
1584 DBG_88E("%s, category=%d, action=%d, status=%d\n", __func__, category, action, status);
1585
1586 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1587 if (!pmgntframe)
1588 return;
1589
1590
1591 pattrib = &pmgntframe->attrib;
1592 update_mgntframe_attrib(padapter, pattrib);
1593
1594 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1595
1596 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1597 pwlanhdr = (struct ieee80211_hdr *)pframe;
1598
1599 fctrl = &pwlanhdr->frame_control;
1600 *(fctrl) = 0;
1601
1602 ether_addr_copy(pwlanhdr->addr1, raddr);
1603 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1604 ether_addr_copy(pwlanhdr->addr3, pnetwork->MacAddress);
1605
1606 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1607 pmlmeext->mgnt_seq++;
1608 SetFrameSubType(pframe, WIFI_ACTION);
1609
1610 pframe += sizeof(struct ieee80211_hdr_3addr);
1611 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
1612
1613 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
1614 pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
1615
1616 if (category == 3) {
1617 switch (action) {
1618 case 0:
1619 do {
1620 pmlmeinfo->dialogToken++;
1621 } while (pmlmeinfo->dialogToken == 0);
1622 pframe = rtw_set_fixed_ie(pframe, 1, &(pmlmeinfo->dialogToken), &(pattrib->pktlen));
1623
1624 BA_para_set = 0x1002 | ((status & 0xf) << 2);
1625 le_tmp = cpu_to_le16(BA_para_set);
1626 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1627 &pattrib->pktlen);
1628
1629 BA_timeout_value = 5000;
1630 le_tmp = cpu_to_le16(BA_timeout_value);
1631 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1632 &pattrib->pktlen);
1633
1634 psta = rtw_get_stainfo(pstapriv, raddr);
1635 if (psta) {
1636 start_seq = (psta->sta_xmitpriv.txseq_tid[status & 0x07]&0xfff) + 1;
1637
1638 DBG_88E("BA_starting_seqctrl=%d for TID=%d\n", start_seq, status & 0x07);
1639
1640 psta->BA_starting_seqctrl[status & 0x07] = start_seq;
1641
1642 BA_starting_seqctrl = start_seq << 4;
1643 }
1644 le_tmp = cpu_to_le16(BA_starting_seqctrl);
1645 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1646 &pattrib->pktlen);
1647 break;
1648 case 1:
1649 {
1650 struct ADDBA_request *ADDBA_req = &pmlmeinfo->ADDBA_req;
1651
1652 pframe = rtw_set_fixed_ie(pframe, 1,
1653 &ADDBA_req->dialog_token,
1654 &pattrib->pktlen);
1655 pframe = rtw_set_fixed_ie(pframe, 2, &status,
1656 &pattrib->pktlen);
1657
1658 BA_para_set = le16_to_cpu(ADDBA_req->BA_para_set) &
1659 0x3f;
1660 rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor);
1661 switch (max_rx_ampdu_factor) {
1662 case MAX_AMPDU_FACTOR_64K:
1663 BA_para_set |= 0x1000;
1664 break;
1665 case MAX_AMPDU_FACTOR_32K:
1666 BA_para_set |= 0x0800;
1667 break;
1668 case MAX_AMPDU_FACTOR_16K:
1669 BA_para_set |= 0x0400;
1670 break;
1671 case MAX_AMPDU_FACTOR_8K:
1672 BA_para_set |= 0x0200;
1673 break;
1674 default:
1675 BA_para_set |= 0x1000;
1676 break;
1677 }
1678
1679 if (pregpriv->ampdu_amsdu == 0)
1680 BA_para_set = BA_para_set & ~BIT(0);
1681 else if (pregpriv->ampdu_amsdu == 1)
1682 BA_para_set = BA_para_set | BIT(0);
1683 le_tmp = cpu_to_le16(BA_para_set);
1684
1685 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1686 &pattrib->pktlen);
1687 pframe = rtw_set_fixed_ie(pframe, 2,
1688 &ADDBA_req->BA_timeout_value,
1689 &pattrib->pktlen);
1690 break;
1691 }
1692 case 2:
1693 BA_para_set = (status & 0x1F) << 3;
1694 le_tmp = cpu_to_le16(BA_para_set);
1695 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1696 &pattrib->pktlen);
1697
1698 reason_code = 37;
1699 le_tmp = cpu_to_le16(reason_code);
1700 pframe = rtw_set_fixed_ie(pframe, 2, &(le_tmp),
1701 &pattrib->pktlen);
1702 break;
1703 default:
1704 break;
1705 }
1706 }
1707
1708 pattrib->last_txcmdsz = pattrib->pktlen;
1709
1710 dump_mgntframe(padapter, pmgntframe);
1711}
1712
1713static void issue_action_BSSCoexistPacket(struct adapter *padapter)
1714{
1715 struct list_head *plist, *phead;
1716 unsigned char category, action;
1717 struct xmit_frame *pmgntframe;
1718 struct pkt_attrib *pattrib;
1719 unsigned char *pframe;
1720 struct ieee80211_hdr *pwlanhdr;
1721 __le16 *fctrl;
1722 struct wlan_network *pnetwork = NULL;
1723 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1724 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1725 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1726 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1727 struct __queue *queue = &(pmlmepriv->scanned_queue);
1728 u8 InfoContent[16] = {0};
1729 u8 ICS[8][15];
1730 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
1731
1732 if ((pmlmepriv->num_FortyMHzIntolerant == 0) || (pmlmepriv->num_sta_no_ht == 0))
1733 return;
1734
1735 if (pmlmeinfo->bwmode_updated)
1736 return;
1737
1738
1739 DBG_88E("%s\n", __func__);
1740
1741
1742 category = RTW_WLAN_CATEGORY_PUBLIC;
1743 action = ACT_PUBLIC_BSSCOEXIST;
1744
1745 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1746 if (!pmgntframe)
1747 return;
1748
1749
1750 pattrib = &pmgntframe->attrib;
1751 update_mgntframe_attrib(padapter, pattrib);
1752
1753 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1754
1755 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1756 pwlanhdr = (struct ieee80211_hdr *)pframe;
1757
1758 fctrl = &pwlanhdr->frame_control;
1759 *(fctrl) = 0;
1760
1761 ether_addr_copy(pwlanhdr->addr1, cur_network->MacAddress);
1762 ether_addr_copy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)));
1763 ether_addr_copy(pwlanhdr->addr3, cur_network->MacAddress);
1764
1765 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1766 pmlmeext->mgnt_seq++;
1767 SetFrameSubType(pframe, WIFI_ACTION);
1768
1769 pframe += sizeof(struct ieee80211_hdr_3addr);
1770 pattrib->pktlen = sizeof(struct ieee80211_hdr_3addr);
1771
1772 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
1773 pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
1774
1775
1776
1777 if (pmlmepriv->num_FortyMHzIntolerant > 0) {
1778 u8 iedata = 0;
1779
1780 iedata |= BIT(2);
1781
1782 pframe = rtw_set_ie(pframe, EID_BSSCoexistence, 1, &iedata, &(pattrib->pktlen));
1783 }
1784
1785
1786
1787 memset(ICS, 0, sizeof(ICS));
1788 if (pmlmepriv->num_sta_no_ht > 0) {
1789 int i;
1790
1791 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1792
1793 phead = get_list_head(queue);
1794 plist = phead->next;
1795
1796 while (phead != plist) {
1797 uint len;
1798 u8 *p;
1799 struct wlan_bssid_ex *pbss_network;
1800
1801 pnetwork = container_of(plist, struct wlan_network, list);
1802
1803 plist = plist->next;
1804
1805 pbss_network = (struct wlan_bssid_ex *)&pnetwork->network;
1806
1807 p = rtw_get_ie(pbss_network->IEs + _FIXED_IE_LENGTH_, _HT_CAPABILITY_IE_, &len, pbss_network->IELength - _FIXED_IE_LENGTH_);
1808 if ((p == NULL) || (len == 0)) {
1809 if ((pbss_network->Configuration.DSConfig <= 0) || (pbss_network->Configuration.DSConfig > 14))
1810 continue;
1811
1812 ICS[0][pbss_network->Configuration.DSConfig] = 1;
1813
1814 if (ICS[0][0] == 0)
1815 ICS[0][0] = 1;
1816 }
1817 }
1818 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1819
1820 for (i = 0; i < 8; i++) {
1821 if (ICS[i][0] == 1) {
1822 int j, k = 0;
1823
1824 InfoContent[k] = i;
1825
1826 k++;
1827
1828 for (j = 1; j <= 14; j++) {
1829 if (ICS[i][j] == 1) {
1830 if (k < 16) {
1831 InfoContent[k] = j;
1832
1833 k++;
1834 }
1835 }
1836 }
1837
1838 pframe = rtw_set_ie(pframe, EID_BSSIntolerantChlReport, k, InfoContent, &(pattrib->pktlen));
1839 }
1840 }
1841 }
1842
1843
1844 pattrib->last_txcmdsz = pattrib->pktlen;
1845
1846 dump_mgntframe(padapter, pmgntframe);
1847}
1848
1849unsigned int send_delba(struct adapter *padapter, u8 initiator, u8 *addr)
1850{
1851 struct sta_priv *pstapriv = &padapter->stapriv;
1852 struct sta_info *psta = NULL;
1853
1854 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1855 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1856 u16 tid;
1857
1858 if ((pmlmeinfo->state&0x03) != WIFI_FW_AP_STATE)
1859 if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))
1860 return _SUCCESS;
1861
1862 psta = rtw_get_stainfo(pstapriv, addr);
1863 if (psta == NULL)
1864 return _SUCCESS;
1865
1866 if (initiator == 0) {
1867 for (tid = 0; tid < MAXTID; tid++) {
1868 if (psta->recvreorder_ctrl[tid].enable) {
1869 DBG_88E("rx agg disable tid(%d)\n", tid);
1870 issue_action_BA(padapter, addr, RTW_WLAN_ACTION_DELBA, (((tid << 1) | initiator)&0x1F));
1871 psta->recvreorder_ctrl[tid].enable = false;
1872 psta->recvreorder_ctrl[tid].indicate_seq = 0xffff;
1873 }
1874 }
1875 } else if (initiator == 1) {
1876 for (tid = 0; tid < MAXTID; tid++) {
1877 if (psta->htpriv.agg_enable_bitmap & BIT(tid)) {
1878 DBG_88E("tx agg disable tid(%d)\n", tid);
1879 issue_action_BA(padapter, addr, RTW_WLAN_ACTION_DELBA, (((tid << 1) | initiator)&0x1F));
1880 psta->htpriv.agg_enable_bitmap &= ~BIT(tid);
1881 psta->htpriv.candidate_tid_bitmap &= ~BIT(tid);
1882 }
1883 }
1884 }
1885
1886 return _SUCCESS;
1887}
1888
1889unsigned int send_beacon(struct adapter *padapter)
1890{
1891 u8 bxmitok = false;
1892 int issue = 0;
1893 int poll = 0;
1894
1895 unsigned long start = jiffies;
1896
1897 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
1898 do {
1899 issue_beacon(padapter, 100);
1900 issue++;
1901 do {
1902 yield();
1903 rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8 *)(&bxmitok));
1904 poll++;
1905 } while ((poll%10) != 0 && !bxmitok && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
1906 } while (!bxmitok && issue < 100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
1907
1908 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
1909 return _FAIL;
1910 if (!bxmitok) {
1911 DBG_88E("%s fail! %u ms\n", __func__,
1912 jiffies_to_msecs(jiffies - start));
1913 return _FAIL;
1914 } else {
1915 u32 passing_time = jiffies_to_msecs(jiffies - start);
1916
1917 if (passing_time > 100 || issue > 3)
1918 DBG_88E("%s success, issue:%d, poll:%d, %u ms\n",
1919 __func__, issue, poll,
1920 jiffies_to_msecs(jiffies - start));
1921 return _SUCCESS;
1922 }
1923}
1924
1925
1926
1927
1928
1929
1930
1931static void site_survey(struct adapter *padapter)
1932{
1933 unsigned char survey_channel = 0, val8;
1934 enum rt_scan_type ScanType = SCAN_PASSIVE;
1935 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1936 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1937 u32 initialgain = 0;
1938 struct rtw_ieee80211_channel *ch;
1939
1940 if (pmlmeext->sitesurvey_res.channel_idx < pmlmeext->sitesurvey_res.ch_num) {
1941 ch = &pmlmeext->sitesurvey_res.ch[pmlmeext->sitesurvey_res.channel_idx];
1942 survey_channel = ch->hw_value;
1943 ScanType = (ch->flags & RTW_IEEE80211_CHAN_PASSIVE_SCAN) ? SCAN_PASSIVE : SCAN_ACTIVE;
1944 }
1945
1946
1947 if (survey_channel != 0) {
1948
1949
1950
1951
1952 if (pmlmeext->sitesurvey_res.channel_idx == 0)
1953 set_channel_bwmode(padapter, survey_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
1954 else
1955 SelectChannel(padapter, survey_channel);
1956
1957 if (ScanType == SCAN_ACTIVE) {
1958 int i;
1959
1960 for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {
1961 if (pmlmeext->sitesurvey_res.ssid[i].SsidLength) {
1962
1963 issue_probereq(padapter,
1964 &(pmlmeext->sitesurvey_res.ssid[i]),
1965 NULL, false);
1966
1967 issue_probereq(padapter,
1968 &(pmlmeext->sitesurvey_res.ssid[i]),
1969 NULL, false);
1970 }
1971 }
1972
1973 if (pmlmeext->sitesurvey_res.scan_mode == SCAN_ACTIVE) {
1974
1975 issue_probereq(padapter, NULL, NULL, false);
1976
1977 issue_probereq(padapter, NULL, NULL, false);
1978 }
1979
1980 if (pmlmeext->sitesurvey_res.scan_mode == SCAN_ACTIVE) {
1981
1982 issue_probereq(padapter, NULL, NULL, false);
1983
1984 issue_probereq(padapter, NULL, NULL, false);
1985 }
1986 }
1987
1988 set_survey_timer(pmlmeext, pmlmeext->chan_scan_time);
1989 } else {
1990
1991
1992
1993
1994 if (rtw_hal_antdiv_before_linked(padapter)) {
1995 pmlmeext->sitesurvey_res.bss_cnt = 0;
1996 pmlmeext->sitesurvey_res.channel_idx = -1;
1997 pmlmeext->chan_scan_time = SURVEY_TO / 2;
1998 set_survey_timer(pmlmeext, pmlmeext->chan_scan_time);
1999 return;
2000 }
2001
2002 pmlmeext->sitesurvey_res.state = SCAN_COMPLETE;
2003
2004
2005
2006 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
2007
2008
2009
2010
2011
2012
2013 Set_MSR(padapter, (pmlmeinfo->state & 0x3));
2014
2015 initialgain = 0xff;
2016 rtw_hal_set_hwreg(padapter, HW_VAR_INITIAL_GAIN, (u8 *)(&initialgain));
2017
2018 Restore_DM_Func_Flag(padapter);
2019
2020
2021 if (is_client_associated_to_ap(padapter))
2022 issue_nulldata(padapter, NULL, 0, 3, 500);
2023
2024 val8 = 0;
2025 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
2026
2027 report_surveydone_event(padapter);
2028
2029 pmlmeext->chan_scan_time = SURVEY_TO;
2030 pmlmeext->sitesurvey_res.state = SCAN_DISABLE;
2031
2032 issue_action_BSSCoexistPacket(padapter);
2033 issue_action_BSSCoexistPacket(padapter);
2034 issue_action_BSSCoexistPacket(padapter);
2035 }
2036}
2037
2038
2039static u8 collect_bss_info(struct adapter *padapter,
2040 struct recv_frame *precv_frame,
2041 struct wlan_bssid_ex *bssid)
2042{
2043 int i;
2044 u32 len;
2045 u8 *p;
2046 u16 val16, subtype;
2047 u8 *pframe = precv_frame->pkt->data;
2048 u32 packet_len = precv_frame->pkt->len;
2049 u8 ie_offset;
2050 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2051 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2052 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2053
2054 len = packet_len - sizeof(struct ieee80211_hdr_3addr);
2055
2056 if (len > MAX_IE_SZ)
2057 return _FAIL;
2058
2059 memset(bssid, 0, sizeof(struct wlan_bssid_ex));
2060
2061 subtype = GetFrameSubType(pframe);
2062
2063 if (subtype == WIFI_BEACON) {
2064 bssid->Reserved[0] = 1;
2065 ie_offset = _BEACON_IE_OFFSET_;
2066 } else {
2067
2068 if (subtype == WIFI_PROBEREQ) {
2069 ie_offset = _PROBEREQ_IE_OFFSET_;
2070 bssid->Reserved[0] = 2;
2071 } else if (subtype == WIFI_PROBERSP) {
2072 ie_offset = _PROBERSP_IE_OFFSET_;
2073 bssid->Reserved[0] = 3;
2074 } else {
2075 bssid->Reserved[0] = 0;
2076 ie_offset = _FIXED_IE_LENGTH_;
2077 }
2078 }
2079
2080 bssid->Length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;
2081
2082
2083 bssid->IELength = len;
2084 memcpy(bssid->IEs, (pframe + sizeof(struct ieee80211_hdr_3addr)), bssid->IELength);
2085
2086
2087 bssid->Rssi = precv_frame->attrib.phy_info.recvpower;
2088 bssid->PhyInfo.SignalQuality = precv_frame->attrib.phy_info.SignalQuality;
2089 bssid->PhyInfo.SignalStrength = precv_frame->attrib.phy_info.SignalStrength;
2090 rtw_hal_get_def_var(padapter, HAL_DEF_CURRENT_ANTENNA, &bssid->PhyInfo.Optimum_antenna);
2091
2092
2093 p = rtw_get_ie(bssid->IEs + ie_offset, _SSID_IE_, &len, bssid->IELength - ie_offset);
2094 if (!p) {
2095 DBG_88E("marc: cannot find SSID for survey event\n");
2096 return _FAIL;
2097 }
2098
2099 if (len) {
2100 if (len > NDIS_802_11_LENGTH_SSID) {
2101 DBG_88E("%s()-%d: IE too long (%d) for survey event\n", __func__, __LINE__, len);
2102 return _FAIL;
2103 }
2104 memcpy(bssid->Ssid.Ssid, (p + 2), len);
2105 bssid->Ssid.SsidLength = len;
2106 } else {
2107 bssid->Ssid.SsidLength = 0;
2108 }
2109
2110 memset(bssid->SupportedRates, 0, NDIS_802_11_LENGTH_RATES_EX);
2111
2112
2113 i = 0;
2114 p = rtw_get_ie(bssid->IEs + ie_offset, _SUPPORTEDRATES_IE_, &len, bssid->IELength - ie_offset);
2115 if (p != NULL) {
2116 if (len > NDIS_802_11_LENGTH_RATES_EX) {
2117 DBG_88E("%s()-%d: IE too long (%d) for survey event\n", __func__, __LINE__, len);
2118 return _FAIL;
2119 }
2120 memcpy(bssid->SupportedRates, (p + 2), len);
2121 i = len;
2122 }
2123
2124 p = rtw_get_ie(bssid->IEs + ie_offset, _EXT_SUPPORTEDRATES_IE_, &len, bssid->IELength - ie_offset);
2125 if (p) {
2126 if (len > (NDIS_802_11_LENGTH_RATES_EX-i)) {
2127 DBG_88E("%s()-%d: IE too long (%d) for survey event\n", __func__, __LINE__, len);
2128 return _FAIL;
2129 }
2130 memcpy(bssid->SupportedRates + i, (p + 2), len);
2131 }
2132
2133
2134 bssid->NetworkTypeInUse = Ndis802_11OFDM24;
2135
2136 if (bssid->IELength < 12)
2137 return _FAIL;
2138
2139
2140 p = rtw_get_ie(bssid->IEs + ie_offset, _DSSET_IE_, &len, bssid->IELength - ie_offset);
2141
2142 bssid->Configuration.DSConfig = 0;
2143 bssid->Configuration.Length = 0;
2144
2145 if (p) {
2146 bssid->Configuration.DSConfig = *(p + 2);
2147 } else {
2148
2149 p = rtw_get_ie(bssid->IEs + ie_offset, _HT_ADD_INFO_IE_, &len, bssid->IELength - ie_offset);
2150 if (p) {
2151 struct HT_info_element *HT_info = (struct HT_info_element *)(p + 2);
2152
2153 bssid->Configuration.DSConfig = HT_info->primary_channel;
2154 } else {
2155 bssid->Configuration.DSConfig = rtw_get_oper_ch(padapter);
2156 }
2157 }
2158
2159 if (subtype == WIFI_PROBEREQ) {
2160
2161 bssid->InfrastructureMode = Ndis802_11Infrastructure;
2162 ether_addr_copy(bssid->MacAddress, GetAddr2Ptr(pframe));
2163 bssid->Privacy = 1;
2164 return _SUCCESS;
2165 }
2166
2167 bssid->Configuration.BeaconPeriod =
2168 get_unaligned_le16(rtw_get_beacon_interval_from_ie(bssid->IEs));
2169
2170 val16 = rtw_get_capability((struct wlan_bssid_ex *)bssid);
2171
2172 if (val16 & BIT(0)) {
2173 bssid->InfrastructureMode = Ndis802_11Infrastructure;
2174 ether_addr_copy(bssid->MacAddress, GetAddr2Ptr(pframe));
2175 } else {
2176 bssid->InfrastructureMode = Ndis802_11IBSS;
2177 ether_addr_copy(bssid->MacAddress, GetAddr3Ptr(pframe));
2178 }
2179
2180 if (val16 & BIT(4))
2181 bssid->Privacy = 1;
2182 else
2183 bssid->Privacy = 0;
2184
2185 bssid->Configuration.ATIMWindow = 0;
2186
2187
2188 if ((pregistrypriv->wifi_spec == 1) && (!pmlmeinfo->bwmode_updated)) {
2189 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2190
2191 p = rtw_get_ie(bssid->IEs + ie_offset, _HT_CAPABILITY_IE_, &len, bssid->IELength - ie_offset);
2192 if (p && len > 0) {
2193 struct ieee80211_ht_cap *pHT_caps =
2194 (struct ieee80211_ht_cap *)(p + 2);
2195
2196 if (le16_to_cpu(pHT_caps->cap_info) & BIT(14))
2197 pmlmepriv->num_FortyMHzIntolerant++;
2198 } else {
2199 pmlmepriv->num_sta_no_ht++;
2200 }
2201 }
2202
2203
2204 if (bssid->Configuration.DSConfig != rtw_get_oper_ch(padapter))
2205 bssid->PhyInfo.SignalQuality = 101;
2206 return _SUCCESS;
2207}
2208
2209static void start_create_ibss(struct adapter *padapter)
2210{
2211 unsigned short caps;
2212 u8 val8;
2213 u8 join_type;
2214 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2215 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2216 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)(&(pmlmeinfo->network));
2217
2218 pmlmeext->cur_channel = (u8)pnetwork->Configuration.DSConfig;
2219 pmlmeinfo->bcn_interval = get_beacon_interval(pnetwork);
2220
2221
2222 update_wireless_mode(padapter);
2223
2224
2225 caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);
2226 update_capinfo(padapter, caps);
2227 if (caps&cap_IBSS) {
2228 val8 = 0xcf;
2229 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
2230
2231
2232
2233 set_channel_bwmode(padapter, pmlmeext->cur_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
2234
2235 beacon_timing_control(padapter);
2236
2237
2238 pmlmeinfo->state = WIFI_FW_ADHOC_STATE;
2239 Set_MSR(padapter, (pmlmeinfo->state & 0x3));
2240
2241
2242 if (send_beacon(padapter) == _FAIL) {
2243 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("issuing beacon frame fail....\n"));
2244
2245 report_join_res(padapter, -1);
2246 pmlmeinfo->state = WIFI_FW_NULL_STATE;
2247 } else {
2248 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, padapter->registrypriv.dev_network.MacAddress);
2249 join_type = 0;
2250 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
2251
2252 report_join_res(padapter, 1);
2253 pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
2254 }
2255 } else {
2256 DBG_88E("%s, invalid cap:%x\n", __func__, caps);
2257 return;
2258 }
2259}
2260
2261static void start_clnt_join(struct adapter *padapter)
2262{
2263 unsigned short caps;
2264 u8 val8;
2265 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2266 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2267 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)(&(pmlmeinfo->network));
2268 int beacon_timeout;
2269
2270 pmlmeext->cur_channel = (u8)pnetwork->Configuration.DSConfig;
2271 pmlmeinfo->bcn_interval = get_beacon_interval(pnetwork);
2272
2273
2274 update_wireless_mode(padapter);
2275
2276
2277 caps = rtw_get_capability((struct wlan_bssid_ex *)pnetwork);
2278 update_capinfo(padapter, caps);
2279 if (caps&cap_ESS) {
2280 Set_MSR(padapter, WIFI_FW_STATION_STATE);
2281
2282 val8 = (pmlmeinfo->auth_algo == dot11AuthAlgrthm_8021X) ? 0xcc : 0xcf;
2283
2284 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
2285
2286
2287 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
2288
2289
2290
2291 beacon_timeout = decide_wait_for_beacon_timeout(pmlmeinfo->bcn_interval);
2292 set_link_timer(pmlmeext, beacon_timeout);
2293 mod_timer(&padapter->mlmepriv.assoc_timer, jiffies +
2294 msecs_to_jiffies((REAUTH_TO * REAUTH_LIMIT) + (REASSOC_TO * REASSOC_LIMIT) + beacon_timeout));
2295
2296 pmlmeinfo->state = WIFI_FW_AUTH_NULL | WIFI_FW_STATION_STATE;
2297 } else if (caps&cap_IBSS) {
2298 Set_MSR(padapter, WIFI_FW_ADHOC_STATE);
2299
2300 val8 = 0xcf;
2301 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
2302
2303
2304 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
2305
2306 beacon_timing_control(padapter);
2307
2308 pmlmeinfo->state = WIFI_FW_ADHOC_STATE;
2309
2310 report_join_res(padapter, 1);
2311 } else {
2312 return;
2313 }
2314}
2315
2316static void start_clnt_auth(struct adapter *padapter)
2317{
2318 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2319 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2320
2321 del_timer_sync(&pmlmeext->link_timer);
2322
2323 pmlmeinfo->state &= (~WIFI_FW_AUTH_NULL);
2324 pmlmeinfo->state |= WIFI_FW_AUTH_STATE;
2325
2326 pmlmeinfo->auth_seq = 1;
2327 pmlmeinfo->reauth_count = 0;
2328 pmlmeinfo->reassoc_count = 0;
2329 pmlmeinfo->link_count = 0;
2330 pmlmeext->retry = 0;
2331
2332
2333
2334
2335
2336
2337
2338 issue_deauth(padapter, (&(pmlmeinfo->network))->MacAddress, WLAN_REASON_DEAUTH_LEAVING);
2339
2340 DBG_88E_LEVEL(_drv_info_, "start auth\n");
2341 issue_auth(padapter, NULL, 0);
2342
2343 set_link_timer(pmlmeext, REAUTH_TO);
2344}
2345
2346
2347static void start_clnt_assoc(struct adapter *padapter)
2348{
2349 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2350 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2351
2352 del_timer_sync(&pmlmeext->link_timer);
2353
2354 pmlmeinfo->state &= (~(WIFI_FW_AUTH_NULL | WIFI_FW_AUTH_STATE));
2355 pmlmeinfo->state |= (WIFI_FW_AUTH_SUCCESS | WIFI_FW_ASSOC_STATE);
2356
2357 issue_assocreq(padapter);
2358
2359 set_link_timer(pmlmeext, REASSOC_TO);
2360}
2361
2362static unsigned int receive_disconnect(struct adapter *padapter,
2363 unsigned char *MacAddr,
2364 unsigned short reason)
2365{
2366 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2367 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2368 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
2369
2370
2371 if (memcmp(MacAddr, pnetwork->MacAddress, ETH_ALEN))
2372 return _SUCCESS;
2373
2374 DBG_88E("%s\n", __func__);
2375
2376 if ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE) {
2377 if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
2378 pmlmeinfo->state = WIFI_FW_NULL_STATE;
2379 report_del_sta_event(padapter, MacAddr, reason);
2380 } else if (pmlmeinfo->state & WIFI_FW_LINKING_STATE) {
2381 pmlmeinfo->state = WIFI_FW_NULL_STATE;
2382 report_join_res(padapter, -2);
2383 }
2384 }
2385 return _SUCCESS;
2386}
2387
2388static void process_80211d(struct adapter *padapter, struct wlan_bssid_ex *bssid)
2389{
2390 struct registry_priv *pregistrypriv;
2391 struct mlme_ext_priv *pmlmeext;
2392 struct rt_channel_info *chplan_new;
2393 u8 channel;
2394 u8 i;
2395
2396 pregistrypriv = &padapter->registrypriv;
2397 pmlmeext = &padapter->mlmeextpriv;
2398
2399
2400 if (pregistrypriv->enable80211d &&
2401 (!pmlmeext->update_channel_plan_by_ap_done)) {
2402 u8 *ie, *p;
2403 u32 len;
2404 struct rt_channel_plan chplan_ap;
2405 struct rt_channel_info chplan_sta[MAX_CHANNEL_NUM];
2406 u8 country[4];
2407 u8 fcn;
2408 u8 noc;
2409 u8 j, k;
2410
2411 ie = rtw_get_ie(bssid->IEs + _FIXED_IE_LENGTH_, _COUNTRY_IE_, &len, bssid->IELength - _FIXED_IE_LENGTH_);
2412 if (!ie)
2413 return;
2414 if (len < 6)
2415 return;
2416 ie += 2;
2417 p = ie;
2418 ie += len;
2419
2420 memset(country, 0, 4);
2421 memcpy(country, p, 3);
2422 p += 3;
2423 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
2424 ("%s: 802.11d country =%s\n", __func__, country));
2425
2426 i = 0;
2427 while ((ie - p) >= 3) {
2428 fcn = *(p++);
2429 noc = *(p++);
2430 p++;
2431
2432 for (j = 0; j < noc; j++) {
2433 if (fcn <= 14)
2434 channel = fcn + j;
2435 else
2436 channel = fcn + j*4;
2437
2438 chplan_ap.Channel[i++] = channel;
2439 }
2440 }
2441 chplan_ap.Len = i;
2442
2443 memcpy(chplan_sta, pmlmeext->channel_set, sizeof(chplan_sta));
2444
2445 memset(pmlmeext->channel_set, 0, sizeof(pmlmeext->channel_set));
2446 chplan_new = pmlmeext->channel_set;
2447
2448 i = 0;
2449 j = 0;
2450 k = 0;
2451 if (pregistrypriv->wireless_mode & WIRELESS_11G) {
2452 do {
2453 if ((i == MAX_CHANNEL_NUM) ||
2454 (chplan_sta[i].ChannelNum == 0) ||
2455 (chplan_sta[i].ChannelNum > 14))
2456 break;
2457
2458 if ((j == chplan_ap.Len) || (chplan_ap.Channel[j] > 14))
2459 break;
2460
2461 if (chplan_sta[i].ChannelNum == chplan_ap.Channel[j]) {
2462 chplan_new[k].ChannelNum = chplan_ap.Channel[j];
2463 chplan_new[k].ScanType = SCAN_ACTIVE;
2464 i++;
2465 j++;
2466 k++;
2467 } else if (chplan_sta[i].ChannelNum < chplan_ap.Channel[j]) {
2468 chplan_new[k].ChannelNum = chplan_sta[i].ChannelNum;
2469 chplan_new[k].ScanType = SCAN_PASSIVE;
2470 i++;
2471 k++;
2472 } else if (chplan_sta[i].ChannelNum > chplan_ap.Channel[j]) {
2473 chplan_new[k].ChannelNum = chplan_ap.Channel[j];
2474 chplan_new[k].ScanType = SCAN_ACTIVE;
2475 j++;
2476 k++;
2477 }
2478 } while (1);
2479
2480
2481 while ((i < MAX_CHANNEL_NUM) &&
2482 (chplan_sta[i].ChannelNum != 0) &&
2483 (chplan_sta[i].ChannelNum <= 14)) {
2484 chplan_new[k].ChannelNum = chplan_sta[i].ChannelNum;
2485 chplan_new[k].ScanType = SCAN_PASSIVE;
2486 i++;
2487 k++;
2488 }
2489
2490
2491 while ((j < chplan_ap.Len) && (chplan_ap.Channel[j] <= 14)) {
2492 chplan_new[k].ChannelNum = chplan_ap.Channel[j];
2493 chplan_new[k].ScanType = SCAN_ACTIVE;
2494 j++;
2495 k++;
2496 }
2497 } else {
2498
2499 while ((i < MAX_CHANNEL_NUM) &&
2500 (chplan_sta[i].ChannelNum != 0) &&
2501 (chplan_sta[i].ChannelNum <= 14)) {
2502 chplan_new[k].ChannelNum = chplan_sta[i].ChannelNum;
2503 chplan_new[k].ScanType = chplan_sta[i].ScanType;
2504 i++;
2505 k++;
2506 }
2507
2508
2509 while ((j < chplan_ap.Len) && (chplan_ap.Channel[j] <= 14))
2510 j++;
2511 }
2512
2513
2514 while ((i < MAX_CHANNEL_NUM) && (chplan_sta[i].ChannelNum != 0)) {
2515 chplan_new[k].ChannelNum = chplan_sta[i].ChannelNum;
2516 chplan_new[k].ScanType = chplan_sta[i].ScanType;
2517 i++;
2518 k++;
2519 }
2520
2521 pmlmeext->update_channel_plan_by_ap_done = 1;
2522 }
2523
2524
2525 channel = bssid->Configuration.DSConfig;
2526 chplan_new = pmlmeext->channel_set;
2527 i = 0;
2528 while ((i < MAX_CHANNEL_NUM) && (chplan_new[i].ChannelNum != 0)) {
2529 if (chplan_new[i].ChannelNum == channel) {
2530 if (chplan_new[i].ScanType == SCAN_PASSIVE) {
2531 chplan_new[i].ScanType = SCAN_ACTIVE;
2532 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
2533 ("%s: change channel %d scan type from passive to active\n",
2534 __func__, channel));
2535 }
2536 break;
2537 }
2538 i++;
2539 }
2540}
2541
2542
2543
2544
2545
2546
2547
2548static unsigned int OnProbeReq(struct adapter *padapter,
2549 struct recv_frame *precv_frame)
2550{
2551 unsigned int ielen;
2552 unsigned char *p;
2553 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2554 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2555 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2556 struct wlan_bssid_ex *cur = &(pmlmeinfo->network);
2557 u8 *pframe = precv_frame->pkt->data;
2558 uint len = precv_frame->pkt->len;
2559
2560 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
2561 return _SUCCESS;
2562
2563 if (!check_fwstate(pmlmepriv, _FW_LINKED) &&
2564 !check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE))
2565 return _SUCCESS;
2566
2567 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, &ielen,
2568 len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
2569
2570
2571 if (p) {
2572 if ((ielen != 0 && memcmp((void *)(p+2), (void *)cur->Ssid.Ssid, cur->Ssid.SsidLength)) ||
2573 (ielen == 0 && pmlmeinfo->hidden_ssid_mode))
2574 return _SUCCESS;
2575
2576 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
2577 pmlmepriv->cur_network.join_res)
2578 issue_probersp(padapter, get_sa(pframe));
2579 }
2580 return _SUCCESS;
2581}
2582
2583static unsigned int OnProbeRsp(struct adapter *padapter,
2584 struct recv_frame *precv_frame)
2585{
2586 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2587
2588 if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {
2589 report_survey_event(padapter, precv_frame);
2590 return _SUCCESS;
2591 }
2592
2593 return _SUCCESS;
2594}
2595
2596static unsigned int OnBeacon(struct adapter *padapter,
2597 struct recv_frame *precv_frame)
2598{
2599 int cam_idx;
2600 struct sta_info *psta;
2601 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2602 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2603 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2604 struct sta_priv *pstapriv = &padapter->stapriv;
2605 u8 *pframe = precv_frame->pkt->data;
2606 uint len = precv_frame->pkt->len;
2607 struct wlan_bssid_ex *pbss;
2608 int ret = _SUCCESS;
2609 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
2610
2611 if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS) {
2612 report_survey_event(padapter, precv_frame);
2613 return _SUCCESS;
2614 }
2615
2616 if (!memcmp(GetAddr3Ptr(pframe), pnetwork->MacAddress, ETH_ALEN)) {
2617 if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {
2618
2619 pbss = (struct wlan_bssid_ex *)rtw_malloc(sizeof(struct wlan_bssid_ex));
2620 if (pbss) {
2621 if (collect_bss_info(padapter, precv_frame, pbss) == _SUCCESS) {
2622 update_network(&(pmlmepriv->cur_network.network), pbss, padapter, true);
2623 rtw_get_bcn_info(&(pmlmepriv->cur_network));
2624 }
2625 kfree(pbss);
2626 }
2627
2628
2629 pmlmeinfo->assoc_AP_vendor = check_assoc_AP(pframe+sizeof(struct ieee80211_hdr_3addr), len-sizeof(struct ieee80211_hdr_3addr));
2630
2631
2632 update_TSF(pmlmeext, pframe, len);
2633
2634
2635 start_clnt_auth(padapter);
2636
2637 return _SUCCESS;
2638 }
2639
2640 if (((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE) && (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
2641 psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
2642 if (psta != NULL) {
2643 ret = rtw_check_bcn_info(padapter, pframe, len);
2644 if (!ret) {
2645 DBG_88E_LEVEL(_drv_info_, "ap has changed, disconnect now\n ");
2646 receive_disconnect(padapter, pmlmeinfo->network.MacAddress, 65535);
2647 return _SUCCESS;
2648 }
2649
2650
2651 if ((sta_rx_pkts(psta) & 0xf) == 0)
2652 update_beacon_info(padapter, pframe, len, psta);
2653 }
2654 } else if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) {
2655 psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
2656 if (psta != NULL) {
2657
2658
2659 if ((sta_rx_pkts(psta) & 0xf) == 0)
2660 update_beacon_info(padapter, pframe, len, psta);
2661 } else {
2662
2663 cam_idx = allocate_fw_sta_entry(padapter);
2664 if (cam_idx == NUM_STA)
2665 goto _END_ONBEACON_;
2666
2667
2668 if (update_sta_support_rate(padapter, (pframe + WLAN_HDR_A3_LEN + _BEACON_IE_OFFSET_), (len - WLAN_HDR_A3_LEN - _BEACON_IE_OFFSET_), cam_idx) == _FAIL) {
2669 pmlmeinfo->FW_sta_info[cam_idx].status = 0;
2670 goto _END_ONBEACON_;
2671 }
2672
2673
2674 update_TSF(pmlmeext, pframe, len);
2675
2676
2677 report_add_sta_event(padapter, GetAddr2Ptr(pframe), cam_idx);
2678 }
2679 }
2680 }
2681
2682_END_ONBEACON_:
2683
2684 return _SUCCESS;
2685}
2686
2687#ifdef CONFIG_88EU_AP_MODE
2688static unsigned int OnAuth(struct adapter *padapter,
2689 struct recv_frame *precv_frame)
2690{
2691 unsigned int auth_mode, ie_len;
2692 u16 seq;
2693 unsigned char *sa, *p;
2694 u16 algorithm;
2695 int status;
2696 static struct sta_info stat;
2697 struct sta_info *pstat = NULL;
2698 struct sta_priv *pstapriv = &padapter->stapriv;
2699 struct security_priv *psecuritypriv = &padapter->securitypriv;
2700 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2701 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2702 u8 *pframe = precv_frame->pkt->data;
2703 uint len = precv_frame->pkt->len;
2704
2705 if ((pmlmeinfo->state&0x03) != WIFI_FW_AP_STATE)
2706 return _FAIL;
2707
2708 DBG_88E("+%s\n", __func__);
2709
2710 sa = GetAddr2Ptr(pframe);
2711
2712 auth_mode = psecuritypriv->dot11AuthAlgrthm;
2713 seq = le16_to_cpu(*(__le16 *)((size_t)pframe + WLAN_HDR_A3_LEN + 2));
2714 algorithm = le16_to_cpu(*(__le16 *)((size_t)pframe + WLAN_HDR_A3_LEN));
2715
2716 DBG_88E("auth alg=%x, seq=%X\n", algorithm, seq);
2717
2718 if (auth_mode == 2 && psecuritypriv->dot11PrivacyAlgrthm != _WEP40_ &&
2719 psecuritypriv->dot11PrivacyAlgrthm != _WEP104_)
2720 auth_mode = 0;
2721
2722 if ((algorithm > 0 && auth_mode == 0) ||
2723 (algorithm == 0 && auth_mode == 1)) {
2724 DBG_88E("auth rejected due to bad alg [alg=%d, auth_mib=%d] %02X%02X%02X%02X%02X%02X\n",
2725 algorithm, auth_mode, sa[0], sa[1], sa[2], sa[3], sa[4], sa[5]);
2726
2727 status = _STATS_NO_SUPP_ALG_;
2728
2729 goto auth_fail;
2730 }
2731
2732 if (!rtw_access_ctrl(padapter, sa)) {
2733 status = _STATS_UNABLE_HANDLE_STA_;
2734 goto auth_fail;
2735 }
2736
2737 pstat = rtw_get_stainfo(pstapriv, sa);
2738 if (!pstat) {
2739
2740 DBG_88E("going to alloc stainfo for sa=%pM\n", sa);
2741 pstat = rtw_alloc_stainfo(pstapriv, sa);
2742 if (!pstat) {
2743 DBG_88E(" Exceed the upper limit of supported clients...\n");
2744 status = _STATS_UNABLE_HANDLE_STA_;
2745 goto auth_fail;
2746 }
2747
2748 pstat->state = WIFI_FW_AUTH_NULL;
2749 pstat->auth_seq = 0;
2750 } else {
2751 spin_lock_bh(&pstapriv->asoc_list_lock);
2752 if (!list_empty(&pstat->asoc_list)) {
2753 list_del_init(&pstat->asoc_list);
2754 pstapriv->asoc_list_cnt--;
2755 }
2756 spin_unlock_bh(&pstapriv->asoc_list_lock);
2757
2758 if (seq == 1) {
2759
2760 }
2761 }
2762
2763 spin_lock_bh(&pstapriv->auth_list_lock);
2764 if (list_empty(&pstat->auth_list)) {
2765 list_add_tail(&pstat->auth_list, &pstapriv->auth_list);
2766 pstapriv->auth_list_cnt++;
2767 }
2768 spin_unlock_bh(&pstapriv->auth_list_lock);
2769
2770 if (pstat->auth_seq == 0)
2771 pstat->expire_to = pstapriv->auth_to;
2772
2773 if ((pstat->auth_seq + 1) != seq) {
2774 DBG_88E("(1)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
2775 seq, pstat->auth_seq+1);
2776 status = _STATS_OUT_OF_AUTH_SEQ_;
2777 goto auth_fail;
2778 }
2779
2780 if (algorithm == 0 && (auth_mode == 0 || auth_mode == 2)) {
2781 if (seq == 1) {
2782 pstat->state &= ~WIFI_FW_AUTH_NULL;
2783 pstat->state |= WIFI_FW_AUTH_SUCCESS;
2784 pstat->expire_to = pstapriv->assoc_to;
2785 pstat->authalg = algorithm;
2786 } else {
2787 DBG_88E("(2)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
2788 seq, pstat->auth_seq+1);
2789 status = _STATS_OUT_OF_AUTH_SEQ_;
2790 goto auth_fail;
2791 }
2792 } else {
2793 if (seq == 1) {
2794
2795
2796 pstat->state &= ~WIFI_FW_AUTH_NULL;
2797 pstat->state |= WIFI_FW_AUTH_STATE;
2798 pstat->authalg = algorithm;
2799 pstat->auth_seq = 2;
2800 } else if (seq == 3) {
2801
2802 DBG_88E("checking for challenging txt...\n");
2803
2804 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + 4 + _AUTH_IE_OFFSET_, _CHLGETXT_IE_, &ie_len,
2805 len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_ - 4);
2806
2807 if ((p == NULL) || (ie_len <= 0)) {
2808 DBG_88E("auth rejected because challenge failure!(1)\n");
2809 status = _STATS_CHALLENGE_FAIL_;
2810 goto auth_fail;
2811 }
2812
2813 if (!memcmp((void *)(p + 2), pstat->chg_txt, 128)) {
2814 pstat->state &= (~WIFI_FW_AUTH_STATE);
2815 pstat->state |= WIFI_FW_AUTH_SUCCESS;
2816
2817 pstat->expire_to = pstapriv->assoc_to;
2818 } else {
2819 DBG_88E("auth rejected because challenge failure!\n");
2820 status = _STATS_CHALLENGE_FAIL_;
2821 goto auth_fail;
2822 }
2823 } else {
2824 DBG_88E("(3)auth rejected because out of seq [rx_seq=%d, exp_seq=%d]!\n",
2825 seq, pstat->auth_seq+1);
2826 status = _STATS_OUT_OF_AUTH_SEQ_;
2827 goto auth_fail;
2828 }
2829 }
2830
2831
2832 pstat->auth_seq = seq + 1;
2833
2834 issue_auth(padapter, pstat, (unsigned short)(_STATS_SUCCESSFUL_));
2835
2836 if (pstat->state & WIFI_FW_AUTH_SUCCESS)
2837 pstat->auth_seq = 0;
2838
2839 return _SUCCESS;
2840
2841auth_fail:
2842
2843 if (pstat)
2844 rtw_free_stainfo(padapter, pstat);
2845
2846 pstat = &stat;
2847 memset((char *)pstat, '\0', sizeof(stat));
2848 pstat->auth_seq = 2;
2849 memcpy(pstat->hwaddr, sa, 6);
2850
2851 issue_auth(padapter, pstat, (unsigned short)status);
2852
2853 return _FAIL;
2854}
2855#endif
2856
2857static unsigned int OnAuthClient(struct adapter *padapter,
2858 struct recv_frame *precv_frame)
2859{
2860 unsigned int seq, len, status, offset;
2861 unsigned char *p;
2862 unsigned int go2asoc = 0;
2863 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2864 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2865 u8 *pframe = precv_frame->pkt->data;
2866 uint pkt_len = precv_frame->pkt->len;
2867
2868 DBG_88E("%s\n", __func__);
2869
2870
2871 if (memcmp(myid(&(padapter->eeprompriv)), get_da(pframe), ETH_ALEN))
2872 return _SUCCESS;
2873
2874 if (!(pmlmeinfo->state & WIFI_FW_AUTH_STATE))
2875 return _SUCCESS;
2876
2877 offset = (GetPrivacy(pframe)) ? 4 : 0;
2878
2879 seq = le16_to_cpu(*(__le16 *)((size_t)pframe + WLAN_HDR_A3_LEN + offset + 2));
2880 status = le16_to_cpu(*(__le16 *)((size_t)pframe + WLAN_HDR_A3_LEN + offset + 4));
2881
2882 if (status != 0) {
2883 DBG_88E("clnt auth fail, status: %d\n", status);
2884 if (status == 13) {
2885 if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)
2886 pmlmeinfo->auth_algo = dot11AuthAlgrthm_Open;
2887 else
2888 pmlmeinfo->auth_algo = dot11AuthAlgrthm_Shared;
2889 }
2890
2891 set_link_timer(pmlmeext, 1);
2892 goto authclnt_fail;
2893 }
2894
2895 if (seq == 2) {
2896 if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared) {
2897
2898 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _AUTH_IE_OFFSET_, _CHLGETXT_IE_, &len,
2899 pkt_len - WLAN_HDR_A3_LEN - _AUTH_IE_OFFSET_);
2900
2901 if (p == NULL)
2902 goto authclnt_fail;
2903
2904 memcpy((void *)(pmlmeinfo->chg_txt), (void *)(p + 2), len);
2905 pmlmeinfo->auth_seq = 3;
2906 issue_auth(padapter, NULL, 0);
2907 set_link_timer(pmlmeext, REAUTH_TO);
2908
2909 return _SUCCESS;
2910 } else {
2911
2912 go2asoc = 1;
2913 }
2914 } else if (seq == 4) {
2915 if (pmlmeinfo->auth_algo == dot11AuthAlgrthm_Shared)
2916 go2asoc = 1;
2917 else
2918 goto authclnt_fail;
2919 } else {
2920
2921 goto authclnt_fail;
2922 }
2923
2924 if (go2asoc) {
2925 DBG_88E_LEVEL(_drv_info_, "auth success, start assoc\n");
2926 start_clnt_assoc(padapter);
2927 return _SUCCESS;
2928 }
2929authclnt_fail:
2930 return _FAIL;
2931}
2932
2933static unsigned int OnAssocReq(struct adapter *padapter,
2934 struct recv_frame *precv_frame)
2935{
2936#ifdef CONFIG_88EU_AP_MODE
2937 u16 capab_info;
2938 struct rtw_ieee802_11_elems elems;
2939 struct sta_info *pstat;
2940 unsigned char reassoc, *p, *pos, *wpa_ie;
2941 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01};
2942 int i, wpa_ie_len, left;
2943 unsigned char supportRate[16];
2944 int supportRateNum;
2945 unsigned short status = _STATS_SUCCESSFUL_;
2946 unsigned short frame_type, ie_offset = 0;
2947 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2948 struct security_priv *psecuritypriv = &padapter->securitypriv;
2949 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2950 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2951 struct wlan_bssid_ex *cur = &(pmlmeinfo->network);
2952 struct sta_priv *pstapriv = &padapter->stapriv;
2953 u8 *pframe = precv_frame->pkt->data;
2954 uint ie_len, pkt_len = precv_frame->pkt->len;
2955
2956 if ((pmlmeinfo->state&0x03) != WIFI_FW_AP_STATE)
2957 return _FAIL;
2958
2959 frame_type = GetFrameSubType(pframe);
2960 if (frame_type == WIFI_ASSOCREQ) {
2961 reassoc = 0;
2962 ie_offset = _ASOCREQ_IE_OFFSET_;
2963 } else {
2964 reassoc = 1;
2965 ie_offset = _REASOCREQ_IE_OFFSET_;
2966 }
2967
2968
2969 if (pkt_len < IEEE80211_3ADDR_LEN + ie_offset) {
2970 DBG_88E("handle_assoc(reassoc=%d) - too short payload (len=%lu)"
2971 "\n", reassoc, (unsigned long)pkt_len);
2972 return _FAIL;
2973 }
2974
2975 pstat = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
2976 if (!pstat) {
2977 status = _RSON_CLS2_;
2978 goto asoc_class2_error;
2979 }
2980
2981 capab_info = get_unaligned_le16(pframe + WLAN_HDR_A3_LEN);
2982
2983 left = pkt_len - (IEEE80211_3ADDR_LEN + ie_offset);
2984 pos = pframe + (IEEE80211_3ADDR_LEN + ie_offset);
2985
2986
2987 DBG_88E("%s\n", __func__);
2988
2989
2990 if (!((pstat->state) & WIFI_FW_AUTH_SUCCESS)) {
2991 if (!((pstat->state) & WIFI_FW_ASSOC_SUCCESS)) {
2992 status = _RSON_CLS2_;
2993 goto asoc_class2_error;
2994 } else {
2995 pstat->state &= (~WIFI_FW_ASSOC_SUCCESS);
2996 pstat->state |= WIFI_FW_ASSOC_STATE;
2997 }
2998 } else {
2999 pstat->state &= (~WIFI_FW_AUTH_SUCCESS);
3000 pstat->state |= WIFI_FW_ASSOC_STATE;
3001 }
3002 pstat->capability = capab_info;
3003
3004 if (rtw_ieee802_11_parse_elems(pos, left, &elems, 1) == ParseFailed ||
3005 !elems.ssid) {
3006 DBG_88E("STA %pM sent invalid association request\n",
3007 pstat->hwaddr);
3008 status = _STATS_FAILURE_;
3009 goto OnAssocReqFail;
3010 }
3011
3012
3013
3014
3015 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + ie_offset, _SSID_IE_, &ie_len,
3016 pkt_len - WLAN_HDR_A3_LEN - ie_offset);
3017 if (!p)
3018 status = _STATS_FAILURE_;
3019
3020 if (ie_len == 0) {
3021 status = _STATS_FAILURE_;
3022 } else {
3023
3024 if (memcmp((void *)(p+2), cur->Ssid.Ssid, cur->Ssid.SsidLength))
3025 status = _STATS_FAILURE_;
3026
3027 if (ie_len != cur->Ssid.SsidLength)
3028 status = _STATS_FAILURE_;
3029 }
3030
3031 if (_STATS_SUCCESSFUL_ != status)
3032 goto OnAssocReqFail;
3033
3034
3035 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + ie_offset, _SUPPORTEDRATES_IE_, &ie_len, pkt_len - WLAN_HDR_A3_LEN - ie_offset);
3036 if (p == NULL) {
3037 DBG_88E("Rx a sta assoc-req which supported rate is empty!\n");
3038
3039
3040
3041
3042 status = _STATS_FAILURE_;
3043 goto OnAssocReqFail;
3044 } else {
3045 memcpy(supportRate, p+2, ie_len);
3046 supportRateNum = ie_len;
3047
3048 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + ie_offset, _EXT_SUPPORTEDRATES_IE_, &ie_len,
3049 pkt_len - WLAN_HDR_A3_LEN - ie_offset);
3050 if (p != NULL) {
3051 if (supportRateNum <= sizeof(supportRate)) {
3052 memcpy(supportRate+supportRateNum, p+2, ie_len);
3053 supportRateNum += ie_len;
3054 }
3055 }
3056 }
3057
3058
3059
3060
3061
3062 pstat->bssratelen = supportRateNum;
3063 memcpy(pstat->bssrateset, supportRate, supportRateNum);
3064 UpdateBrateTblForSoftAP(pstat->bssrateset, pstat->bssratelen);
3065
3066
3067 pstat->dot8021xalg = 0;
3068 pstat->wpa_psk = 0;
3069 pstat->wpa_group_cipher = 0;
3070 pstat->wpa2_group_cipher = 0;
3071 pstat->wpa_pairwise_cipher = 0;
3072 pstat->wpa2_pairwise_cipher = 0;
3073 memset(pstat->wpa_ie, 0, sizeof(pstat->wpa_ie));
3074 if ((psecuritypriv->wpa_psk & BIT(1)) && elems.rsn_ie) {
3075 int group_cipher = 0, pairwise_cipher = 0;
3076
3077 wpa_ie = elems.rsn_ie;
3078 wpa_ie_len = elems.rsn_ie_len;
3079
3080 if (rtw_parse_wpa2_ie(wpa_ie-2, wpa_ie_len+2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
3081 pstat->dot8021xalg = 1;
3082 pstat->wpa_psk |= BIT(1);
3083
3084 pstat->wpa2_group_cipher = group_cipher&psecuritypriv->wpa2_group_cipher;
3085 pstat->wpa2_pairwise_cipher = pairwise_cipher&psecuritypriv->wpa2_pairwise_cipher;
3086
3087 if (!pstat->wpa2_group_cipher)
3088 status = WLAN_STATUS_INVALID_GROUP_CIPHER;
3089
3090 if (!pstat->wpa2_pairwise_cipher)
3091 status = WLAN_STATUS_INVALID_PAIRWISE_CIPHER;
3092 } else {
3093 status = WLAN_STATUS_INVALID_IE;
3094 }
3095 } else if ((psecuritypriv->wpa_psk & BIT(0)) && elems.wpa_ie) {
3096 int group_cipher = 0, pairwise_cipher = 0;
3097
3098 wpa_ie = elems.wpa_ie;
3099 wpa_ie_len = elems.wpa_ie_len;
3100
3101 if (rtw_parse_wpa_ie(wpa_ie-2, wpa_ie_len+2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
3102 pstat->dot8021xalg = 1;
3103 pstat->wpa_psk |= BIT(0);
3104
3105 pstat->wpa_group_cipher = group_cipher&psecuritypriv->wpa_group_cipher;
3106 pstat->wpa_pairwise_cipher = pairwise_cipher&psecuritypriv->wpa_pairwise_cipher;
3107
3108 if (!pstat->wpa_group_cipher)
3109 status = WLAN_STATUS_INVALID_GROUP_CIPHER;
3110
3111 if (!pstat->wpa_pairwise_cipher)
3112 status = WLAN_STATUS_INVALID_PAIRWISE_CIPHER;
3113 } else {
3114 status = WLAN_STATUS_INVALID_IE;
3115 }
3116 } else {
3117 wpa_ie = NULL;
3118 wpa_ie_len = 0;
3119 }
3120
3121 if (_STATS_SUCCESSFUL_ != status)
3122 goto OnAssocReqFail;
3123
3124 pstat->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS);
3125 if (!wpa_ie) {
3126 if (elems.wps_ie) {
3127 DBG_88E("STA included WPS IE in "
3128 "(Re)Association Request - assume WPS is "
3129 "used\n");
3130 pstat->flags |= WLAN_STA_WPS;
3131
3132
3133
3134 } else {
3135 DBG_88E("STA did not include WPA/RSN IE "
3136 "in (Re)Association Request - possible WPS "
3137 "use\n");
3138 pstat->flags |= WLAN_STA_MAYBE_WPS;
3139 }
3140
3141
3142
3143
3144 if ((psecuritypriv->wpa_psk > 0) && (pstat->flags & (WLAN_STA_WPS|WLAN_STA_MAYBE_WPS))) {
3145 if (pmlmepriv->wps_beacon_ie) {
3146 u8 selected_registrar = 0;
3147
3148 rtw_get_wps_attr_content(pmlmepriv->wps_beacon_ie, pmlmepriv->wps_beacon_ie_len, WPS_ATTR_SELECTED_REGISTRAR, &selected_registrar, NULL);
3149
3150 if (!selected_registrar) {
3151 DBG_88E("selected_registrar is false , or AP is not ready to do WPS\n");
3152
3153 status = _STATS_UNABLE_HANDLE_STA_;
3154
3155 goto OnAssocReqFail;
3156 }
3157 }
3158 }
3159 } else {
3160 int copy_len;
3161
3162 if (psecuritypriv->wpa_psk == 0) {
3163 DBG_88E("STA %pM: WPA/RSN IE in association "
3164 "request, but AP don't support WPA/RSN\n", pstat->hwaddr);
3165
3166 status = WLAN_STATUS_INVALID_IE;
3167
3168 goto OnAssocReqFail;
3169 }
3170
3171 if (elems.wps_ie) {
3172 DBG_88E("STA included WPS IE in "
3173 "(Re)Association Request - WPS is "
3174 "used\n");
3175 pstat->flags |= WLAN_STA_WPS;
3176 copy_len = 0;
3177 } else {
3178 copy_len = min_t(int, wpa_ie_len + 2, sizeof(pstat->wpa_ie));
3179 }
3180 if (copy_len > 0)
3181 memcpy(pstat->wpa_ie, wpa_ie-2, copy_len);
3182 }
3183
3184 pstat->flags &= ~WLAN_STA_WME;
3185 pstat->qos_option = 0;
3186 pstat->qos_info = 0;
3187 pstat->has_legacy_ac = true;
3188 pstat->uapsd_vo = 0;
3189 pstat->uapsd_vi = 0;
3190 pstat->uapsd_be = 0;
3191 pstat->uapsd_bk = 0;
3192 if (pmlmepriv->qospriv.qos_option) {
3193 p = pframe + WLAN_HDR_A3_LEN + ie_offset; ie_len = 0;
3194 for (;;) {
3195 p = rtw_get_ie(p, _VENDOR_SPECIFIC_IE_, &ie_len, pkt_len - WLAN_HDR_A3_LEN - ie_offset);
3196 if (p != NULL) {
3197 if (!memcmp(p+2, WMM_IE, 6)) {
3198 pstat->flags |= WLAN_STA_WME;
3199
3200 pstat->qos_option = 1;
3201 pstat->qos_info = *(p+8);
3202
3203 pstat->max_sp_len = (pstat->qos_info>>5)&0x3;
3204
3205 if ((pstat->qos_info&0xf) != 0xf)
3206 pstat->has_legacy_ac = true;
3207 else
3208 pstat->has_legacy_ac = false;
3209
3210 if (pstat->qos_info&0xf) {
3211 if (pstat->qos_info&BIT(0))
3212 pstat->uapsd_vo = BIT(0)|BIT(1);
3213 else
3214 pstat->uapsd_vo = 0;
3215
3216 if (pstat->qos_info&BIT(1))
3217 pstat->uapsd_vi = BIT(0)|BIT(1);
3218 else
3219 pstat->uapsd_vi = 0;
3220
3221 if (pstat->qos_info&BIT(2))
3222 pstat->uapsd_bk = BIT(0)|BIT(1);
3223 else
3224 pstat->uapsd_bk = 0;
3225
3226 if (pstat->qos_info&BIT(3))
3227 pstat->uapsd_be = BIT(0)|BIT(1);
3228 else
3229 pstat->uapsd_be = 0;
3230 }
3231 break;
3232 }
3233 } else {
3234 break;
3235 }
3236 p = p + ie_len + 2;
3237 }
3238 }
3239
3240
3241 memset(&pstat->htpriv.ht_cap, 0, sizeof(struct ieee80211_ht_cap));
3242 if (elems.ht_capabilities &&
3243 elems.ht_capabilities_len >= sizeof(struct ieee80211_ht_cap)) {
3244 pstat->flags |= WLAN_STA_HT;
3245
3246 pstat->flags |= WLAN_STA_WME;
3247
3248 memcpy(&pstat->htpriv.ht_cap,
3249 elems.ht_capabilities, sizeof(struct ieee80211_ht_cap));
3250 } else {
3251 pstat->flags &= ~WLAN_STA_HT;
3252 }
3253 if ((!pmlmepriv->htpriv.ht_option) && (pstat->flags&WLAN_STA_HT)) {
3254 status = _STATS_FAILURE_;
3255 goto OnAssocReqFail;
3256 }
3257
3258 if ((pstat->flags & WLAN_STA_HT) &&
3259 ((pstat->wpa2_pairwise_cipher&WPA_CIPHER_TKIP) ||
3260 (pstat->wpa_pairwise_cipher&WPA_CIPHER_TKIP))) {
3261 DBG_88E("HT: %pM tried to "
3262 "use TKIP with HT association\n", pstat->hwaddr);
3263
3264
3265
3266 }
3267
3268 pstat->flags |= WLAN_STA_NONERP;
3269 for (i = 0; i < pstat->bssratelen; i++) {
3270 if ((pstat->bssrateset[i] & 0x7f) > 22) {
3271 pstat->flags &= ~WLAN_STA_NONERP;
3272 break;
3273 }
3274 }
3275
3276 if (pstat->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3277 pstat->flags |= WLAN_STA_SHORT_PREAMBLE;
3278 else
3279 pstat->flags &= ~WLAN_STA_SHORT_PREAMBLE;
3280
3281
3282
3283 if (status != _STATS_SUCCESSFUL_)
3284 goto OnAssocReqFail;
3285
3286
3287
3288
3289
3290
3291
3292
3293 if (pstat->aid > 0) {
3294 DBG_88E(" old AID %d\n", pstat->aid);
3295 } else {
3296 for (pstat->aid = 1; pstat->aid <= NUM_STA; pstat->aid++)
3297 if (pstapriv->sta_aid[pstat->aid - 1] == NULL)
3298 break;
3299
3300
3301 if (pstat->aid > pstapriv->max_num_sta) {
3302 pstat->aid = 0;
3303
3304 DBG_88E(" no room for more AIDs\n");
3305
3306 status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
3307
3308 goto OnAssocReqFail;
3309 } else {
3310 pstapriv->sta_aid[pstat->aid - 1] = pstat;
3311 DBG_88E("allocate new AID=(%d)\n", pstat->aid);
3312 }
3313 }
3314
3315 pstat->state &= (~WIFI_FW_ASSOC_STATE);
3316 pstat->state |= WIFI_FW_ASSOC_SUCCESS;
3317
3318 spin_lock_bh(&pstapriv->auth_list_lock);
3319 if (!list_empty(&pstat->auth_list)) {
3320 list_del_init(&pstat->auth_list);
3321 pstapriv->auth_list_cnt--;
3322 }
3323 spin_unlock_bh(&pstapriv->auth_list_lock);
3324
3325 spin_lock_bh(&pstapriv->asoc_list_lock);
3326 if (list_empty(&pstat->asoc_list)) {
3327 pstat->expire_to = pstapriv->expire_to;
3328 list_add_tail(&pstat->asoc_list, &pstapriv->asoc_list);
3329 pstapriv->asoc_list_cnt++;
3330 }
3331 spin_unlock_bh(&pstapriv->asoc_list_lock);
3332
3333
3334 if ((pstat->state & WIFI_FW_ASSOC_SUCCESS) && (_STATS_SUCCESSFUL_ == status)) {
3335
3336 bss_cap_update_on_sta_join(padapter, pstat);
3337 sta_info_update(padapter, pstat);
3338
3339
3340 if (frame_type == WIFI_ASSOCREQ)
3341 issue_asocrsp(padapter, status, pstat, WIFI_ASSOCRSP);
3342 else
3343 issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);
3344
3345
3346 DBG_88E("indicate_sta_join_event to upper layer - hostapd\n");
3347 rtw_indicate_sta_assoc_event(padapter, pstat);
3348
3349
3350 report_add_sta_event(padapter, pstat->hwaddr, pstat->aid);
3351 }
3352
3353 return _SUCCESS;
3354
3355asoc_class2_error:
3356
3357 issue_deauth(padapter, (void *)GetAddr2Ptr(pframe), status);
3358
3359 return _FAIL;
3360
3361OnAssocReqFail:
3362
3363 pstat->aid = 0;
3364 if (frame_type == WIFI_ASSOCREQ)
3365 issue_asocrsp(padapter, status, pstat, WIFI_ASSOCRSP);
3366 else
3367 issue_asocrsp(padapter, status, pstat, WIFI_REASSOCRSP);
3368
3369#endif
3370
3371 return _FAIL;
3372}
3373
3374static unsigned int OnAssocRsp(struct adapter *padapter,
3375 struct recv_frame *precv_frame)
3376{
3377 uint i;
3378 int res;
3379 unsigned short status;
3380 struct ndis_802_11_var_ie *pIE;
3381 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3382 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3383 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3384
3385 u8 *pframe = precv_frame->pkt->data;
3386 uint pkt_len = precv_frame->pkt->len;
3387
3388 DBG_88E("%s\n", __func__);
3389
3390
3391 if (memcmp(myid(&(padapter->eeprompriv)), get_da(pframe), ETH_ALEN))
3392 return _SUCCESS;
3393
3394 if (!(pmlmeinfo->state & (WIFI_FW_AUTH_SUCCESS | WIFI_FW_ASSOC_STATE)))
3395 return _SUCCESS;
3396
3397 if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)
3398 return _SUCCESS;
3399
3400 del_timer_sync(&pmlmeext->link_timer);
3401
3402
3403 status = le16_to_cpu(*(__le16 *)(pframe + WLAN_HDR_A3_LEN + 2));
3404 if (status > 0) {
3405 DBG_88E("assoc reject, status code: %d\n", status);
3406 pmlmeinfo->state = WIFI_FW_NULL_STATE;
3407 res = -4;
3408 goto report_assoc_result;
3409 }
3410
3411
3412 pmlmeinfo->capability = le16_to_cpu(*(__le16 *)(pframe + WLAN_HDR_A3_LEN));
3413
3414
3415 pmlmeinfo->slotTime = (pmlmeinfo->capability & BIT(10)) ? 9 : 20;
3416
3417
3418 pmlmeinfo->aid = (int)(le16_to_cpu(*(__le16 *)(pframe + WLAN_HDR_A3_LEN + 4))&0x3fff);
3419 res = pmlmeinfo->aid;
3420
3421
3422
3423
3424 for (i = 6 + WLAN_HDR_A3_LEN; i < pkt_len;) {
3425 pIE = (struct ndis_802_11_var_ie *)(pframe + i);
3426
3427 switch (pIE->ElementID) {
3428 case _VENDOR_SPECIFIC_IE_:
3429 if (!memcmp(pIE->data, WMM_PARA_OUI, 6))
3430 WMM_param_handler(padapter, pIE);
3431 break;
3432 case _HT_CAPABILITY_IE_:
3433 HT_caps_handler(padapter, pIE);
3434 break;
3435 case _HT_EXTRA_INFO_IE_:
3436 HT_info_handler(padapter, pIE);
3437 break;
3438 case _ERPINFO_IE_:
3439 ERP_IE_handler(padapter, pIE);
3440 default:
3441 break;
3442 }
3443
3444 i += (pIE->Length + 2);
3445 }
3446
3447 pmlmeinfo->state &= (~WIFI_FW_ASSOC_STATE);
3448 pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
3449
3450 UpdateBrateTbl(padapter, pmlmeinfo->network.SupportedRates);
3451
3452report_assoc_result:
3453 if (res > 0)
3454 rtw_buf_update(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len, pframe, pkt_len);
3455 else
3456 rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len);
3457
3458 report_join_res(padapter, res);
3459
3460 return _SUCCESS;
3461}
3462
3463static unsigned int OnDeAuth(struct adapter *padapter,
3464 struct recv_frame *precv_frame)
3465{
3466 unsigned short reason;
3467 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3468 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3469 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3470 u8 *pframe = precv_frame->pkt->data;
3471 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
3472
3473
3474 if (memcmp(GetAddr3Ptr(pframe), pnetwork->MacAddress, ETH_ALEN))
3475 return _SUCCESS;
3476
3477 reason = le16_to_cpu(*(__le16 *)(pframe + WLAN_HDR_A3_LEN));
3478
3479 DBG_88E("%s Reason code(%d)\n", __func__, reason);
3480
3481#ifdef CONFIG_88EU_AP_MODE
3482 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
3483 struct sta_info *psta;
3484 struct sta_priv *pstapriv = &padapter->stapriv;
3485
3486 DBG_88E_LEVEL(_drv_always_, "ap recv deauth reason code(%d) sta:%pM\n",
3487 reason, GetAddr2Ptr(pframe));
3488
3489 psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
3490 if (psta) {
3491 u8 updated = 0;
3492
3493 spin_lock_bh(&pstapriv->asoc_list_lock);
3494 if (!list_empty(&psta->asoc_list)) {
3495 list_del_init(&psta->asoc_list);
3496 pstapriv->asoc_list_cnt--;
3497 updated = ap_free_sta(padapter, psta, false, reason);
3498 }
3499 spin_unlock_bh(&pstapriv->asoc_list_lock);
3500
3501 associated_clients_update(padapter, updated);
3502 }
3503
3504
3505 return _SUCCESS;
3506 } else
3507#endif
3508 {
3509 DBG_88E_LEVEL(_drv_always_, "sta recv deauth reason code(%d) sta:%pM\n",
3510 reason, GetAddr3Ptr(pframe));
3511
3512 receive_disconnect(padapter, GetAddr3Ptr(pframe), reason);
3513 }
3514 pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
3515 return _SUCCESS;
3516}
3517
3518static unsigned int OnDisassoc(struct adapter *padapter,
3519 struct recv_frame *precv_frame)
3520{
3521 u16 reason;
3522 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3523 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3524 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3525 u8 *pframe = precv_frame->pkt->data;
3526 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
3527
3528
3529 if (memcmp(GetAddr3Ptr(pframe), pnetwork->MacAddress, ETH_ALEN))
3530 return _SUCCESS;
3531
3532 reason = le16_to_cpu(*(__le16 *)(pframe + WLAN_HDR_A3_LEN));
3533
3534 DBG_88E("%s Reason code(%d)\n", __func__, reason);
3535
3536#ifdef CONFIG_88EU_AP_MODE
3537 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
3538 struct sta_info *psta;
3539 struct sta_priv *pstapriv = &padapter->stapriv;
3540
3541 DBG_88E_LEVEL(_drv_always_, "ap recv disassoc reason code(%d) sta:%pM\n",
3542 reason, GetAddr2Ptr(pframe));
3543
3544 psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
3545 if (psta) {
3546 u8 updated = 0;
3547
3548 spin_lock_bh(&pstapriv->asoc_list_lock);
3549 if (!list_empty(&psta->asoc_list)) {
3550 list_del_init(&psta->asoc_list);
3551 pstapriv->asoc_list_cnt--;
3552 updated = ap_free_sta(padapter, psta, false, reason);
3553 }
3554 spin_unlock_bh(&pstapriv->asoc_list_lock);
3555
3556 associated_clients_update(padapter, updated);
3557 }
3558
3559 return _SUCCESS;
3560 } else
3561#endif
3562 {
3563 DBG_88E_LEVEL(_drv_always_, "ap recv disassoc reason code(%d) sta:%pM\n",
3564 reason, GetAddr3Ptr(pframe));
3565
3566 receive_disconnect(padapter, GetAddr3Ptr(pframe), reason);
3567 }
3568 pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
3569 return _SUCCESS;
3570}
3571
3572static unsigned int OnAtim(struct adapter *padapter,
3573 struct recv_frame *precv_frame)
3574{
3575 DBG_88E("%s\n", __func__);
3576 return _SUCCESS;
3577}
3578
3579static unsigned int on_action_spct(struct adapter *padapter,
3580 struct recv_frame *precv_frame)
3581{
3582 struct sta_info *psta = NULL;
3583 struct sta_priv *pstapriv = &padapter->stapriv;
3584 u8 *pframe = precv_frame->pkt->data;
3585 u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3586 u8 category;
3587 u8 action;
3588
3589 DBG_88E(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(padapter->pnetdev));
3590
3591 psta = rtw_get_stainfo(pstapriv, GetAddr2Ptr(pframe));
3592
3593 if (!psta)
3594 goto exit;
3595
3596 category = frame_body[0];
3597 if (category != RTW_WLAN_CATEGORY_SPECTRUM_MGMT)
3598 goto exit;
3599
3600 action = frame_body[1];
3601 switch (action) {
3602 case RTW_WLAN_ACTION_SPCT_MSR_REQ:
3603 case RTW_WLAN_ACTION_SPCT_MSR_RPRT:
3604 case RTW_WLAN_ACTION_SPCT_TPC_REQ:
3605 case RTW_WLAN_ACTION_SPCT_TPC_RPRT:
3606 break;
3607 case RTW_WLAN_ACTION_SPCT_CHL_SWITCH:
3608 break;
3609 default:
3610 break;
3611 }
3612
3613exit:
3614 return _FAIL;
3615}
3616
3617static unsigned int OnAction_qos(struct adapter *padapter,
3618 struct recv_frame *precv_frame)
3619{
3620 return _SUCCESS;
3621}
3622
3623static unsigned int OnAction_dls(struct adapter *padapter,
3624 struct recv_frame *precv_frame)
3625{
3626 return _SUCCESS;
3627}
3628
3629static unsigned int OnAction_back(struct adapter *padapter,
3630 struct recv_frame *precv_frame)
3631{
3632 u8 *addr;
3633 struct sta_info *psta = NULL;
3634 struct recv_reorder_ctrl *preorder_ctrl;
3635 unsigned char *frame_body;
3636 unsigned char category, action;
3637 unsigned short tid, status, reason_code = 0;
3638 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3639 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3640 u8 *pframe = precv_frame->pkt->data;
3641 struct sta_priv *pstapriv = &padapter->stapriv;
3642
3643 if (memcmp(myid(&(padapter->eeprompriv)), GetAddr1Ptr(pframe),
3644 ETH_ALEN))
3645 return _SUCCESS;
3646
3647 DBG_88E("%s\n", __func__);
3648
3649 if ((pmlmeinfo->state&0x03) != WIFI_FW_AP_STATE)
3650 if (!(pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS))
3651 return _SUCCESS;
3652
3653 addr = GetAddr2Ptr(pframe);
3654 psta = rtw_get_stainfo(pstapriv, addr);
3655
3656 if (!psta)
3657 return _SUCCESS;
3658
3659 frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));
3660
3661 category = frame_body[0];
3662 if (category == RTW_WLAN_CATEGORY_BACK) {
3663 if (!pmlmeinfo->HT_enable)
3664 return _SUCCESS;
3665 action = frame_body[1];
3666 DBG_88E("%s, action=%d\n", __func__, action);
3667 switch (action) {
3668 case RTW_WLAN_ACTION_ADDBA_REQ:
3669 memcpy(&(pmlmeinfo->ADDBA_req), &(frame_body[2]), sizeof(struct ADDBA_request));
3670 process_addba_req(padapter, (u8 *)&(pmlmeinfo->ADDBA_req), addr);
3671
3672
3673 issue_action_BA(padapter, addr,
3674 RTW_WLAN_ACTION_ADDBA_RESP,
3675 pmlmeinfo->accept_addba_req ? 0 : 37);
3676 break;
3677 case RTW_WLAN_ACTION_ADDBA_RESP:
3678 status = get_unaligned_le16(&frame_body[3]);
3679 tid = (frame_body[5] >> 2) & 0x7;
3680 if (status == 0) {
3681 DBG_88E("agg_enable for TID=%d\n", tid);
3682 psta->htpriv.agg_enable_bitmap |= 1 << tid;
3683 psta->htpriv.candidate_tid_bitmap &= ~BIT(tid);
3684 } else {
3685 psta->htpriv.agg_enable_bitmap &= ~BIT(tid);
3686 }
3687 break;
3688 case RTW_WLAN_ACTION_DELBA:
3689 if ((frame_body[3] & BIT(3)) == 0) {
3690 psta->htpriv.agg_enable_bitmap &= ~(1 << ((frame_body[3] >> 4) & 0xf));
3691 psta->htpriv.candidate_tid_bitmap &= ~(1 << ((frame_body[3] >> 4) & 0xf));
3692 reason_code = get_unaligned_le16(&frame_body[4]);
3693 } else if ((frame_body[3] & BIT(3)) == BIT(3)) {
3694 tid = (frame_body[3] >> 4) & 0x0F;
3695 preorder_ctrl = &psta->recvreorder_ctrl[tid];
3696 preorder_ctrl->enable = false;
3697 preorder_ctrl->indicate_seq = 0xffff;
3698 }
3699 DBG_88E("%s(): DELBA: %x(%x)\n", __func__, pmlmeinfo->agg_enable_bitmap, reason_code);
3700
3701 break;
3702 default:
3703 break;
3704 }
3705 }
3706 return _SUCCESS;
3707}
3708
3709static s32 rtw_action_public_decache(struct recv_frame *recv_frame, s32 token)
3710{
3711 struct adapter *adapter = recv_frame->adapter;
3712 struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
3713 u8 *frame = recv_frame->pkt->data;
3714 u16 seq_ctrl = ((recv_frame->attrib.seq_num&0xffff) << 4) |
3715 (recv_frame->attrib.frag_num & 0xf);
3716
3717 if (GetRetry(frame)) {
3718 if (token >= 0) {
3719 if ((seq_ctrl == mlmeext->action_public_rxseq) && (token == mlmeext->action_public_dialog_token)) {
3720 DBG_88E(FUNC_ADPT_FMT" seq_ctrl = 0x%x, rxseq = 0x%x, token:%d\n",
3721 FUNC_ADPT_ARG(adapter), seq_ctrl, mlmeext->action_public_rxseq, token);
3722 return _FAIL;
3723 }
3724 } else {
3725 if (seq_ctrl == mlmeext->action_public_rxseq) {
3726 DBG_88E(FUNC_ADPT_FMT" seq_ctrl = 0x%x, rxseq = 0x%x\n",
3727 FUNC_ADPT_ARG(adapter), seq_ctrl, mlmeext->action_public_rxseq);
3728 return _FAIL;
3729 }
3730 }
3731 }
3732
3733 mlmeext->action_public_rxseq = seq_ctrl;
3734
3735 if (token >= 0)
3736 mlmeext->action_public_dialog_token = token;
3737
3738 return _SUCCESS;
3739}
3740
3741static unsigned int on_action_public_p2p(struct recv_frame *precv_frame)
3742{
3743 u8 *pframe = precv_frame->pkt->data;
3744 u8 *frame_body;
3745 u8 dialogToken = 0;
3746
3747 frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));
3748 dialogToken = frame_body[7];
3749
3750 if (rtw_action_public_decache(precv_frame, dialogToken) == _FAIL)
3751 return _FAIL;
3752
3753 return _SUCCESS;
3754}
3755
3756static unsigned int on_action_public_vendor(struct recv_frame *precv_frame)
3757{
3758 unsigned int ret = _FAIL;
3759 u8 *pframe = precv_frame->pkt->data;
3760 u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3761
3762 if (!memcmp(frame_body + 2, P2P_OUI, 4))
3763 ret = on_action_public_p2p(precv_frame);
3764
3765 return ret;
3766}
3767
3768static unsigned int on_action_public_default(struct recv_frame *precv_frame,
3769 u8 action)
3770{
3771 unsigned int ret = _FAIL;
3772 u8 *pframe = precv_frame->pkt->data;
3773 u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3774 u8 token;
3775
3776 token = frame_body[2];
3777
3778 if (rtw_action_public_decache(precv_frame, token) == _FAIL)
3779 goto exit;
3780
3781 ret = _SUCCESS;
3782
3783exit:
3784 return ret;
3785}
3786
3787static unsigned int on_action_public(struct adapter *padapter,
3788 struct recv_frame *precv_frame)
3789{
3790 unsigned int ret = _FAIL;
3791 u8 *pframe = precv_frame->pkt->data;
3792 u8 *frame_body = pframe + sizeof(struct ieee80211_hdr_3addr);
3793 u8 category, action;
3794
3795
3796 if (memcmp(myid(&(padapter->eeprompriv)), GetAddr1Ptr(pframe), ETH_ALEN))
3797 goto exit;
3798
3799 category = frame_body[0];
3800 if (category != RTW_WLAN_CATEGORY_PUBLIC)
3801 goto exit;
3802
3803 action = frame_body[1];
3804 switch (action) {
3805 case ACT_PUBLIC_VENDOR:
3806 ret = on_action_public_vendor(precv_frame);
3807 break;
3808 default:
3809 ret = on_action_public_default(precv_frame, action);
3810 break;
3811 }
3812
3813exit:
3814 return ret;
3815}
3816
3817static unsigned int OnAction_ht(struct adapter *padapter,
3818 struct recv_frame *precv_frame)
3819{
3820 return _SUCCESS;
3821}
3822
3823static unsigned int OnAction_wmm(struct adapter *padapter,
3824 struct recv_frame *precv_frame)
3825{
3826 return _SUCCESS;
3827}
3828
3829static unsigned int OnAction_p2p(struct adapter *padapter,
3830 struct recv_frame *precv_frame)
3831{
3832 return _SUCCESS;
3833}
3834
3835static unsigned int DoReserved(struct adapter *padapter,
3836 struct recv_frame *precv_frame)
3837{
3838 return _SUCCESS;
3839}
3840
3841static struct action_handler OnAction_tbl[] = {
3842 {RTW_WLAN_CATEGORY_SPECTRUM_MGMT, "ACTION_SPECTRUM_MGMT", on_action_spct},
3843 {RTW_WLAN_CATEGORY_QOS, "ACTION_QOS", &OnAction_qos},
3844 {RTW_WLAN_CATEGORY_DLS, "ACTION_DLS", &OnAction_dls},
3845 {RTW_WLAN_CATEGORY_BACK, "ACTION_BACK", &OnAction_back},
3846 {RTW_WLAN_CATEGORY_PUBLIC, "ACTION_PUBLIC", on_action_public},
3847 {RTW_WLAN_CATEGORY_RADIO_MEASUREMENT, "ACTION_RADIO_MEASUREMENT", &DoReserved},
3848 {RTW_WLAN_CATEGORY_FT, "ACTION_FT", &DoReserved},
3849 {RTW_WLAN_CATEGORY_HT, "ACTION_HT", &OnAction_ht},
3850 {RTW_WLAN_CATEGORY_SA_QUERY, "ACTION_SA_QUERY", &DoReserved},
3851 {RTW_WLAN_CATEGORY_WMM, "ACTION_WMM", &OnAction_wmm},
3852 {RTW_WLAN_CATEGORY_P2P, "ACTION_P2P", &OnAction_p2p},
3853};
3854
3855static unsigned int OnAction(struct adapter *padapter,
3856 struct recv_frame *precv_frame)
3857{
3858 int i;
3859 unsigned char category;
3860 struct action_handler *ptable;
3861 unsigned char *frame_body;
3862 u8 *pframe = precv_frame->pkt->data;
3863
3864 frame_body = (unsigned char *)(pframe + sizeof(struct ieee80211_hdr_3addr));
3865
3866 category = frame_body[0];
3867
3868 for (i = 0; i < ARRAY_SIZE(OnAction_tbl); i++) {
3869 ptable = &OnAction_tbl[i];
3870 if (category == ptable->num)
3871 ptable->func(padapter, precv_frame);
3872 }
3873 return _SUCCESS;
3874}
3875
3876
3877
3878
3879
3880
3881
3882static struct mlme_handler mlme_sta_tbl[] = {
3883 {WIFI_ASSOCREQ, "OnAssocReq", &OnAssocReq},
3884 {WIFI_ASSOCRSP, "OnAssocRsp", &OnAssocRsp},
3885 {WIFI_REASSOCREQ, "OnReAssocReq", &OnAssocReq},
3886 {WIFI_REASSOCRSP, "OnReAssocRsp", &OnAssocRsp},
3887 {WIFI_PROBEREQ, "OnProbeReq", &OnProbeReq},
3888 {WIFI_PROBERSP, "OnProbeRsp", &OnProbeRsp},
3889
3890
3891
3892
3893 {0, "DoReserved", &DoReserved},
3894 {0, "DoReserved", &DoReserved},
3895 {WIFI_BEACON, "OnBeacon", &OnBeacon},
3896 {WIFI_ATIM, "OnATIM", &OnAtim},
3897 {WIFI_DISASSOC, "OnDisassoc", &OnDisassoc},
3898 {WIFI_AUTH, "OnAuth", &OnAuthClient},
3899 {WIFI_DEAUTH, "OnDeAuth", &OnDeAuth},
3900 {WIFI_ACTION, "OnAction", &OnAction},
3901};
3902
3903int init_hw_mlme_ext(struct adapter *padapter)
3904{
3905 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3906
3907 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
3908 return _SUCCESS;
3909}
3910
3911static void init_mlme_ext_priv_value(struct adapter *padapter)
3912{
3913 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3914 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3915 unsigned char mixed_datarate[NumRates] = {
3916 _1M_RATE_, _2M_RATE_, _5M_RATE_, _11M_RATE_, _6M_RATE_,
3917 _9M_RATE_, _12M_RATE_, _18M_RATE_, _24M_RATE_, _36M_RATE_,
3918 _48M_RATE_, _54M_RATE_, 0xff
3919 };
3920 unsigned char mixed_basicrate[NumRates] = {
3921 _1M_RATE_, _2M_RATE_, _5M_RATE_, _11M_RATE_, _6M_RATE_,
3922 _12M_RATE_, _24M_RATE_, 0xff,
3923 };
3924
3925 atomic_set(&pmlmeext->event_seq, 0);
3926 pmlmeext->mgnt_seq = 0;
3927
3928 pmlmeext->cur_channel = padapter->registrypriv.channel;
3929 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_20;
3930 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
3931 pmlmeext->oper_channel = pmlmeext->cur_channel;
3932 pmlmeext->oper_bwmode = pmlmeext->cur_bwmode;
3933 pmlmeext->oper_ch_offset = pmlmeext->cur_ch_offset;
3934 pmlmeext->retry = 0;
3935
3936 pmlmeext->cur_wireless_mode = padapter->registrypriv.wireless_mode;
3937
3938 memcpy(pmlmeext->datarate, mixed_datarate, NumRates);
3939 memcpy(pmlmeext->basicrate, mixed_basicrate, NumRates);
3940
3941 pmlmeext->tx_rate = IEEE80211_CCK_RATE_1MB;
3942
3943 pmlmeext->sitesurvey_res.state = SCAN_DISABLE;
3944 pmlmeext->sitesurvey_res.channel_idx = 0;
3945 pmlmeext->sitesurvey_res.bss_cnt = 0;
3946 pmlmeext->scan_abort = false;
3947
3948 pmlmeinfo->state = WIFI_FW_NULL_STATE;
3949 pmlmeinfo->reauth_count = 0;
3950 pmlmeinfo->reassoc_count = 0;
3951 pmlmeinfo->link_count = 0;
3952 pmlmeinfo->auth_seq = 0;
3953 pmlmeinfo->auth_algo = dot11AuthAlgrthm_Open;
3954 pmlmeinfo->key_index = 0;
3955 pmlmeinfo->iv = 0;
3956
3957 pmlmeinfo->enc_algo = _NO_PRIVACY_;
3958 pmlmeinfo->authModeToggle = 0;
3959
3960 memset(pmlmeinfo->chg_txt, 0, 128);
3961
3962 pmlmeinfo->slotTime = SHORT_SLOT_TIME;
3963 pmlmeinfo->preamble_mode = PREAMBLE_AUTO;
3964
3965 pmlmeinfo->dialogToken = 0;
3966
3967 pmlmeext->action_public_rxseq = 0xffff;
3968 pmlmeext->action_public_dialog_token = 0xff;
3969}
3970
3971static int has_channel(struct rt_channel_info *channel_set,
3972 u8 chanset_size,
3973 u8 chan)
3974{
3975 int i;
3976
3977 for (i = 0; i < chanset_size; i++) {
3978 if (channel_set[i].ChannelNum == chan)
3979 return 1;
3980 }
3981 return 0;
3982}
3983
3984static void init_channel_list(struct adapter *padapter,
3985 struct rt_channel_info *channel_set,
3986 u8 chanset_size,
3987 struct p2p_channels *channel_list)
3988{
3989 struct p2p_oper_class_map op_class[] = {
3990 { IEEE80211G, 81, 1, 13, 1, BW20 },
3991 { IEEE80211G, 82, 14, 14, 1, BW20 },
3992 { -1, 0, 0, 0, 0, BW20 }
3993 };
3994
3995 int cla, op;
3996
3997 cla = 0;
3998
3999 for (op = 0; op_class[op].op_class; op++) {
4000 u8 ch;
4001 struct p2p_oper_class_map *o = &op_class[op];
4002 struct p2p_reg_class *reg = NULL;
4003
4004 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
4005 if (!has_channel(channel_set, chanset_size, ch))
4006 continue;
4007
4008 if ((0 == padapter->registrypriv.ht_enable) && (8 == o->inc))
4009 continue;
4010
4011 if ((0 == (padapter->registrypriv.cbw40_enable & BIT(1))) &&
4012 ((o->bw == BW40MINUS) || (o->bw == BW40PLUS)))
4013 continue;
4014
4015 if (reg == NULL) {
4016 reg = &channel_list->reg_class[cla];
4017 cla++;
4018 reg->reg_class = o->op_class;
4019 reg->channels = 0;
4020 }
4021 reg->channel[reg->channels] = ch;
4022 reg->channels++;
4023 }
4024 }
4025 channel_list->reg_classes = cla;
4026}
4027
4028static u8 init_channel_set(struct adapter *padapter, u8 ChannelPlan,
4029 struct rt_channel_info *channel_set)
4030{
4031 u8 index, chanset_size = 0;
4032 u8 b2_4GBand = false;
4033 u8 Index2G = 0;
4034
4035 memset(channel_set, 0, sizeof(struct rt_channel_info) * MAX_CHANNEL_NUM);
4036
4037 if (ChannelPlan >= RT_CHANNEL_DOMAIN_MAX && ChannelPlan != RT_CHANNEL_DOMAIN_REALTEK_DEFINE) {
4038 DBG_88E("ChannelPlan ID %x error !!!!!\n", ChannelPlan);
4039 return chanset_size;
4040 }
4041
4042 if (padapter->registrypriv.wireless_mode & WIRELESS_11G) {
4043 b2_4GBand = true;
4044 if (ChannelPlan == RT_CHANNEL_DOMAIN_REALTEK_DEFINE)
4045 Index2G = RTW_CHANNEL_PLAN_MAP_REALTEK_DEFINE.Index2G;
4046 else
4047 Index2G = RTW_ChannelPlanMap[ChannelPlan].Index2G;
4048 }
4049
4050 if (b2_4GBand) {
4051 for (index = 0; index < RTW_ChannelPlan2G[Index2G].Len; index++) {
4052 channel_set[chanset_size].ChannelNum = RTW_ChannelPlan2G[Index2G].Channel[index];
4053
4054 if ((ChannelPlan == RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN) ||
4055 (ChannelPlan == RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN_2G)) {
4056 if (channel_set[chanset_size].ChannelNum >= 1 && channel_set[chanset_size].ChannelNum <= 11)
4057 channel_set[chanset_size].ScanType = SCAN_ACTIVE;
4058 else if ((channel_set[chanset_size].ChannelNum >= 12 && channel_set[chanset_size].ChannelNum <= 14))
4059 channel_set[chanset_size].ScanType = SCAN_PASSIVE;
4060 } else if (ChannelPlan == RT_CHANNEL_DOMAIN_WORLD_WIDE_13 ||
4061 Index2G == RT_CHANNEL_DOMAIN_2G_WORLD) {
4062 if (channel_set[chanset_size].ChannelNum <= 11)
4063 channel_set[chanset_size].ScanType = SCAN_ACTIVE;
4064 else
4065 channel_set[chanset_size].ScanType = SCAN_PASSIVE;
4066 } else {
4067 channel_set[chanset_size].ScanType = SCAN_ACTIVE;
4068 }
4069
4070 chanset_size++;
4071 }
4072 }
4073 return chanset_size;
4074}
4075
4076int init_mlme_ext_priv(struct adapter *padapter)
4077{
4078 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4079 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4080 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4081 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4082
4083 pmlmeext->padapter = padapter;
4084
4085 init_mlme_ext_priv_value(padapter);
4086 pmlmeinfo->accept_addba_req = pregistrypriv->accept_addba_req;
4087
4088 init_mlme_ext_timer(padapter);
4089
4090#ifdef CONFIG_88EU_AP_MODE
4091 init_mlme_ap_info(padapter);
4092#endif
4093
4094 pmlmeext->max_chan_nums = init_channel_set(padapter, pmlmepriv->ChannelPlan, pmlmeext->channel_set);
4095 init_channel_list(padapter, pmlmeext->channel_set, pmlmeext->max_chan_nums, &pmlmeext->channel_list);
4096
4097 pmlmeext->chan_scan_time = SURVEY_TO;
4098 pmlmeext->mlmeext_init = true;
4099
4100
4101 pmlmeext->active_keep_alive_check = true;
4102
4103 return _SUCCESS;
4104}
4105
4106void free_mlme_ext_priv(struct mlme_ext_priv *pmlmeext)
4107{
4108 struct adapter *padapter = pmlmeext->padapter;
4109
4110 if (!padapter)
4111 return;
4112
4113 if (padapter->bDriverStopped) {
4114 del_timer_sync(&pmlmeext->survey_timer);
4115 del_timer_sync(&pmlmeext->link_timer);
4116 }
4117}
4118
4119static void _mgt_dispatcher(struct adapter *padapter,
4120 struct mlme_handler *ptable,
4121 struct recv_frame *precv_frame)
4122{
4123 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
4124 u8 *pframe = precv_frame->pkt->data;
4125
4126 if (ptable->func) {
4127
4128 if (memcmp(GetAddr1Ptr(pframe), myid(&padapter->eeprompriv), ETH_ALEN) &&
4129 memcmp(GetAddr1Ptr(pframe), bc_addr, ETH_ALEN))
4130 return;
4131 ptable->func(padapter, precv_frame);
4132 }
4133}
4134
4135void mgt_dispatcher(struct adapter *padapter, struct recv_frame *precv_frame)
4136{
4137 int index;
4138 struct mlme_handler *ptable;
4139#ifdef CONFIG_88EU_AP_MODE
4140 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4141#endif
4142 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
4143 u8 *pframe = precv_frame->pkt->data;
4144 struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, GetAddr2Ptr(pframe));
4145
4146 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
4147 ("+%s: type(0x%x) subtype(0x%x)\n", __func__,
4148 (unsigned int)GetFrameType(pframe),
4149 (unsigned int)GetFrameSubType(pframe)));
4150
4151 if (GetFrameType(pframe) != WIFI_MGT_TYPE) {
4152 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
4153 ("%s: type(0x%x) error!\n", __func__,
4154 (unsigned int)GetFrameType(pframe)));
4155 return;
4156 }
4157
4158
4159 if (memcmp(GetAddr1Ptr(pframe), myid(&padapter->eeprompriv), ETH_ALEN) &&
4160 memcmp(GetAddr1Ptr(pframe), bc_addr, ETH_ALEN))
4161 return;
4162
4163 ptable = mlme_sta_tbl;
4164
4165 index = GetFrameSubType(pframe) >> 4;
4166
4167 if (index > 13) {
4168 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_, ("Currently we do not support reserved sub-fr-type=%d\n", index));
4169 return;
4170 }
4171 ptable += index;
4172
4173 if (psta) {
4174 if (GetRetry(pframe)) {
4175 if (precv_frame->attrib.seq_num ==
4176 psta->RxMgmtFrameSeqNum) {
4177
4178 DBG_88E("Drop duplicate management frame with seq_num=%d.\n",
4179 precv_frame->attrib.seq_num);
4180 return;
4181 }
4182 }
4183 psta->RxMgmtFrameSeqNum = precv_frame->attrib.seq_num;
4184 }
4185
4186#ifdef CONFIG_88EU_AP_MODE
4187 switch (GetFrameSubType(pframe)) {
4188 case WIFI_AUTH:
4189 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
4190 ptable->func = &OnAuth;
4191 else
4192 ptable->func = &OnAuthClient;
4193
4194 case WIFI_ASSOCREQ:
4195 case WIFI_REASSOCREQ:
4196 case WIFI_PROBEREQ:
4197 case WIFI_BEACON:
4198 case WIFI_ACTION:
4199 _mgt_dispatcher(padapter, ptable, precv_frame);
4200 break;
4201 default:
4202 _mgt_dispatcher(padapter, ptable, precv_frame);
4203 break;
4204 }
4205#else
4206 _mgt_dispatcher(padapter, ptable, precv_frame);
4207#endif
4208}
4209
4210
4211
4212
4213
4214
4215
4216void report_survey_event(struct adapter *padapter,
4217 struct recv_frame *precv_frame)
4218{
4219 struct cmd_obj *pcmd_obj;
4220 u8 *pevtcmd;
4221 u32 cmdsz;
4222 struct survey_event *psurvey_evt;
4223 struct C2HEvent_Header *pc2h_evt_hdr;
4224 struct mlme_ext_priv *pmlmeext;
4225 struct cmd_priv *pcmdpriv;
4226
4227 if (!padapter)
4228 return;
4229
4230 pmlmeext = &padapter->mlmeextpriv;
4231 pcmdpriv = &padapter->cmdpriv;
4232
4233
4234 pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
4235 if (!pcmd_obj)
4236 return;
4237
4238 cmdsz = sizeof(struct survey_event) + sizeof(struct C2HEvent_Header);
4239 pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
4240 if (!pevtcmd) {
4241 kfree(pcmd_obj);
4242 return;
4243 }
4244
4245 INIT_LIST_HEAD(&pcmd_obj->list);
4246
4247 pcmd_obj->cmdcode = _Set_MLME_EVT_CMD_;
4248 pcmd_obj->cmdsz = cmdsz;
4249 pcmd_obj->parmbuf = pevtcmd;
4250
4251 pcmd_obj->rsp = NULL;
4252 pcmd_obj->rspsz = 0;
4253
4254 pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
4255 pc2h_evt_hdr->len = sizeof(struct survey_event);
4256 pc2h_evt_hdr->ID = _Survey_EVT_;
4257 pc2h_evt_hdr->seq = atomic_inc_return(&pmlmeext->event_seq);
4258
4259 psurvey_evt = (struct survey_event *)(pevtcmd + sizeof(struct C2HEvent_Header));
4260
4261 if (collect_bss_info(padapter, precv_frame, (struct wlan_bssid_ex *)&psurvey_evt->bss) == _FAIL) {
4262 kfree(pcmd_obj);
4263 kfree(pevtcmd);
4264 return;
4265 }
4266
4267 process_80211d(padapter, &psurvey_evt->bss);
4268
4269 rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
4270
4271 pmlmeext->sitesurvey_res.bss_cnt++;
4272}
4273
4274void report_surveydone_event(struct adapter *padapter)
4275{
4276 struct cmd_obj *pcmd_obj;
4277 u8 *pevtcmd;
4278 u32 cmdsz;
4279 struct surveydone_event *psurveydone_evt;
4280 struct C2HEvent_Header *pc2h_evt_hdr;
4281 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4282 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4283
4284 pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
4285 if (!pcmd_obj)
4286 return;
4287
4288 cmdsz = sizeof(struct surveydone_event) + sizeof(struct C2HEvent_Header);
4289 pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
4290 if (!pevtcmd) {
4291 kfree(pcmd_obj);
4292 return;
4293 }
4294
4295 INIT_LIST_HEAD(&pcmd_obj->list);
4296
4297 pcmd_obj->cmdcode = _Set_MLME_EVT_CMD_;
4298 pcmd_obj->cmdsz = cmdsz;
4299 pcmd_obj->parmbuf = pevtcmd;
4300
4301 pcmd_obj->rsp = NULL;
4302 pcmd_obj->rspsz = 0;
4303
4304 pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
4305 pc2h_evt_hdr->len = sizeof(struct surveydone_event);
4306 pc2h_evt_hdr->ID = _SurveyDone_EVT_;
4307 pc2h_evt_hdr->seq = atomic_inc_return(&pmlmeext->event_seq);
4308
4309 psurveydone_evt = (struct surveydone_event *)(pevtcmd + sizeof(struct C2HEvent_Header));
4310 psurveydone_evt->bss_cnt = pmlmeext->sitesurvey_res.bss_cnt;
4311
4312 DBG_88E("survey done event(%x)\n", psurveydone_evt->bss_cnt);
4313
4314 rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
4315}
4316
4317void report_join_res(struct adapter *padapter, int res)
4318{
4319 struct cmd_obj *pcmd_obj;
4320 u8 *pevtcmd;
4321 u32 cmdsz;
4322 struct joinbss_event *pjoinbss_evt;
4323 struct C2HEvent_Header *pc2h_evt_hdr;
4324 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4325 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4326 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4327
4328 pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
4329 if (!pcmd_obj)
4330 return;
4331
4332 cmdsz = sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header);
4333 pevtcmd = kzalloc(cmdsz, GFP_ATOMIC);
4334 if (!pevtcmd) {
4335 kfree(pcmd_obj);
4336 return;
4337 }
4338
4339 INIT_LIST_HEAD(&pcmd_obj->list);
4340
4341 pcmd_obj->cmdcode = _Set_MLME_EVT_CMD_;
4342 pcmd_obj->cmdsz = cmdsz;
4343 pcmd_obj->parmbuf = pevtcmd;
4344
4345 pcmd_obj->rsp = NULL;
4346 pcmd_obj->rspsz = 0;
4347
4348 pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
4349 pc2h_evt_hdr->len = sizeof(struct joinbss_event);
4350 pc2h_evt_hdr->ID = _JoinBss_EVT_;
4351 pc2h_evt_hdr->seq = atomic_inc_return(&pmlmeext->event_seq);
4352
4353 pjoinbss_evt = (struct joinbss_event *)(pevtcmd + sizeof(struct C2HEvent_Header));
4354 memcpy((unsigned char *)(&(pjoinbss_evt->network.network)), &(pmlmeinfo->network), sizeof(struct wlan_bssid_ex));
4355 pjoinbss_evt->network.join_res = res;
4356 pjoinbss_evt->network.aid = res;
4357
4358 DBG_88E("%s(%d)\n", __func__, res);
4359
4360
4361 rtw_joinbss_event_prehandle(padapter, (u8 *)&pjoinbss_evt->network);
4362
4363
4364 rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
4365}
4366
4367void report_del_sta_event(struct adapter *padapter, unsigned char *MacAddr,
4368 unsigned short reason)
4369{
4370 struct cmd_obj *pcmd_obj;
4371 u8 *pevtcmd;
4372 u32 cmdsz;
4373 struct sta_info *psta;
4374 int mac_id;
4375 struct stadel_event *pdel_sta_evt;
4376 struct C2HEvent_Header *pc2h_evt_hdr;
4377 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4378 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4379
4380 pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
4381 if (!pcmd_obj)
4382 return;
4383
4384 cmdsz = sizeof(struct stadel_event) + sizeof(struct C2HEvent_Header);
4385 pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
4386 if (!pevtcmd) {
4387 kfree(pcmd_obj);
4388 return;
4389 }
4390
4391 INIT_LIST_HEAD(&pcmd_obj->list);
4392
4393 pcmd_obj->cmdcode = _Set_MLME_EVT_CMD_;
4394 pcmd_obj->cmdsz = cmdsz;
4395 pcmd_obj->parmbuf = pevtcmd;
4396
4397 pcmd_obj->rsp = NULL;
4398 pcmd_obj->rspsz = 0;
4399
4400 pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
4401 pc2h_evt_hdr->len = sizeof(struct stadel_event);
4402 pc2h_evt_hdr->ID = _DelSTA_EVT_;
4403 pc2h_evt_hdr->seq = atomic_inc_return(&pmlmeext->event_seq);
4404
4405 pdel_sta_evt = (struct stadel_event *)(pevtcmd + sizeof(struct C2HEvent_Header));
4406 ether_addr_copy((unsigned char *)(&(pdel_sta_evt->macaddr)), MacAddr);
4407 memcpy((unsigned char *)(pdel_sta_evt->rsvd), (unsigned char *)(&reason), 2);
4408
4409
4410 psta = rtw_get_stainfo(&padapter->stapriv, MacAddr);
4411 if (psta)
4412 mac_id = (int)psta->mac_id;
4413 else
4414 mac_id = -1;
4415
4416 pdel_sta_evt->mac_id = mac_id;
4417
4418 DBG_88E("%s: delete STA, mac_id =%d\n", __func__, mac_id);
4419
4420 rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
4421}
4422
4423void report_add_sta_event(struct adapter *padapter, unsigned char *MacAddr,
4424 int cam_idx)
4425{
4426 struct cmd_obj *pcmd_obj;
4427 u8 *pevtcmd;
4428 u32 cmdsz;
4429 struct stassoc_event *padd_sta_evt;
4430 struct C2HEvent_Header *pc2h_evt_hdr;
4431 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4432 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4433
4434 pcmd_obj = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
4435 if (!pcmd_obj)
4436 return;
4437
4438 cmdsz = sizeof(struct stassoc_event) + sizeof(struct C2HEvent_Header);
4439 pevtcmd = kzalloc(cmdsz, GFP_KERNEL);
4440 if (!pevtcmd) {
4441 kfree(pcmd_obj);
4442 return;
4443 }
4444
4445 INIT_LIST_HEAD(&pcmd_obj->list);
4446
4447 pcmd_obj->cmdcode = _Set_MLME_EVT_CMD_;
4448 pcmd_obj->cmdsz = cmdsz;
4449 pcmd_obj->parmbuf = pevtcmd;
4450
4451 pcmd_obj->rsp = NULL;
4452 pcmd_obj->rspsz = 0;
4453
4454 pc2h_evt_hdr = (struct C2HEvent_Header *)(pevtcmd);
4455 pc2h_evt_hdr->len = sizeof(struct stassoc_event);
4456 pc2h_evt_hdr->ID = _AddSTA_EVT_;
4457 pc2h_evt_hdr->seq = atomic_inc_return(&pmlmeext->event_seq);
4458
4459 padd_sta_evt = (struct stassoc_event *)(pevtcmd + sizeof(struct C2HEvent_Header));
4460 ether_addr_copy((unsigned char *)(&(padd_sta_evt->macaddr)), MacAddr);
4461 padd_sta_evt->cam_id = cam_idx;
4462
4463 DBG_88E("%s: add STA\n", __func__);
4464
4465 rtw_enqueue_cmd(pcmdpriv, pcmd_obj);
4466}
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476void update_sta_info(struct adapter *padapter, struct sta_info *psta)
4477{
4478 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4479 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4480 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4481
4482
4483 VCS_update(padapter, psta);
4484
4485
4486 if (pmlmepriv->htpriv.ht_option) {
4487 psta->htpriv.ht_option = true;
4488
4489 psta->htpriv.ampdu_enable = pmlmepriv->htpriv.ampdu_enable;
4490
4491 if (support_short_GI(padapter, &pmlmeinfo->HT_caps))
4492 psta->htpriv.sgi = true;
4493
4494 psta->qos_option = true;
4495 } else {
4496 psta->htpriv.ht_option = false;
4497
4498 psta->htpriv.ampdu_enable = false;
4499
4500 psta->htpriv.sgi = false;
4501 psta->qos_option = false;
4502 }
4503 psta->htpriv.bwmode = pmlmeext->cur_bwmode;
4504 psta->htpriv.ch_offset = pmlmeext->cur_ch_offset;
4505
4506 psta->htpriv.agg_enable_bitmap = 0x0;
4507 psta->htpriv.candidate_tid_bitmap = 0x0;
4508
4509
4510 if (pmlmepriv->qospriv.qos_option)
4511 psta->qos_option = true;
4512
4513
4514 psta->state = _FW_LINKED;
4515}
4516
4517void mlmeext_joinbss_event_callback(struct adapter *padapter, int join_res)
4518{
4519 struct sta_info *psta, *psta_bmc;
4520 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4521 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4522 struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
4523 struct sta_priv *pstapriv = &padapter->stapriv;
4524 u8 join_type;
4525 u16 media_status;
4526
4527 if (join_res < 0) {
4528 join_type = 1;
4529 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
4530 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, null_addr);
4531
4532
4533 update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
4534
4535 goto exit_mlmeext_joinbss_event_callback;
4536 }
4537
4538 if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) {
4539
4540 psta_bmc = rtw_get_bcmc_stainfo(padapter);
4541 if (psta_bmc) {
4542 pmlmeinfo->FW_sta_info[psta_bmc->mac_id].psta = psta_bmc;
4543 update_bmc_sta_support_rate(padapter, psta_bmc->mac_id);
4544 Update_RA_Entry(padapter, psta_bmc->mac_id);
4545 }
4546 }
4547
4548
4549
4550 Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true);
4551
4552
4553 update_IOT_info(padapter);
4554
4555 rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, cur_network->SupportedRates);
4556
4557
4558 rtw_hal_set_hwreg(padapter, HW_VAR_BEACON_INTERVAL, (u8 *)(&pmlmeinfo->bcn_interval));
4559
4560
4561 update_capinfo(padapter, pmlmeinfo->capability);
4562
4563
4564 WMMOnAssocRsp(padapter);
4565
4566
4567 HTOnAssocRsp(padapter);
4568
4569 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
4570
4571 psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
4572 if (psta) {
4573 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
4574
4575 psta->wireless_mode = pmlmeext->cur_wireless_mode;
4576
4577
4578 set_sta_rate(padapter, psta);
4579 rtw_hal_set_hwreg(padapter, HW_VAR_TX_RPT_MAX_MACID, (u8 *)&psta->mac_id);
4580 media_status = (psta->mac_id<<8)|1;
4581 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status);
4582 }
4583
4584 join_type = 2;
4585 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
4586
4587 if ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE) {
4588
4589 correct_TSF(padapter, pmlmeext);
4590 }
4591 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_CONNECT, 0);
4592
4593exit_mlmeext_joinbss_event_callback:
4594
4595 DBG_88E("=>%s\n", __func__);
4596}
4597
4598void mlmeext_sta_add_event_callback(struct adapter *padapter, struct sta_info *psta)
4599{
4600 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
4601 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4602 u8 join_type;
4603
4604 DBG_88E("%s\n", __func__);
4605
4606 if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) {
4607 if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
4608
4609 } else {
4610
4611 correct_TSF(padapter, pmlmeext);
4612
4613
4614 if (send_beacon(padapter) == _FAIL) {
4615 pmlmeinfo->FW_sta_info[psta->mac_id].status = 0;
4616 pmlmeinfo->state ^= WIFI_FW_ADHOC_STATE;
4617 return;
4618 }
4619 pmlmeinfo->state |= WIFI_FW_ASSOC_SUCCESS;
4620 }
4621
4622 join_type = 2;
4623 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
4624 }
4625
4626 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
4627
4628
4629 Update_RA_Entry(padapter, psta->mac_id);
4630
4631
4632 update_sta_info(padapter, psta);
4633}
4634
4635void mlmeext_sta_del_event_callback(struct adapter *padapter)
4636{
4637 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4638 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4639
4640 if (is_client_associated_to_ap(padapter) || is_IBSS_empty(padapter)) {
4641 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_DISCONNECT, NULL);
4642 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, null_addr);
4643
4644
4645 update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
4646
4647
4648 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_20;
4649 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
4650
4651
4652 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
4653
4654
4655 flush_all_cam_entry(padapter);
4656
4657 pmlmeinfo->state = WIFI_FW_NULL_STATE;
4658
4659
4660 Set_MSR(padapter, _HW_STATE_STATION_);
4661
4662 del_timer_sync(&pmlmeext->link_timer);
4663 }
4664}
4665
4666
4667
4668
4669
4670
4671
4672static u8 chk_ap_is_alive(struct adapter *padapter, struct sta_info *psta)
4673{
4674 u8 ret = false;
4675
4676 if ((sta_rx_data_pkts(psta) == sta_last_rx_data_pkts(psta)) &&
4677 sta_rx_beacon_pkts(psta) == sta_last_rx_beacon_pkts(psta) &&
4678 sta_rx_probersp_pkts(psta) == sta_last_rx_probersp_pkts(psta))
4679 ret = false;
4680 else
4681 ret = true;
4682
4683 sta_update_last_rx_pkts(psta);
4684
4685 return ret;
4686}
4687
4688void linked_status_chk(struct adapter *padapter)
4689{
4690 u32 i;
4691 struct sta_info *psta;
4692 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
4693 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4694 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4695 struct sta_priv *pstapriv = &padapter->stapriv;
4696
4697 if (is_client_associated_to_ap(padapter)) {
4698
4699
4700 int tx_chk = _SUCCESS, rx_chk = _SUCCESS;
4701 int rx_chk_limit;
4702
4703 rx_chk_limit = 4;
4704 psta = rtw_get_stainfo(pstapriv, pmlmeinfo->network.MacAddress);
4705 if (psta) {
4706 bool is_p2p_enable = false;
4707
4708 if (!chk_ap_is_alive(padapter, psta))
4709 rx_chk = _FAIL;
4710
4711 if (pxmitpriv->last_tx_pkts == pxmitpriv->tx_pkts)
4712 tx_chk = _FAIL;
4713
4714 if (pmlmeext->active_keep_alive_check && (rx_chk == _FAIL || tx_chk == _FAIL)) {
4715 u8 backup_oper_channel = 0;
4716
4717
4718 if (rtw_get_oper_ch(padapter) != pmlmeext->cur_channel) {
4719 backup_oper_channel = rtw_get_oper_ch(padapter);
4720 SelectChannel(padapter, pmlmeext->cur_channel);
4721 }
4722
4723 if (rx_chk != _SUCCESS)
4724 issue_probereq_ex(padapter, &pmlmeinfo->network.Ssid, psta->hwaddr, 3, 1);
4725
4726 if ((tx_chk != _SUCCESS && pmlmeinfo->link_count++ == 0xf) || rx_chk != _SUCCESS) {
4727 tx_chk = issue_nulldata(padapter, psta->hwaddr, 0, 3, 1);
4728
4729 if (tx_chk == _SUCCESS && !is_p2p_enable)
4730 rx_chk = _SUCCESS;
4731 }
4732
4733
4734 if (backup_oper_channel > 0)
4735 SelectChannel(padapter, backup_oper_channel);
4736 } else {
4737 if (rx_chk != _SUCCESS) {
4738 if (pmlmeext->retry == 0) {
4739 issue_probereq(padapter,
4740 &pmlmeinfo->network.Ssid,
4741 pmlmeinfo->network.MacAddress,
4742 false);
4743 issue_probereq(padapter,
4744 &pmlmeinfo->network.Ssid,
4745 pmlmeinfo->network.MacAddress,
4746 false);
4747 issue_probereq(padapter,
4748 &pmlmeinfo->network.Ssid,
4749 pmlmeinfo->network.MacAddress,
4750 false);
4751 }
4752 }
4753
4754 if (tx_chk != _SUCCESS && pmlmeinfo->link_count++ == 0xf)
4755 tx_chk = issue_nulldata(padapter, NULL, 0, 1, 0);
4756 }
4757
4758 if (rx_chk == _FAIL) {
4759 pmlmeext->retry++;
4760 if (pmlmeext->retry > rx_chk_limit) {
4761 DBG_88E_LEVEL(_drv_always_, FUNC_ADPT_FMT" disconnect or roaming\n",
4762 FUNC_ADPT_ARG(padapter));
4763 receive_disconnect(padapter, pmlmeinfo->network.MacAddress,
4764 WLAN_REASON_EXPIRATION_CHK);
4765 return;
4766 }
4767 } else {
4768 pmlmeext->retry = 0;
4769 }
4770
4771 if (tx_chk == _FAIL) {
4772 pmlmeinfo->link_count &= 0xf;
4773 } else {
4774 pxmitpriv->last_tx_pkts = pxmitpriv->tx_pkts;
4775 pmlmeinfo->link_count = 0;
4776 }
4777 }
4778 } else if (is_client_associated_to_ibss(padapter)) {
4779
4780
4781 for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {
4782 if (pmlmeinfo->FW_sta_info[i].status == 1) {
4783 psta = pmlmeinfo->FW_sta_info[i].psta;
4784
4785 if (!psta)
4786 continue;
4787 if (pmlmeinfo->FW_sta_info[i].rx_pkt == sta_rx_pkts(psta)) {
4788 if (pmlmeinfo->FW_sta_info[i].retry < 3) {
4789 pmlmeinfo->FW_sta_info[i].retry++;
4790 } else {
4791 pmlmeinfo->FW_sta_info[i].retry = 0;
4792 pmlmeinfo->FW_sta_info[i].status = 0;
4793 report_del_sta_event(padapter, psta->hwaddr
4794 , 65535
4795 );
4796 }
4797 } else {
4798 pmlmeinfo->FW_sta_info[i].retry = 0;
4799 pmlmeinfo->FW_sta_info[i].rx_pkt = (u32)sta_rx_pkts(psta);
4800 }
4801 }
4802 }
4803 }
4804}
4805
4806void survey_timer_hdl(struct timer_list *t)
4807{
4808 struct adapter *padapter = from_timer(padapter, t,
4809 mlmeextpriv.survey_timer);
4810 struct cmd_obj *ph2c;
4811 struct sitesurvey_parm *psurveyPara;
4812 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4813 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4814
4815
4816 if (pmlmeext->sitesurvey_res.state > SCAN_START) {
4817 if (pmlmeext->sitesurvey_res.state == SCAN_PROCESS)
4818 pmlmeext->sitesurvey_res.channel_idx++;
4819
4820 if (pmlmeext->scan_abort) {
4821 pmlmeext->sitesurvey_res.channel_idx = pmlmeext->sitesurvey_res.ch_num;
4822 DBG_88E("%s idx:%d\n", __func__
4823 , pmlmeext->sitesurvey_res.channel_idx);
4824
4825 pmlmeext->scan_abort = false;
4826 }
4827
4828 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
4829 if (!ph2c)
4830 goto exit_survey_timer_hdl;
4831
4832 psurveyPara = kzalloc(sizeof(struct sitesurvey_parm), GFP_ATOMIC);
4833 if (!psurveyPara) {
4834 kfree(ph2c);
4835 goto exit_survey_timer_hdl;
4836 }
4837
4838 init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, _SiteSurvey_CMD_);
4839 rtw_enqueue_cmd(pcmdpriv, ph2c);
4840 }
4841
4842
4843exit_survey_timer_hdl:
4844 return;
4845}
4846
4847void link_timer_hdl(struct timer_list *t)
4848{
4849 struct adapter *padapter = from_timer(padapter, t,
4850 mlmeextpriv.link_timer);
4851 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4852 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4853
4854 if (pmlmeinfo->state & WIFI_FW_AUTH_NULL) {
4855 DBG_88E("%s:no beacon while connecting\n", __func__);
4856 pmlmeinfo->state = WIFI_FW_NULL_STATE;
4857 report_join_res(padapter, -3);
4858 } else if (pmlmeinfo->state & WIFI_FW_AUTH_STATE) {
4859
4860 if (++pmlmeinfo->reauth_count > REAUTH_LIMIT) {
4861 pmlmeinfo->state = 0;
4862 report_join_res(padapter, -1);
4863 return;
4864 }
4865
4866 DBG_88E("%s: auth timeout and try again\n", __func__);
4867 pmlmeinfo->auth_seq = 1;
4868 issue_auth(padapter, NULL, 0);
4869 set_link_timer(pmlmeext, REAUTH_TO);
4870 } else if (pmlmeinfo->state & WIFI_FW_ASSOC_STATE) {
4871
4872 if (++pmlmeinfo->reassoc_count > REASSOC_LIMIT) {
4873 pmlmeinfo->state = WIFI_FW_NULL_STATE;
4874 report_join_res(padapter, -2);
4875 return;
4876 }
4877
4878 DBG_88E("%s: assoc timeout and try again\n", __func__);
4879 issue_assocreq(padapter);
4880 set_link_timer(pmlmeext, REASSOC_TO);
4881 }
4882}
4883
4884void addba_timer_hdl(struct timer_list *t)
4885{
4886 struct sta_info *psta = from_timer(psta, t, addba_retry_timer);
4887 struct ht_priv *phtpriv;
4888
4889 if (!psta)
4890 return;
4891
4892 phtpriv = &psta->htpriv;
4893
4894 if ((phtpriv->ht_option) && (phtpriv->ampdu_enable)) {
4895 if (phtpriv->candidate_tid_bitmap)
4896 phtpriv->candidate_tid_bitmap = 0x0;
4897 }
4898}
4899
4900u8 setopmode_hdl(struct adapter *padapter, u8 *pbuf)
4901{
4902 u8 type;
4903 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4904 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4905 struct setopmode_parm *psetop = (struct setopmode_parm *)pbuf;
4906
4907 if (psetop->mode == Ndis802_11APMode) {
4908 pmlmeinfo->state = WIFI_FW_AP_STATE;
4909 type = _HW_STATE_AP_;
4910 } else if (psetop->mode == Ndis802_11Infrastructure) {
4911 pmlmeinfo->state &= ~(BIT(0)|BIT(1));
4912 pmlmeinfo->state |= WIFI_FW_STATION_STATE;
4913 type = _HW_STATE_STATION_;
4914 } else if (psetop->mode == Ndis802_11IBSS) {
4915 type = _HW_STATE_ADHOC_;
4916 } else {
4917 type = _HW_STATE_NOLINK_;
4918 }
4919
4920 rtw_hal_set_hwreg(padapter, HW_VAR_SET_OPMODE, (u8 *)(&type));
4921
4922
4923 return H2C_SUCCESS;
4924}
4925
4926u8 createbss_hdl(struct adapter *padapter, u8 *pbuf)
4927{
4928 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4929 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4930 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)(&(pmlmeinfo->network));
4931 struct wlan_bssid_ex *pparm = (struct wlan_bssid_ex *)pbuf;
4932
4933
4934
4935 if (pparm->InfrastructureMode == Ndis802_11APMode) {
4936#ifdef CONFIG_88EU_AP_MODE
4937
4938 if (pmlmeinfo->state == WIFI_FW_AP_STATE) {
4939
4940 return H2C_SUCCESS;
4941 }
4942#endif
4943 }
4944
4945
4946 if (pparm->InfrastructureMode == Ndis802_11IBSS) {
4947 rtw_joinbss_reset(padapter);
4948
4949 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_20;
4950 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
4951 pmlmeinfo->ERP_enable = 0;
4952 pmlmeinfo->WMM_enable = 0;
4953 pmlmeinfo->HT_enable = 0;
4954 pmlmeinfo->HT_caps_enable = 0;
4955 pmlmeinfo->HT_info_enable = 0;
4956 pmlmeinfo->agg_enable_bitmap = 0;
4957 pmlmeinfo->candidate_tid_bitmap = 0;
4958
4959
4960 Save_DM_Func_Flag(padapter);
4961 Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false);
4962
4963
4964
4965
4966
4967
4968 del_timer_sync(&pmlmeext->link_timer);
4969
4970
4971 flush_all_cam_entry(padapter);
4972
4973 memcpy(pnetwork, pbuf, offsetof(struct wlan_bssid_ex, IELength));
4974 pnetwork->IELength = ((struct wlan_bssid_ex *)pbuf)->IELength;
4975
4976 if (pnetwork->IELength > MAX_IE_SZ)
4977 return H2C_PARAMETERS_ERROR;
4978
4979 memcpy(pnetwork->IEs, ((struct wlan_bssid_ex *)pbuf)->IEs, pnetwork->IELength);
4980
4981 start_create_ibss(padapter);
4982 }
4983
4984 return H2C_SUCCESS;
4985}
4986
4987u8 join_cmd_hdl(struct adapter *padapter, u8 *pbuf)
4988{
4989 u8 join_type;
4990 struct ndis_802_11_var_ie *pIE;
4991 struct registry_priv *pregpriv = &padapter->registrypriv;
4992 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4993 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
4994 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)(&(pmlmeinfo->network));
4995 struct wlan_bssid_ex *pparm = (struct wlan_bssid_ex *)pbuf;
4996 u32 i;
4997
4998
4999 if (pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) {
5000 if (pmlmeinfo->state & WIFI_FW_STATION_STATE)
5001 issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, 5, 100);
5002
5003 pmlmeinfo->state = WIFI_FW_NULL_STATE;
5004
5005
5006 flush_all_cam_entry(padapter);
5007
5008 del_timer_sync(&pmlmeext->link_timer);
5009
5010
5011 Set_MSR(padapter, _HW_STATE_STATION_);
5012
5013
5014 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_DISCONNECT, NULL);
5015 }
5016
5017 rtw_antenna_select_cmd(padapter, pparm->PhyInfo.Optimum_antenna, false);
5018
5019 rtw_joinbss_reset(padapter);
5020
5021 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_20;
5022 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
5023 pmlmeinfo->ERP_enable = 0;
5024 pmlmeinfo->WMM_enable = 0;
5025 pmlmeinfo->HT_enable = 0;
5026 pmlmeinfo->HT_caps_enable = 0;
5027 pmlmeinfo->HT_info_enable = 0;
5028 pmlmeinfo->agg_enable_bitmap = 0;
5029 pmlmeinfo->candidate_tid_bitmap = 0;
5030 pmlmeinfo->bwmode_updated = false;
5031
5032 memcpy(pnetwork, pbuf, offsetof(struct wlan_bssid_ex, IELength));
5033 pnetwork->IELength = ((struct wlan_bssid_ex *)pbuf)->IELength;
5034
5035 if (pnetwork->IELength > MAX_IE_SZ)
5036 return H2C_PARAMETERS_ERROR;
5037
5038 memcpy(pnetwork->IEs, ((struct wlan_bssid_ex *)pbuf)->IEs, pnetwork->IELength);
5039
5040
5041
5042 for (i = sizeof(struct ndis_802_11_fixed_ie); i < pnetwork->IELength;) {
5043 pIE = (struct ndis_802_11_var_ie *)(pnetwork->IEs + i);
5044
5045 switch (pIE->ElementID) {
5046 case _VENDOR_SPECIFIC_IE_:
5047 if (!memcmp(pIE->data, WMM_OUI, 4))
5048 pmlmeinfo->WMM_enable = 1;
5049 break;
5050 case _HT_CAPABILITY_IE_:
5051 pmlmeinfo->HT_caps_enable = 1;
5052 break;
5053 case _HT_EXTRA_INFO_IE_:
5054 pmlmeinfo->HT_info_enable = 1;
5055
5056
5057 {
5058 struct HT_info_element *pht_info = (struct HT_info_element *)(pIE->data);
5059
5060 if ((pregpriv->cbw40_enable) && (pht_info->infos[0] & BIT(2))) {
5061
5062 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_40;
5063 switch (pht_info->infos[0] & 0x3) {
5064 case 1:
5065 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
5066 break;
5067 case 3:
5068 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
5069 break;
5070 default:
5071 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
5072 break;
5073 }
5074
5075 DBG_88E("set ch/bw before connected\n");
5076 }
5077 }
5078 break;
5079 default:
5080 break;
5081 }
5082
5083 i += (pIE->Length + 2);
5084 }
5085
5086
5087
5088
5089 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pmlmeinfo->network.MacAddress);
5090 join_type = 0;
5091 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_JOIN, (u8 *)(&join_type));
5092
5093
5094 del_timer_sync(&pmlmeext->link_timer);
5095
5096 start_clnt_join(padapter);
5097
5098 return H2C_SUCCESS;
5099}
5100
5101u8 disconnect_hdl(struct adapter *padapter, unsigned char *pbuf)
5102{
5103 struct disconnect_parm *param = (struct disconnect_parm *)pbuf;
5104 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5105 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5106 struct wlan_bssid_ex *pnetwork = (struct wlan_bssid_ex *)(&(pmlmeinfo->network));
5107 u8 val8;
5108
5109 if (is_client_associated_to_ap(padapter))
5110 issue_deauth_ex(padapter, pnetwork->MacAddress, WLAN_REASON_DEAUTH_LEAVING, param->deauth_timeout_ms/100, 100);
5111
5112 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_DISCONNECT, NULL);
5113 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, null_addr);
5114
5115
5116 update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
5117
5118 if (((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)) {
5119
5120 val8 = 0;
5121 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_FUNC, (u8 *)(&val8));
5122 }
5123
5124
5125
5126 Set_MSR(padapter, _HW_STATE_STATION_);
5127
5128 pmlmeinfo->state = WIFI_FW_NULL_STATE;
5129
5130
5131 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_20;
5132 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
5133
5134 set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode);
5135
5136 flush_all_cam_entry(padapter);
5137
5138 del_timer_sync(&pmlmeext->link_timer);
5139
5140 rtw_free_uc_swdec_pending_queue(padapter);
5141
5142 return H2C_SUCCESS;
5143}
5144
5145static int rtw_scan_ch_decision(struct adapter *padapter,
5146 struct rtw_ieee80211_channel *out,
5147 u32 out_num,
5148 struct rtw_ieee80211_channel *in, u32 in_num)
5149{
5150 int i, j;
5151 int set_idx;
5152 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5153
5154
5155 memset(out, 0, sizeof(struct rtw_ieee80211_channel)*out_num);
5156
5157
5158 j = 0;
5159 for (i = 0; i < in_num; i++) {
5160 set_idx = rtw_ch_set_search_ch(pmlmeext->channel_set, in[i].hw_value);
5161 if (in[i].hw_value && !(in[i].flags & RTW_IEEE80211_CHAN_DISABLED) &&
5162 set_idx >= 0) {
5163 out[j] = in[i];
5164
5165 if (pmlmeext->channel_set[set_idx].ScanType == SCAN_PASSIVE)
5166 out[j].flags &= RTW_IEEE80211_CHAN_PASSIVE_SCAN;
5167
5168 j++;
5169 }
5170 if (j >= out_num)
5171 break;
5172 }
5173
5174
5175 if (j == 0) {
5176 for (i = 0; i < pmlmeext->max_chan_nums; i++) {
5177 out[i].hw_value = pmlmeext->channel_set[i].ChannelNum;
5178
5179 if (pmlmeext->channel_set[i].ScanType == SCAN_PASSIVE)
5180 out[i].flags &= RTW_IEEE80211_CHAN_PASSIVE_SCAN;
5181
5182 j++;
5183 }
5184 }
5185
5186 return j;
5187}
5188
5189u8 sitesurvey_cmd_hdl(struct adapter *padapter, u8 *pbuf)
5190{
5191 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5192 struct sitesurvey_parm *pparm = (struct sitesurvey_parm *)pbuf;
5193 u8 bdelayscan = false;
5194 u8 val8;
5195 u32 initialgain;
5196 u32 i;
5197
5198 if (pmlmeext->sitesurvey_res.state == SCAN_DISABLE) {
5199
5200 rtw_hal_set_hwreg(padapter, HW_VAR_CHECK_TXBUF, NULL);
5201
5202 pmlmeext->sitesurvey_res.state = SCAN_START;
5203 pmlmeext->sitesurvey_res.bss_cnt = 0;
5204 pmlmeext->sitesurvey_res.channel_idx = 0;
5205
5206 for (i = 0; i < RTW_SSID_SCAN_AMOUNT; i++) {
5207 if (pparm->ssid[i].SsidLength) {
5208 memcpy(pmlmeext->sitesurvey_res.ssid[i].Ssid, pparm->ssid[i].Ssid, IW_ESSID_MAX_SIZE);
5209 pmlmeext->sitesurvey_res.ssid[i].SsidLength = pparm->ssid[i].SsidLength;
5210 } else {
5211 pmlmeext->sitesurvey_res.ssid[i].SsidLength = 0;
5212 }
5213 }
5214
5215 pmlmeext->sitesurvey_res.ch_num = rtw_scan_ch_decision(padapter
5216 , pmlmeext->sitesurvey_res.ch, RTW_CHANNEL_SCAN_AMOUNT
5217 , pparm->ch, pparm->ch_num
5218 );
5219
5220 pmlmeext->sitesurvey_res.scan_mode = pparm->scan_mode;
5221
5222
5223 if (is_client_associated_to_ap(padapter)) {
5224 pmlmeext->sitesurvey_res.state = SCAN_TXNULL;
5225
5226 issue_nulldata(padapter, NULL, 1, 3, 500);
5227
5228 bdelayscan = true;
5229 }
5230 if (bdelayscan) {
5231
5232 set_survey_timer(pmlmeext, 50);
5233 return H2C_SUCCESS;
5234 }
5235 }
5236
5237 if ((pmlmeext->sitesurvey_res.state == SCAN_START) || (pmlmeext->sitesurvey_res.state == SCAN_TXNULL)) {
5238
5239 Save_DM_Func_Flag(padapter);
5240 Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false);
5241
5242
5243 initialgain = 0x1E;
5244
5245 rtw_hal_set_hwreg(padapter, HW_VAR_INITIAL_GAIN, (u8 *)(&initialgain));
5246
5247
5248 Set_MSR(padapter, _HW_STATE_NOLINK_);
5249
5250 val8 = 1;
5251 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
5252
5253 pmlmeext->sitesurvey_res.state = SCAN_PROCESS;
5254 }
5255
5256 site_survey(padapter);
5257
5258 return H2C_SUCCESS;
5259}
5260
5261u8 setauth_hdl(struct adapter *padapter, unsigned char *pbuf)
5262{
5263 struct setauth_parm *pparm = (struct setauth_parm *)pbuf;
5264 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5265 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5266
5267 if (pparm->mode < 4)
5268 pmlmeinfo->auth_algo = pparm->mode;
5269 return H2C_SUCCESS;
5270}
5271
5272u8 setkey_hdl(struct adapter *padapter, u8 *pbuf)
5273{
5274 unsigned short ctrl;
5275 struct setkey_parm *pparm = (struct setkey_parm *)pbuf;
5276 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5277 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5278 unsigned char null_sta[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
5279
5280
5281 if (pparm->set_tx)
5282 pmlmeinfo->key_index = pparm->keyid;
5283
5284
5285 ctrl = BIT(15) | ((pparm->algorithm) << 2) | pparm->keyid;
5286
5287 DBG_88E_LEVEL(_drv_info_, "set group key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) "
5288 "keyid:%d\n", pparm->algorithm, pparm->keyid);
5289 write_cam(padapter, pparm->keyid, ctrl, null_sta, pparm->key);
5290
5291 return H2C_SUCCESS;
5292}
5293
5294u8 set_stakey_hdl(struct adapter *padapter, u8 *pbuf)
5295{
5296 u16 ctrl = 0;
5297 u8 cam_id;
5298 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5299 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5300 struct set_stakey_parm *pparm = (struct set_stakey_parm *)pbuf;
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315 cam_id = 4;
5316
5317 DBG_88E_LEVEL(_drv_info_, "set pairwise key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) camid:%d\n",
5318 pparm->algorithm, cam_id);
5319 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) {
5320 struct sta_info *psta;
5321 struct sta_priv *pstapriv = &padapter->stapriv;
5322
5323 if (pparm->algorithm == _NO_PRIVACY_) {
5324 clear_cam_entry(padapter, pparm->id);
5325 return H2C_SUCCESS_RSP;
5326 }
5327
5328 psta = rtw_get_stainfo(pstapriv, pparm->addr);
5329 if (psta) {
5330 ctrl = BIT(15) | ((pparm->algorithm) << 2);
5331
5332 DBG_88E("r871x_set_stakey_hdl(): enc_algorithm=%d\n", pparm->algorithm);
5333
5334 if ((psta->mac_id < 1) || (psta->mac_id > (NUM_STA-4))) {
5335 DBG_88E("r871x_set_stakey_hdl():set_stakey failed, mac_id(aid)=%d\n", psta->mac_id);
5336 return H2C_REJECTED;
5337 }
5338
5339 cam_id = psta->mac_id + 3;
5340
5341 DBG_88E("Write CAM, mac_addr =%pM, cam_entry=%d\n",
5342 pparm->addr, cam_id);
5343
5344 write_cam(padapter, cam_id, ctrl, pparm->addr, pparm->key);
5345
5346 return H2C_SUCCESS_RSP;
5347 } else {
5348 DBG_88E("r871x_set_stakey_hdl(): sta has been free\n");
5349 return H2C_REJECTED;
5350 }
5351 }
5352
5353
5354
5355 if (pparm->algorithm == _NO_PRIVACY_) {
5356 clear_cam_entry(padapter, pparm->id);
5357 return H2C_SUCCESS;
5358 }
5359 ctrl = BIT(15) | ((pparm->algorithm) << 2);
5360 write_cam(padapter, cam_id, ctrl, pparm->addr, pparm->key);
5361 pmlmeinfo->enc_algo = pparm->algorithm;
5362 return H2C_SUCCESS;
5363}
5364
5365u8 add_ba_hdl(struct adapter *padapter, unsigned char *pbuf)
5366{
5367 struct addBaReq_parm *pparm = (struct addBaReq_parm *)pbuf;
5368 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5369 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5370
5371 struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, pparm->addr);
5372
5373 if (!psta)
5374 return H2C_SUCCESS;
5375
5376 if (((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && (pmlmeinfo->HT_enable)) ||
5377 ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)) {
5378 issue_action_BA(padapter, pparm->addr, RTW_WLAN_ACTION_ADDBA_REQ, (u16)pparm->tid);
5379 mod_timer(&psta->addba_retry_timer,
5380 jiffies + msecs_to_jiffies(ADDBA_TO));
5381 } else {
5382 psta->htpriv.candidate_tid_bitmap &= ~BIT(pparm->tid);
5383 }
5384 return H2C_SUCCESS;
5385}
5386
5387u8 set_tx_beacon_cmd(struct adapter *padapter)
5388{
5389 struct cmd_obj *ph2c;
5390 struct wlan_bssid_ex *ptxBeacon_parm;
5391 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
5392 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5393 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5394 u8 res = _SUCCESS;
5395 int len_diff = 0;
5396
5397
5398 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
5399 if (!ph2c) {
5400 res = _FAIL;
5401 goto exit;
5402 }
5403
5404 ptxBeacon_parm = kmemdup(&(pmlmeinfo->network),
5405 sizeof(struct wlan_bssid_ex), GFP_ATOMIC);
5406 if (ptxBeacon_parm == NULL) {
5407 kfree(ph2c);
5408 res = _FAIL;
5409 goto exit;
5410 }
5411
5412 len_diff = update_hidden_ssid(ptxBeacon_parm->IEs+_BEACON_IE_OFFSET_,
5413 ptxBeacon_parm->IELength-_BEACON_IE_OFFSET_,
5414 pmlmeinfo->hidden_ssid_mode);
5415 ptxBeacon_parm->IELength += len_diff;
5416
5417 init_h2fwcmd_w_parm_no_rsp(ph2c, ptxBeacon_parm, _TX_Beacon_CMD_);
5418
5419 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
5420
5421
5422exit:
5423
5424
5425 return res;
5426}
5427
5428u8 mlme_evt_hdl(struct adapter *padapter, unsigned char *pbuf)
5429{
5430 u8 evt_code;
5431 u16 evt_sz;
5432 uint *peventbuf;
5433 void (*event_callback)(struct adapter *dev, u8 *pbuf);
5434
5435 peventbuf = (uint *)pbuf;
5436 evt_sz = (u16)(*peventbuf&0xffff);
5437 evt_code = (u8)((*peventbuf>>16)&0xff);
5438
5439
5440 if (evt_code >= MAX_C2HEVT) {
5441 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_, ("\nEvent Code(%d) mismatch!\n", evt_code));
5442 goto _abort_event_;
5443 }
5444
5445
5446 if ((wlanevents[evt_code].parmsize != 0) &&
5447 (wlanevents[evt_code].parmsize != evt_sz)) {
5448 RT_TRACE(_module_rtl871x_cmd_c_, _drv_err_,
5449 ("\nEvent(%d) Parm Size mismatch (%d vs %d)!\n",
5450 evt_code, wlanevents[evt_code].parmsize, evt_sz));
5451 goto _abort_event_;
5452 }
5453
5454 peventbuf += 2;
5455
5456 if (peventbuf) {
5457 event_callback = wlanevents[evt_code].event_callback;
5458 event_callback(padapter, (u8 *)peventbuf);
5459
5460 }
5461
5462_abort_event_:
5463 return H2C_SUCCESS;
5464}
5465
5466u8 tx_beacon_hdl(struct adapter *padapter, unsigned char *pbuf)
5467{
5468 if (send_beacon(padapter) == _FAIL) {
5469 DBG_88E("issue_beacon, fail!\n");
5470 return H2C_PARAMETERS_ERROR;
5471 }
5472#ifdef CONFIG_88EU_AP_MODE
5473 else {
5474 struct sta_info *psta_bmc;
5475 struct list_head *xmitframe_plist, *xmitframe_phead;
5476 struct xmit_frame *pxmitframe = NULL;
5477 struct sta_priv *pstapriv = &padapter->stapriv;
5478
5479
5480 psta_bmc = rtw_get_bcmc_stainfo(padapter);
5481 if (!psta_bmc)
5482 return H2C_SUCCESS;
5483
5484 if ((pstapriv->tim_bitmap&BIT(0)) && (psta_bmc->sleepq_len > 0)) {
5485 msleep(10);
5486 spin_lock_bh(&psta_bmc->sleep_q.lock);
5487
5488 xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
5489 xmitframe_plist = xmitframe_phead->next;
5490
5491 while (xmitframe_phead != xmitframe_plist) {
5492 pxmitframe = container_of(xmitframe_plist, struct xmit_frame, list);
5493
5494 xmitframe_plist = xmitframe_plist->next;
5495
5496 list_del_init(&pxmitframe->list);
5497
5498 psta_bmc->sleepq_len--;
5499 if (psta_bmc->sleepq_len > 0)
5500 pxmitframe->attrib.mdata = 1;
5501 else
5502 pxmitframe->attrib.mdata = 0;
5503
5504 pxmitframe->attrib.triggered = 1;
5505
5506 pxmitframe->attrib.qsel = 0x11;
5507
5508 spin_unlock_bh(&psta_bmc->sleep_q.lock);
5509 if (rtw_hal_xmit(padapter, pxmitframe))
5510 rtw_os_xmit_complete(padapter, pxmitframe);
5511 spin_lock_bh(&psta_bmc->sleep_q.lock);
5512 }
5513 spin_unlock_bh(&psta_bmc->sleep_q.lock);
5514 }
5515 }
5516#endif
5517 return H2C_SUCCESS;
5518}
5519
5520u8 set_ch_hdl(struct adapter *padapter, u8 *pbuf)
5521{
5522 struct set_ch_parm *set_ch_parm;
5523 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5524
5525 if (!pbuf)
5526 return H2C_PARAMETERS_ERROR;
5527
5528 set_ch_parm = (struct set_ch_parm *)pbuf;
5529
5530 DBG_88E(FUNC_NDEV_FMT" ch:%u, bw:%u, ch_offset:%u\n",
5531 FUNC_NDEV_ARG(padapter->pnetdev),
5532 set_ch_parm->ch, set_ch_parm->bw, set_ch_parm->ch_offset);
5533
5534 pmlmeext->cur_channel = set_ch_parm->ch;
5535 pmlmeext->cur_ch_offset = set_ch_parm->ch_offset;
5536 pmlmeext->cur_bwmode = set_ch_parm->bw;
5537
5538 set_channel_bwmode(padapter, set_ch_parm->ch, set_ch_parm->ch_offset, set_ch_parm->bw);
5539
5540 return H2C_SUCCESS;
5541}
5542
5543u8 set_chplan_hdl(struct adapter *padapter, unsigned char *pbuf)
5544{
5545 struct SetChannelPlan_param *setChannelPlan_param;
5546 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5547
5548 if (!pbuf)
5549 return H2C_PARAMETERS_ERROR;
5550
5551 setChannelPlan_param = (struct SetChannelPlan_param *)pbuf;
5552
5553 pmlmeext->max_chan_nums = init_channel_set(padapter, setChannelPlan_param->channel_plan, pmlmeext->channel_set);
5554 init_channel_list(padapter, pmlmeext->channel_set, pmlmeext->max_chan_nums, &pmlmeext->channel_list);
5555
5556 return H2C_SUCCESS;
5557}
5558
