1
2
3
4
5
6
7
8#include <drv_types.h>
9#include <rtw_debug.h>
10#include <asm/unaligned.h>
11
12void init_mlme_ap_info(struct adapter *padapter)
13{
14 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15 struct sta_priv *pstapriv = &padapter->stapriv;
16 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
17
18 spin_lock_init(&pmlmepriv->bcn_update_lock);
19
20
21 INIT_LIST_HEAD(&pacl_list->acl_node_q.queue);
22 spin_lock_init(&pacl_list->acl_node_q.lock);
23
24
25
26 start_ap_mode(padapter);
27}
28
29void free_mlme_ap_info(struct adapter *padapter)
30{
31 struct sta_info *psta = NULL;
32 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
33 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
34 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
35
36
37
38 pmlmepriv->update_bcn = false;
39 pmlmeext->bstart_bss = false;
40
41 rtw_sta_flush(padapter);
42
43 pmlmeinfo->state = _HW_STATE_NOLINK_;
44
45
46 rtw_free_all_stainfo(padapter);
47
48
49 psta = rtw_get_bcmc_stainfo(padapter);
50 rtw_free_stainfo(padapter, psta);
51}
52
53static void update_BCNTIM(struct adapter *padapter)
54{
55 struct sta_priv *pstapriv = &padapter->stapriv;
56 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
57 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
58 struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network;
59 unsigned char *pie = pnetwork_mlmeext->ies;
60
61
62 u8 *p, *dst_ie, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
63 __le16 tim_bitmap_le;
64 uint offset, tmp_len, tim_ielen, tim_ie_offset, remainder_ielen;
65
66 tim_bitmap_le = cpu_to_le16(pstapriv->tim_bitmap);
67
68 p = rtw_get_ie(pie + _FIXED_IE_LENGTH_,
69 WLAN_EID_TIM,
70 &tim_ielen,
71 pnetwork_mlmeext->ie_length - _FIXED_IE_LENGTH_
72 );
73 if (p && tim_ielen > 0) {
74 tim_ielen += 2;
75
76 premainder_ie = p + tim_ielen;
77
78 tim_ie_offset = (signed int)(p - pie);
79
80 remainder_ielen = pnetwork_mlmeext->ie_length - tim_ie_offset - tim_ielen;
81
82
83 dst_ie = p;
84 } else {
85 tim_ielen = 0;
86
87
88 offset = _FIXED_IE_LENGTH_;
89
90
91 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_,
92 WLAN_EID_SSID,
93 &tmp_len,
94 (pnetwork_mlmeext->ie_length - _BEACON_IE_OFFSET_)
95 );
96 if (p)
97 offset += tmp_len + 2;
98
99
100 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_,
101 WLAN_EID_SUPP_RATES, &tmp_len,
102 (pnetwork_mlmeext->ie_length - _BEACON_IE_OFFSET_)
103 );
104 if (p)
105 offset += tmp_len + 2;
106
107
108 offset += 3;
109
110 premainder_ie = pie + offset;
111
112 remainder_ielen = pnetwork_mlmeext->ie_length - offset - tim_ielen;
113
114
115 dst_ie = pie + offset;
116 }
117
118 if (remainder_ielen > 0) {
119 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
120 if (pbackup_remainder_ie && premainder_ie)
121 memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
122 }
123
124 *dst_ie++ = WLAN_EID_TIM;
125
126 if ((pstapriv->tim_bitmap & 0xff00) && (pstapriv->tim_bitmap & 0x00fe))
127 tim_ielen = 5;
128 else
129 tim_ielen = 4;
130
131 *dst_ie++ = tim_ielen;
132
133 *dst_ie++ = 0;
134 *dst_ie++ = 1;
135
136 if (pstapriv->tim_bitmap & BIT(0))
137 *dst_ie++ = BIT(0);
138 else
139 *dst_ie++ = 0;
140
141 if (tim_ielen == 4) {
142 __le16 pvb;
143
144 if (pstapriv->tim_bitmap & 0xff00)
145 pvb = cpu_to_le16(pstapriv->tim_bitmap >> 8);
146 else
147 pvb = tim_bitmap_le;
148
149 *dst_ie++ = le16_to_cpu(pvb);
150
151 } else if (tim_ielen == 5) {
152 memcpy(dst_ie, &tim_bitmap_le, 2);
153 dst_ie += 2;
154 }
155
156
157 if (pbackup_remainder_ie) {
158 memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
159
160 kfree(pbackup_remainder_ie);
161 }
162
163 offset = (uint)(dst_ie - pie);
164 pnetwork_mlmeext->ie_length = offset + remainder_ielen;
165}
166
167static u8 chk_sta_is_alive(struct sta_info *psta)
168{
169 sta_update_last_rx_pkts(psta);
170
171 return true;
172}
173
174void expire_timeout_chk(struct adapter *padapter)
175{
176 struct list_head *phead, *plist, *tmp;
177 u8 updated = false;
178 struct sta_info *psta = NULL;
179 struct sta_priv *pstapriv = &padapter->stapriv;
180 u8 chk_alive_num = 0;
181 char chk_alive_list[NUM_STA];
182 int i;
183
184 spin_lock_bh(&pstapriv->auth_list_lock);
185
186 phead = &pstapriv->auth_list;
187
188 list_for_each_safe(plist, tmp, phead) {
189 psta = list_entry(plist, struct sta_info, auth_list);
190
191 if (psta->expire_to > 0) {
192 psta->expire_to--;
193 if (psta->expire_to == 0) {
194 list_del_init(&psta->auth_list);
195 pstapriv->auth_list_cnt--;
196
197 spin_unlock_bh(&pstapriv->auth_list_lock);
198
199 rtw_free_stainfo(padapter, psta);
200
201 spin_lock_bh(&pstapriv->auth_list_lock);
202 }
203 }
204 }
205
206 spin_unlock_bh(&pstapriv->auth_list_lock);
207 psta = NULL;
208
209 spin_lock_bh(&pstapriv->asoc_list_lock);
210
211 phead = &pstapriv->asoc_list;
212
213 list_for_each_safe(plist, tmp, phead) {
214 psta = list_entry(plist, struct sta_info, asoc_list);
215 if (chk_sta_is_alive(psta) || !psta->expire_to) {
216 psta->expire_to = pstapriv->expire_to;
217 psta->keep_alive_trycnt = 0;
218 psta->under_exist_checking = 0;
219 } else {
220 if (psta->expire_to > 0)
221 psta->expire_to--;
222 }
223
224 if (psta->expire_to == 0) {
225 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
226
227 if (padapter->registrypriv.wifi_spec == 1) {
228 psta->expire_to = pstapriv->expire_to;
229 continue;
230 }
231
232 if (psta->state & WIFI_SLEEP_STATE) {
233 if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) {
234
235
236 psta->expire_to = pstapriv->expire_to;
237 psta->state |= WIFI_STA_ALIVE_CHK_STATE;
238
239
240 pstapriv->tim_bitmap |= BIT(psta->aid);
241 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
242
243 if (!pmlmeext->active_keep_alive_check)
244 continue;
245 }
246 }
247 if (pmlmeext->active_keep_alive_check) {
248 int stainfo_offset;
249
250 stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
251 if (stainfo_offset_valid(stainfo_offset))
252 chk_alive_list[chk_alive_num++] = stainfo_offset;
253
254 continue;
255 }
256 list_del_init(&psta->asoc_list);
257 pstapriv->asoc_list_cnt--;
258 updated = ap_free_sta(padapter, psta, false, WLAN_REASON_DEAUTH_LEAVING);
259 } else {
260
261
262 if (psta->sleepq_len > (NR_XMITFRAME / pstapriv->asoc_list_cnt)
263 && padapter->xmitpriv.free_xmitframe_cnt < ((
264 NR_XMITFRAME / pstapriv->asoc_list_cnt
265 ) / 2)
266 )
267 wakeup_sta_to_xmit(padapter, psta);
268 }
269 }
270
271 spin_unlock_bh(&pstapriv->asoc_list_lock);
272
273 if (chk_alive_num) {
274 u8 backup_oper_channel = 0;
275 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
276
277
278 if (rtw_get_oper_ch(padapter) != pmlmeext->cur_channel) {
279 backup_oper_channel = rtw_get_oper_ch(padapter);
280 SelectChannel(padapter, pmlmeext->cur_channel);
281 }
282
283
284 for (i = 0; i < chk_alive_num; i++) {
285 int ret = _FAIL;
286
287 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
288 if (!(psta->state & _FW_LINKED))
289 continue;
290
291 if (psta->state & WIFI_SLEEP_STATE)
292 ret = issue_nulldata(padapter, psta->hwaddr, 0, 1, 50);
293 else
294 ret = issue_nulldata(padapter, psta->hwaddr, 0, 3, 50);
295
296 psta->keep_alive_trycnt++;
297 if (ret == _SUCCESS) {
298 psta->expire_to = pstapriv->expire_to;
299 psta->keep_alive_trycnt = 0;
300 continue;
301 } else if (psta->keep_alive_trycnt <= 3) {
302 psta->expire_to = 1;
303 continue;
304 }
305
306 psta->keep_alive_trycnt = 0;
307 spin_lock_bh(&pstapriv->asoc_list_lock);
308 if (list_empty(&psta->asoc_list) == false) {
309 list_del_init(&psta->asoc_list);
310 pstapriv->asoc_list_cnt--;
311 updated = ap_free_sta(padapter, psta, false,
312 WLAN_REASON_DEAUTH_LEAVING);
313 }
314 spin_unlock_bh(&pstapriv->asoc_list_lock);
315 }
316
317 if (backup_oper_channel > 0)
318 SelectChannel(padapter, backup_oper_channel);
319 }
320
321 associated_clients_update(padapter, updated);
322}
323
324void add_RATid(struct adapter *padapter, struct sta_info *psta, u8 rssi_level)
325{
326 unsigned char sta_band = 0, shortGIrate = false;
327 unsigned int tx_ra_bitmap = 0;
328 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
329 struct wlan_bssid_ex
330 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
331
332 if (!psta)
333 return;
334
335 if (!(psta->state & _FW_LINKED))
336 return;
337
338 rtw_hal_update_sta_rate_mask(padapter, psta);
339 tx_ra_bitmap = psta->ra_mask;
340
341 shortGIrate = query_ra_short_GI(psta);
342
343 if (pcur_network->configuration.ds_config > 14) {
344 sta_band |= WIRELESS_INVALID;
345 } else {
346 if (tx_ra_bitmap & 0xffff000)
347 sta_band |= WIRELESS_11_24N;
348
349 if (tx_ra_bitmap & 0xff0)
350 sta_band |= WIRELESS_11G;
351
352 if (tx_ra_bitmap & 0x0f)
353 sta_band |= WIRELESS_11B;
354 }
355
356 psta->wireless_mode = sta_band;
357 psta->raid = networktype_to_raid_ex(padapter, psta);
358
359 if (psta->aid < NUM_STA) {
360 u8 arg[4] = {0};
361
362 arg[0] = psta->mac_id;
363 arg[1] = psta->raid;
364 arg[2] = shortGIrate;
365 arg[3] = psta->init_rate;
366
367 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, rssi_level);
368 }
369}
370
371void update_bmc_sta(struct adapter *padapter)
372{
373 unsigned char network_type;
374 int supportRateNum = 0;
375 unsigned int tx_ra_bitmap = 0;
376 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
377 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
378 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
379 struct wlan_bssid_ex
380 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
381 struct sta_info *psta = rtw_get_bcmc_stainfo(padapter);
382
383 if (psta) {
384 psta->aid = 0;
385
386 psta->mac_id = psta->aid + 1;
387
388 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
389
390 psta->qos_option = 0;
391 psta->htpriv.ht_option = false;
392
393 psta->ieee8021x_blocked = 0;
394
395 memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
396
397
398
399
400 supportRateNum = rtw_get_rateset_len((u8 *)&pcur_network->supported_rates);
401 network_type = rtw_check_network_type((u8 *)&pcur_network->supported_rates,
402 supportRateNum,
403 pcur_network->configuration.ds_config
404 );
405 if (is_supported_tx_cck(network_type)) {
406 network_type = WIRELESS_11B;
407 } else if (network_type == WIRELESS_INVALID) {
408
409 if (pcur_network->configuration.ds_config > 14)
410 network_type = WIRELESS_INVALID;
411 else
412 network_type = WIRELESS_11B;
413 }
414 update_sta_basic_rate(psta, network_type);
415 psta->wireless_mode = network_type;
416
417 rtw_hal_update_sta_rate_mask(padapter, psta);
418 tx_ra_bitmap = psta->ra_mask;
419
420 psta->raid = networktype_to_raid_ex(padapter, psta);
421
422
423 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
424
425
426 {
427 u8 arg[4] = {0};
428
429 arg[0] = psta->mac_id;
430 arg[1] = psta->raid;
431 arg[2] = 0;
432 arg[3] = psta->init_rate;
433
434 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, 0);
435 }
436
437 rtw_sta_media_status_rpt(padapter, psta, 1);
438
439 spin_lock_bh(&psta->lock);
440 psta->state = _FW_LINKED;
441 spin_unlock_bh(&psta->lock);
442
443 }
444}
445
446
447
448
449
450
451
452
453void update_sta_info_apmode(struct adapter *padapter, struct sta_info *psta)
454{
455 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
456 struct security_priv *psecuritypriv = &padapter->securitypriv;
457 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
458 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
459 struct ht_priv *phtpriv_sta = &psta->htpriv;
460 u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0;
461
462
463
464
465
466
467
468
469 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
470
471 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
472 psta->ieee8021x_blocked = true;
473 else
474 psta->ieee8021x_blocked = false;
475
476
477
478
479 VCS_update(padapter, psta);
480
481
482 if (phtpriv_sta->ht_option) {
483
484 phtpriv_sta->ampdu_enable = phtpriv_ap->ampdu_enable;
485
486 phtpriv_sta->rx_ampdu_min_spacing = (
487 phtpriv_sta->ht_cap.ampdu_params_info & IEEE80211_HT_CAP_AMPDU_DENSITY
488 ) >> 2;
489
490
491 if ((
492 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
493 ) & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH))
494 psta->bw_mode = CHANNEL_WIDTH_40;
495 else
496 psta->bw_mode = CHANNEL_WIDTH_20;
497
498 if (pmlmeext->cur_bwmode < psta->bw_mode)
499 psta->bw_mode = pmlmeext->cur_bwmode;
500
501 phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset;
502
503
504 if ((
505 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
506 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
507 phtpriv_sta->sgi_20m = true;
508
509
510 if ((
511 phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
512 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) {
513 if (psta->bw_mode == CHANNEL_WIDTH_40)
514 phtpriv_sta->sgi_40m = true;
515 else
516 phtpriv_sta->sgi_40m = false;
517 }
518
519 psta->qos_option = true;
520
521
522 if (TEST_FLAG(phtpriv_ap->ldpc_cap, LDPC_HT_ENABLE_TX) &&
523 GET_HT_CAPABILITY_ELE_LDPC_CAP((u8 *)(&phtpriv_sta->ht_cap)))
524 SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
525
526
527 if (TEST_FLAG(phtpriv_ap->stbc_cap, STBC_HT_ENABLE_TX) &&
528 GET_HT_CAPABILITY_ELE_RX_STBC((u8 *)(&phtpriv_sta->ht_cap)))
529 SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
530 } else {
531 phtpriv_sta->ampdu_enable = false;
532
533 phtpriv_sta->sgi_20m = false;
534 phtpriv_sta->sgi_40m = false;
535 psta->bw_mode = CHANNEL_WIDTH_20;
536 phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
537 }
538
539 phtpriv_sta->ldpc_cap = cur_ldpc_cap;
540 phtpriv_sta->stbc_cap = cur_stbc_cap;
541 phtpriv_sta->beamform_cap = cur_beamform_cap;
542
543
544 send_delba(padapter, 0, psta->hwaddr);
545
546
547 send_delba(padapter, 1, psta->hwaddr);
548 phtpriv_sta->agg_enable_bitmap = 0x0;
549 phtpriv_sta->candidate_tid_bitmap = 0x0;
550
551 update_ldpc_stbc_cap(psta);
552
553
554
555 memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
556
557
558
559
560 spin_lock_bh(&psta->lock);
561 psta->state |= _FW_LINKED;
562 spin_unlock_bh(&psta->lock);
563}
564
565static void update_ap_info(struct adapter *padapter, struct sta_info *psta)
566{
567 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
568 struct wlan_bssid_ex
569 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
570 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
571 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
572
573 psta->wireless_mode = pmlmeext->cur_wireless_mode;
574
575 psta->bssratelen = rtw_get_rateset_len(pnetwork->supported_rates);
576 memcpy(psta->bssrateset, pnetwork->supported_rates, psta->bssratelen);
577
578
579 if (phtpriv_ap->ht_option) {
580
581
582
583
584 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
585 phtpriv_ap->sgi_20m = true;
586
587
588 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40))
589 phtpriv_ap->sgi_40m = true;
590
591 psta->qos_option = true;
592 } else {
593 phtpriv_ap->ampdu_enable = false;
594
595 phtpriv_ap->sgi_20m = false;
596 phtpriv_ap->sgi_40m = false;
597 }
598
599 psta->bw_mode = pmlmeext->cur_bwmode;
600 phtpriv_ap->ch_offset = pmlmeext->cur_ch_offset;
601
602 phtpriv_ap->agg_enable_bitmap = 0x0;
603 phtpriv_ap->candidate_tid_bitmap = 0x0;
604
605 memcpy(&psta->htpriv, &pmlmepriv->htpriv, sizeof(struct ht_priv));
606}
607
608static void update_hw_ht_param(struct adapter *padapter)
609{
610 unsigned char max_AMPDU_len;
611 unsigned char min_MPDU_spacing;
612 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
613 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
614
615
616
617
618
619
620 max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
621
622 min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2;
623
624 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing));
625
626 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len));
627
628
629
630
631 pmlmeinfo->SM_PS = (le16_to_cpu(
632 pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info
633 ) & 0x0C) >> 2;
634
635
636
637
638
639}
640
641void start_bss_network(struct adapter *padapter)
642{
643 u8 *p;
644 u8 val8, cur_channel, cur_bwmode, cur_ch_offset;
645 u16 bcn_interval;
646 u32 acparm;
647 int ie_len;
648 struct registry_priv *pregpriv = &padapter->registrypriv;
649 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
650 struct security_priv *psecuritypriv = &(padapter->securitypriv);
651 struct wlan_bssid_ex
652 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
653 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
654 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
655 struct wlan_bssid_ex *pnetwork_mlmeext = &(pmlmeinfo->network);
656 struct HT_info_element *pht_info = NULL;
657 u8 cbw40_enable = 0;
658
659 bcn_interval = (u16)pnetwork->configuration.beacon_period;
660 cur_channel = pnetwork->configuration.ds_config;
661 cur_bwmode = CHANNEL_WIDTH_20;
662 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
663
664
665
666
667 if (!rtw_get_wps_ie(pnetwork->ies + _FIXED_IE_LENGTH_,
668 pnetwork->ie_length - _FIXED_IE_LENGTH_, NULL, NULL))
669 pmlmeext->bstart_bss = true;
670
671
672
673
674 if (pmlmepriv->qospriv.qos_option)
675 pmlmeinfo->WMM_enable = true;
676 if (pmlmepriv->htpriv.ht_option) {
677 pmlmeinfo->WMM_enable = true;
678 pmlmeinfo->HT_enable = true;
679
680
681
682 update_hw_ht_param(padapter);
683 }
684
685 if (!pmlmepriv->cur_network.join_res) {
686
687
688 if ((psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) &&
689 (psecuritypriv->dot11PrivacyAlgrthm != _WEP104_))
690 flush_all_cam_entry(padapter);
691 }
692
693
694 Set_MSR(padapter, _HW_STATE_AP_);
695
696
697 rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pnetwork->mac_address);
698
699
700 acparm = 0x002F3217;
701 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acparm));
702 acparm = 0x005E4317;
703 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acparm));
704
705 acparm = 0x005ea42b;
706 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acparm));
707 acparm = 0x0000A444;
708 rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acparm));
709
710
711 val8 = (
712 psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X
713 ) ? 0xcc : 0xcf;
714 rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
715
716
717 rtw_hal_set_hwreg(padapter, HW_VAR_BEACON_INTERVAL, (u8 *)(&bcn_interval));
718
719 rtw_hal_set_hwreg(padapter, HW_VAR_DO_IQK, NULL);
720
721 if (!pmlmepriv->cur_network.join_res) {
722
723
724
725
726
727
728
729
730
731 Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true);
732
733
734 }
735
736
737 p = rtw_get_ie((pnetwork->ies + sizeof(struct ndis_802_11_fix_ie)),
738 WLAN_EID_HT_OPERATION,
739 &ie_len,
740 (pnetwork->ie_length - sizeof(struct ndis_802_11_fix_ie))
741 );
742 if (p && ie_len) {
743 pht_info = (struct HT_info_element *)(p + 2);
744
745 if (cur_channel > 14) {
746 if ((pregpriv->bw_mode & 0xf0) > 0)
747 cbw40_enable = 1;
748 } else {
749 if ((pregpriv->bw_mode & 0x0f) > 0)
750 cbw40_enable = 1;
751 }
752
753 if ((cbw40_enable) && (pht_info->infos[0] & BIT(2))) {
754
755
756 cur_bwmode = CHANNEL_WIDTH_40;
757 switch (pht_info->infos[0] & 0x3) {
758 case 1:
759
760 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
761 break;
762
763 case 3:
764
765 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
766 break;
767
768 default:
769
770 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
771 break;
772 }
773 }
774 }
775
776 set_channel_bwmode(padapter, cur_channel, cur_ch_offset, cur_bwmode);
777 pmlmeext->cur_channel = cur_channel;
778 pmlmeext->cur_bwmode = cur_bwmode;
779 pmlmeext->cur_ch_offset = cur_ch_offset;
780 pmlmeext->cur_wireless_mode = pmlmepriv->cur_network.network_type;
781
782
783 memcpy(pnetwork_mlmeext, pnetwork, pnetwork->length);
784
785
786 update_wireless_mode(padapter);
787
788
789 UpdateBrateTbl(padapter, pnetwork->supported_rates);
790 rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->supported_rates);
791
792
793 update_capinfo(
794 padapter,
795 rtw_get_capability((struct wlan_bssid_ex *)pnetwork)
796 );
797
798 if (pmlmeext->bstart_bss) {
799 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
800
801
802 send_beacon(padapter);
803 }
804
805
806 update_bmc_sta(padapter);
807
808
809}
810
811int rtw_check_beacon_data(struct adapter *padapter, u8 *pbuf, int len)
812{
813 int ret = _SUCCESS;
814 u8 *p;
815 u8 *pHT_caps_ie = NULL;
816 u8 *pHT_info_ie = NULL;
817 struct sta_info *psta = NULL;
818 u16 cap, ht_cap = false;
819 uint ie_len = 0;
820 int group_cipher, pairwise_cipher;
821 u8 channel, network_type, supportRate[NDIS_802_11_LENGTH_RATES_EX];
822 int supportRateNum = 0;
823 u8 OUI1[] = {0x00, 0x50, 0xf2, 0x01};
824 u8 WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
825 struct registry_priv *pregistrypriv = &padapter->registrypriv;
826 struct security_priv *psecuritypriv = &padapter->securitypriv;
827 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
828 struct wlan_bssid_ex
829 *pbss_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
830 u8 *ie = pbss_network->ies;
831
832 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
833 return _FAIL;
834
835 if (len < 0 || len > MAX_IE_SZ)
836 return _FAIL;
837
838 pbss_network->ie_length = len;
839
840 memset(ie, 0, MAX_IE_SZ);
841
842 memcpy(ie, pbuf, pbss_network->ie_length);
843
844 if (pbss_network->infrastructure_mode != Ndis802_11APMode)
845 return _FAIL;
846
847 pbss_network->rssi = 0;
848
849 memcpy(pbss_network->mac_address, myid(&(padapter->eeprompriv)), ETH_ALEN);
850
851
852 p = rtw_get_beacon_interval_from_ie(ie);
853
854 pbss_network->configuration.beacon_period = get_unaligned_le16(p);
855
856
857
858
859 cap = get_unaligned_le16(ie);
860
861
862 p = rtw_get_ie(
863 ie + _BEACON_IE_OFFSET_,
864 WLAN_EID_SSID,
865 &ie_len,
866 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
867 );
868 if (p && ie_len > 0) {
869 memset(&pbss_network->ssid, 0, sizeof(struct ndis_802_11_ssid));
870 memcpy(pbss_network->ssid.ssid, (p + 2), ie_len);
871 pbss_network->ssid.ssid_length = ie_len;
872 }
873
874
875 channel = 0;
876 pbss_network->configuration.length = 0;
877 p = rtw_get_ie(
878 ie + _BEACON_IE_OFFSET_,
879 WLAN_EID_DS_PARAMS, &ie_len,
880 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
881 );
882 if (p && ie_len > 0)
883 channel = *(p + 2);
884
885 pbss_network->configuration.ds_config = channel;
886
887 memset(supportRate, 0, NDIS_802_11_LENGTH_RATES_EX);
888
889 p = rtw_get_ie(
890 ie + _BEACON_IE_OFFSET_,
891 WLAN_EID_SUPP_RATES,
892 &ie_len,
893 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
894 );
895 if (p) {
896 memcpy(supportRate, p + 2, ie_len);
897 supportRateNum = ie_len;
898 }
899
900
901 p = rtw_get_ie(
902 ie + _BEACON_IE_OFFSET_,
903 WLAN_EID_EXT_SUPP_RATES,
904 &ie_len,
905 pbss_network->ie_length - _BEACON_IE_OFFSET_
906 );
907 if (p) {
908 memcpy(supportRate + supportRateNum, p + 2, ie_len);
909 supportRateNum += ie_len;
910 }
911
912 network_type = rtw_check_network_type(supportRate, supportRateNum, channel);
913
914 rtw_set_supported_rate(pbss_network->supported_rates, network_type);
915
916
917 p = rtw_get_ie(
918 ie + _BEACON_IE_OFFSET_,
919 WLAN_EID_ERP_INFO,
920 &ie_len,
921 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
922 );
923 if (p && ie_len > 0)
924 ERP_IE_handler(padapter, (struct ndis_80211_var_ie *)p);
925
926
927 if (cap & BIT(4))
928 pbss_network->privacy = 1;
929 else
930 pbss_network->privacy = 0;
931
932 psecuritypriv->wpa_psk = 0;
933
934
935 group_cipher = 0; pairwise_cipher = 0;
936 psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_;
937 psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_;
938 p = rtw_get_ie(
939 ie + _BEACON_IE_OFFSET_,
940 WLAN_EID_RSN,
941 &ie_len,
942 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
943 );
944 if (p && ie_len > 0) {
945 if (rtw_parse_wpa2_ie(
946 p,
947 ie_len + 2,
948 &group_cipher,
949 &pairwise_cipher,
950 NULL
951 ) == _SUCCESS) {
952 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
953
954 psecuritypriv->dot8021xalg = 1;
955 psecuritypriv->wpa_psk |= BIT(1);
956
957 psecuritypriv->wpa2_group_cipher = group_cipher;
958 psecuritypriv->wpa2_pairwise_cipher = pairwise_cipher;
959 }
960 }
961
962
963 ie_len = 0;
964 group_cipher = 0; pairwise_cipher = 0;
965 psecuritypriv->wpa_group_cipher = _NO_PRIVACY_;
966 psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_;
967 for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
968 p = rtw_get_ie(
969 p,
970 WLAN_EID_VENDOR_SPECIFIC,
971 &ie_len,
972 (pbss_network->ie_length - _BEACON_IE_OFFSET_ - (ie_len + 2))
973 );
974 if ((p) && (!memcmp(p + 2, OUI1, 4))) {
975 if (rtw_parse_wpa_ie(
976 p,
977 ie_len + 2,
978 &group_cipher,
979 &pairwise_cipher,
980 NULL
981 ) == _SUCCESS) {
982 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
983
984 psecuritypriv->dot8021xalg = 1;
985
986 psecuritypriv->wpa_psk |= BIT(0);
987
988 psecuritypriv->wpa_group_cipher = group_cipher;
989 psecuritypriv->wpa_pairwise_cipher = pairwise_cipher;
990 }
991
992 break;
993 }
994
995 if (!p || ie_len == 0)
996 break;
997 }
998
999
1000 ie_len = 0;
1001 pmlmepriv->qospriv.qos_option = 0;
1002 if (pregistrypriv->wmm_enable) {
1003 for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
1004 p = rtw_get_ie(
1005 p,
1006 WLAN_EID_VENDOR_SPECIFIC,
1007 &ie_len,
1008 (pbss_network->ie_length - _BEACON_IE_OFFSET_ - (ie_len + 2))
1009 );
1010 if ((p) && !memcmp(p + 2, WMM_PARA_IE, 6)) {
1011 pmlmepriv->qospriv.qos_option = 1;
1012
1013 *(p + 8) |= BIT(7);
1014
1015
1016
1017 *(p + 10) &= ~BIT(4);
1018 *(p + 14) &= ~BIT(4);
1019 *(p + 18) &= ~BIT(4);
1020 *(p + 22) &= ~BIT(4);
1021
1022 break;
1023 }
1024
1025 if (!p || ie_len == 0)
1026 break;
1027 }
1028 }
1029
1030
1031 p = rtw_get_ie(
1032 ie + _BEACON_IE_OFFSET_,
1033 WLAN_EID_HT_CAPABILITY,
1034 &ie_len,
1035 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
1036 );
1037 if (p && ie_len > 0) {
1038 u8 max_rx_ampdu_factor = 0;
1039 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2);
1040
1041 pHT_caps_ie = p;
1042
1043 ht_cap = true;
1044 network_type |= WIRELESS_11_24N;
1045
1046 rtw_ht_use_default_setting(padapter);
1047
1048 if (pmlmepriv->htpriv.sgi_20m == false)
1049 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_20));
1050
1051 if (pmlmepriv->htpriv.sgi_40m == false)
1052 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_40));
1053
1054 if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX))
1055 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_LDPC_CODING));
1056
1057 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX))
1058 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_TX_STBC));
1059
1060 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX))
1061 pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_RX_STBC_3R));
1062
1063 pht_cap->ampdu_params_info &= ~(
1064 IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY
1065 );
1066
1067 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) ||
1068 (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) {
1069 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (0x07 << 2));
1070 } else {
1071 pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
1072 }
1073
1074 rtw_hal_get_def_var(
1075 padapter,
1076 HW_VAR_MAX_RX_AMPDU_FACTOR,
1077 &max_rx_ampdu_factor
1078 );
1079 pht_cap->ampdu_params_info |= (
1080 IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor
1081 );
1082
1083 pht_cap->mcs.rx_mask[0] = 0xff;
1084 pht_cap->mcs.rx_mask[1] = 0x0;
1085
1086 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
1087 }
1088
1089
1090 p = rtw_get_ie(
1091 ie + _BEACON_IE_OFFSET_,
1092 WLAN_EID_HT_OPERATION,
1093 &ie_len,
1094 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
1095 );
1096 if (p && ie_len > 0)
1097 pHT_info_ie = p;
1098
1099 switch (network_type) {
1100 case WIRELESS_11B:
1101 pbss_network->network_type_in_use = Ndis802_11DS;
1102 break;
1103 case WIRELESS_11G:
1104 case WIRELESS_11BG:
1105 case WIRELESS_11G_24N:
1106 case WIRELESS_11BG_24N:
1107 pbss_network->network_type_in_use = Ndis802_11OFDM24;
1108 break;
1109 default:
1110 pbss_network->network_type_in_use = Ndis802_11OFDM24;
1111 break;
1112 }
1113
1114 pmlmepriv->cur_network.network_type = network_type;
1115
1116 pmlmepriv->htpriv.ht_option = false;
1117
1118 if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
1119 (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) {
1120
1121
1122 }
1123
1124
1125 if (pregistrypriv->ht_enable && ht_cap) {
1126 pmlmepriv->htpriv.ht_option = true;
1127 pmlmepriv->qospriv.qos_option = 1;
1128
1129 if (pregistrypriv->ampdu_enable == 1)
1130 pmlmepriv->htpriv.ampdu_enable = true;
1131
1132 HT_caps_handler(padapter, (struct ndis_80211_var_ie *)pHT_caps_ie);
1133
1134 HT_info_handler(padapter, (struct ndis_80211_var_ie *)pHT_info_ie);
1135 }
1136
1137 pbss_network->length = get_wlan_bssid_ex_sz(
1138 (struct wlan_bssid_ex *)pbss_network
1139 );
1140
1141
1142
1143 rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK);
1144
1145
1146 psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->mac_address);
1147 if (!psta) {
1148 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->mac_address);
1149 if (!psta)
1150 return _FAIL;
1151 }
1152
1153
1154 update_ap_info(padapter, psta);
1155
1156 psta->state |= WIFI_AP_STATE;
1157 rtw_indicate_connect(padapter);
1158
1159 pmlmepriv->cur_network.join_res = true;
1160
1161
1162
1163
1164 return ret;
1165}
1166
1167void rtw_set_macaddr_acl(struct adapter *padapter, int mode)
1168{
1169 struct sta_priv *pstapriv = &padapter->stapriv;
1170 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1171
1172 pacl_list->mode = mode;
1173}
1174
1175int rtw_acl_add_sta(struct adapter *padapter, u8 *addr)
1176{
1177 struct list_head *plist, *phead;
1178 u8 added = false;
1179 int i, ret = 0;
1180 struct rtw_wlan_acl_node *paclnode;
1181 struct sta_priv *pstapriv = &padapter->stapriv;
1182 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1183 struct __queue *pacl_node_q = &pacl_list->acl_node_q;
1184
1185 if ((NUM_ACL - 1) < pacl_list->num)
1186 return (-1);
1187
1188 spin_lock_bh(&(pacl_node_q->lock));
1189
1190 phead = get_list_head(pacl_node_q);
1191 list_for_each(plist, phead) {
1192 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1193
1194 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
1195 if (paclnode->valid == true) {
1196 added = true;
1197 break;
1198 }
1199 }
1200 }
1201
1202 spin_unlock_bh(&(pacl_node_q->lock));
1203
1204 if (added)
1205 return ret;
1206
1207 spin_lock_bh(&(pacl_node_q->lock));
1208
1209 for (i = 0; i < NUM_ACL; i++) {
1210 paclnode = &pacl_list->aclnode[i];
1211
1212 if (!paclnode->valid) {
1213 INIT_LIST_HEAD(&paclnode->list);
1214
1215 memcpy(paclnode->addr, addr, ETH_ALEN);
1216
1217 paclnode->valid = true;
1218
1219 list_add_tail(&paclnode->list, get_list_head(pacl_node_q));
1220
1221 pacl_list->num++;
1222
1223 break;
1224 }
1225 }
1226
1227 spin_unlock_bh(&(pacl_node_q->lock));
1228
1229 return ret;
1230}
1231
1232void rtw_acl_remove_sta(struct adapter *padapter, u8 *addr)
1233{
1234 struct list_head *plist, *phead, *tmp;
1235 struct rtw_wlan_acl_node *paclnode;
1236 struct sta_priv *pstapriv = &padapter->stapriv;
1237 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1238 struct __queue *pacl_node_q = &pacl_list->acl_node_q;
1239 u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1240
1241 spin_lock_bh(&(pacl_node_q->lock));
1242
1243 phead = get_list_head(pacl_node_q);
1244 list_for_each_safe(plist, tmp, phead) {
1245 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1246
1247 if (
1248 !memcmp(paclnode->addr, addr, ETH_ALEN) ||
1249 !memcmp(baddr, addr, ETH_ALEN)
1250 ) {
1251 if (paclnode->valid) {
1252 paclnode->valid = false;
1253
1254 list_del_init(&paclnode->list);
1255
1256 pacl_list->num--;
1257 }
1258 }
1259 }
1260
1261 spin_unlock_bh(&(pacl_node_q->lock));
1262
1263}
1264
1265u8 rtw_ap_set_pairwise_key(struct adapter *padapter, struct sta_info *psta)
1266{
1267 struct cmd_obj *ph2c;
1268 struct set_stakey_parm *psetstakey_para;
1269 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1270 u8 res = _SUCCESS;
1271
1272 ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
1273 if (!ph2c) {
1274 res = _FAIL;
1275 goto exit;
1276 }
1277
1278 psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
1279 if (!psetstakey_para) {
1280 kfree(ph2c);
1281 res = _FAIL;
1282 goto exit;
1283 }
1284
1285 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1286
1287 psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy;
1288
1289 memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN);
1290
1291 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
1292
1293 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1294
1295exit:
1296
1297 return res;
1298}
1299
1300static int rtw_ap_set_key(
1301 struct adapter *padapter,
1302 u8 *key,
1303 u8 alg,
1304 int keyid,
1305 u8 set_tx
1306)
1307{
1308 u8 keylen;
1309 struct cmd_obj *pcmd;
1310 struct setkey_parm *psetkeyparm;
1311 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
1312 int res = _SUCCESS;
1313
1314 pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
1315 if (!pcmd) {
1316 res = _FAIL;
1317 goto exit;
1318 }
1319 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
1320 if (!psetkeyparm) {
1321 kfree(pcmd);
1322 res = _FAIL;
1323 goto exit;
1324 }
1325
1326 psetkeyparm->keyid = (u8)keyid;
1327 if (is_wep_enc(alg))
1328 padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
1329
1330 psetkeyparm->algorithm = alg;
1331
1332 psetkeyparm->set_tx = set_tx;
1333
1334 switch (alg) {
1335 case _WEP40_:
1336 keylen = 5;
1337 break;
1338 case _WEP104_:
1339 keylen = 13;
1340 break;
1341 case _TKIP_:
1342 case _TKIP_WTMIC_:
1343 case _AES_:
1344 default:
1345 keylen = 16;
1346 }
1347
1348 memcpy(&(psetkeyparm->key[0]), key, keylen);
1349
1350 pcmd->cmdcode = _SetKey_CMD_;
1351 pcmd->parmbuf = (u8 *)psetkeyparm;
1352 pcmd->cmdsz = (sizeof(struct setkey_parm));
1353 pcmd->rsp = NULL;
1354 pcmd->rspsz = 0;
1355
1356 INIT_LIST_HEAD(&pcmd->list);
1357
1358 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1359
1360exit:
1361
1362 return res;
1363}
1364
1365int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
1366{
1367 return rtw_ap_set_key(padapter, key, alg, keyid, 1);
1368}
1369
1370int rtw_ap_set_wep_key(
1371 struct adapter *padapter,
1372 u8 *key,
1373 u8 keylen,
1374 int keyid,
1375 u8 set_tx
1376)
1377{
1378 u8 alg;
1379
1380 switch (keylen) {
1381 case 5:
1382 alg = _WEP40_;
1383 break;
1384 case 13:
1385 alg = _WEP104_;
1386 break;
1387 default:
1388 alg = _NO_PRIVACY_;
1389 }
1390
1391 return rtw_ap_set_key(padapter, key, alg, keyid, set_tx);
1392}
1393
1394static void update_bcn_fixed_ie(struct adapter *padapter)
1395{
1396}
1397
1398static void update_bcn_erpinfo_ie(struct adapter *padapter)
1399{
1400 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1401 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1402 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1403 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1404 unsigned char *p, *ie = pnetwork->ies;
1405 u32 len = 0;
1406
1407 if (!pmlmeinfo->ERP_enable)
1408 return;
1409
1410
1411 p = rtw_get_ie(
1412 ie + _BEACON_IE_OFFSET_,
1413 WLAN_EID_ERP_INFO,
1414 &len,
1415 (pnetwork->ie_length - _BEACON_IE_OFFSET_)
1416 );
1417 if (p && len > 0) {
1418 struct ndis_80211_var_ie *pIE = (struct ndis_80211_var_ie *)p;
1419
1420 if (pmlmepriv->num_sta_non_erp == 1)
1421 pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION;
1422 else
1423 pIE->data[0] &= ~(
1424 RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION
1425 );
1426
1427 if (pmlmepriv->num_sta_no_short_preamble > 0)
1428 pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE;
1429 else
1430 pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE);
1431
1432 ERP_IE_handler(padapter, pIE);
1433 }
1434}
1435
1436static void update_bcn_htcap_ie(struct adapter *padapter)
1437{
1438}
1439
1440static void update_bcn_htinfo_ie(struct adapter *padapter)
1441{
1442}
1443
1444static void update_bcn_rsn_ie(struct adapter *padapter)
1445{
1446}
1447
1448static void update_bcn_wpa_ie(struct adapter *padapter)
1449{
1450}
1451
1452static void update_bcn_wmm_ie(struct adapter *padapter)
1453{
1454}
1455
1456static void update_bcn_wps_ie(struct adapter *padapter)
1457{
1458 u8 *pwps_ie = NULL;
1459 u8 *pwps_ie_src;
1460 u8 *premainder_ie;
1461 u8 *pbackup_remainder_ie = NULL;
1462
1463 uint wps_ielen = 0, wps_offset, remainder_ielen;
1464 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1465 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1466 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1467 struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1468 unsigned char *ie = pnetwork->ies;
1469 u32 ielen = pnetwork->ie_length;
1470
1471 pwps_ie = rtw_get_wps_ie(
1472 ie + _FIXED_IE_LENGTH_,
1473 ielen - _FIXED_IE_LENGTH_,
1474 NULL,
1475 &wps_ielen
1476 );
1477
1478 if (!pwps_ie || wps_ielen == 0)
1479 return;
1480
1481 pwps_ie_src = pmlmepriv->wps_beacon_ie;
1482 if (!pwps_ie_src)
1483 return;
1484
1485 wps_offset = (uint)(pwps_ie - ie);
1486
1487 premainder_ie = pwps_ie + wps_ielen;
1488
1489 remainder_ielen = ielen - wps_offset - wps_ielen;
1490
1491 if (remainder_ielen > 0) {
1492 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
1493 if (pbackup_remainder_ie)
1494 memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
1495 }
1496
1497 wps_ielen = (uint)pwps_ie_src[1];
1498 if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
1499 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
1500 pwps_ie += (wps_ielen+2);
1501
1502 if (pbackup_remainder_ie)
1503 memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
1504
1505
1506 pnetwork->ie_length = wps_offset + (wps_ielen + 2) + remainder_ielen;
1507 }
1508
1509 kfree(pbackup_remainder_ie);
1510}
1511
1512static void update_bcn_p2p_ie(struct adapter *padapter)
1513{
1514}
1515
1516static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui)
1517{
1518 if (!memcmp(RTW_WPA_OUI, oui, 4))
1519 update_bcn_wpa_ie(padapter);
1520
1521 else if (!memcmp(WMM_OUI, oui, 4))
1522 update_bcn_wmm_ie(padapter);
1523
1524 else if (!memcmp(WPS_OUI, oui, 4))
1525 update_bcn_wps_ie(padapter);
1526
1527 else if (!memcmp(P2P_OUI, oui, 4))
1528 update_bcn_p2p_ie(padapter);
1529}
1530
1531void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx)
1532{
1533 struct mlme_priv *pmlmepriv;
1534 struct mlme_ext_priv *pmlmeext;
1535
1536
1537 if (!padapter)
1538 return;
1539
1540 pmlmepriv = &(padapter->mlmepriv);
1541 pmlmeext = &(padapter->mlmeextpriv);
1542
1543
1544 if (!pmlmeext->bstart_bss)
1545 return;
1546
1547 spin_lock_bh(&pmlmepriv->bcn_update_lock);
1548
1549 switch (ie_id) {
1550 case 0xFF:
1551
1552 update_bcn_fixed_ie(padapter);
1553
1554 break;
1555
1556 case WLAN_EID_TIM:
1557
1558 update_BCNTIM(padapter);
1559
1560 break;
1561
1562 case WLAN_EID_ERP_INFO:
1563
1564 update_bcn_erpinfo_ie(padapter);
1565
1566 break;
1567
1568 case WLAN_EID_HT_CAPABILITY:
1569
1570 update_bcn_htcap_ie(padapter);
1571
1572 break;
1573
1574 case WLAN_EID_RSN:
1575
1576 update_bcn_rsn_ie(padapter);
1577
1578 break;
1579
1580 case WLAN_EID_HT_OPERATION:
1581
1582 update_bcn_htinfo_ie(padapter);
1583
1584 break;
1585
1586 case WLAN_EID_VENDOR_SPECIFIC:
1587
1588 update_bcn_vendor_spec_ie(padapter, oui);
1589
1590 break;
1591
1592 default:
1593 break;
1594 }
1595
1596 pmlmepriv->update_bcn = true;
1597
1598 spin_unlock_bh(&pmlmepriv->bcn_update_lock);
1599
1600 if (tx) {
1601
1602 set_tx_beacon_cmd(padapter);
1603 }
1604}
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618static int rtw_ht_operation_update(struct adapter *padapter)
1619{
1620 u16 cur_op_mode, new_op_mode;
1621 int op_mode_changes = 0;
1622 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1623 struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
1624
1625 if (pmlmepriv->htpriv.ht_option)
1626 return 0;
1627
1628 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
1629 && pmlmepriv->num_sta_ht_no_gf) {
1630 pmlmepriv->ht_op_mode |=
1631 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1632 op_mode_changes++;
1633 } else if ((pmlmepriv->ht_op_mode &
1634 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
1635 pmlmepriv->num_sta_ht_no_gf == 0) {
1636 pmlmepriv->ht_op_mode &=
1637 ~IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1638 op_mode_changes++;
1639 }
1640
1641 if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1642 (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) {
1643 pmlmepriv->ht_op_mode |= IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1644 op_mode_changes++;
1645 } else if ((pmlmepriv->ht_op_mode &
1646 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1647 (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) {
1648 pmlmepriv->ht_op_mode &=
1649 ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1650 op_mode_changes++;
1651 }
1652
1653
1654
1655
1656
1657 new_op_mode = 0;
1658 if (pmlmepriv->num_sta_no_ht ||
1659 (pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
1660 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
1661 else if (
1662 (le16_to_cpu(phtpriv_ap->ht_cap.cap_info) & IEEE80211_HT_CAP_SUP_WIDTH)
1663 && pmlmepriv->num_sta_ht_20mhz)
1664 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
1665 else if (pmlmepriv->olbc_ht)
1666 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER;
1667 else
1668 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
1669
1670 cur_op_mode = pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_PROTECTION;
1671 if (cur_op_mode != new_op_mode) {
1672 pmlmepriv->ht_op_mode &= ~IEEE80211_HT_OP_MODE_PROTECTION;
1673 pmlmepriv->ht_op_mode |= new_op_mode;
1674 op_mode_changes++;
1675 }
1676
1677 return op_mode_changes;
1678}
1679
1680void associated_clients_update(struct adapter *padapter, u8 updated)
1681{
1682
1683 if (updated) {
1684 struct list_head *phead, *plist;
1685 struct sta_info *psta = NULL;
1686 struct sta_priv *pstapriv = &padapter->stapriv;
1687
1688 spin_lock_bh(&pstapriv->asoc_list_lock);
1689
1690 phead = &pstapriv->asoc_list;
1691
1692 list_for_each(plist, phead) {
1693 psta = list_entry(plist, struct sta_info, asoc_list);
1694
1695 VCS_update(padapter, psta);
1696 }
1697
1698 spin_unlock_bh(&pstapriv->asoc_list_lock);
1699 }
1700}
1701
1702
1703void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta)
1704{
1705 u8 beacon_updated = false;
1706 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1707 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1708
1709 if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) {
1710 if (!psta->no_short_preamble_set) {
1711 psta->no_short_preamble_set = 1;
1712
1713 pmlmepriv->num_sta_no_short_preamble++;
1714
1715 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1716 (pmlmepriv->num_sta_no_short_preamble == 1)) {
1717 beacon_updated = true;
1718 update_beacon(padapter, 0xFF, NULL, true);
1719 }
1720 }
1721 } else {
1722 if (psta->no_short_preamble_set) {
1723 psta->no_short_preamble_set = 0;
1724
1725 pmlmepriv->num_sta_no_short_preamble--;
1726
1727 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1728 (pmlmepriv->num_sta_no_short_preamble == 0)) {
1729 beacon_updated = true;
1730 update_beacon(padapter, 0xFF, NULL, true);
1731 }
1732 }
1733 }
1734
1735 if (psta->flags & WLAN_STA_NONERP) {
1736 if (!psta->nonerp_set) {
1737 psta->nonerp_set = 1;
1738
1739 pmlmepriv->num_sta_non_erp++;
1740
1741 if (pmlmepriv->num_sta_non_erp == 1) {
1742 beacon_updated = true;
1743 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1744 }
1745 }
1746 } else {
1747 if (psta->nonerp_set) {
1748 psta->nonerp_set = 0;
1749
1750 pmlmepriv->num_sta_non_erp--;
1751
1752 if (pmlmepriv->num_sta_non_erp == 0) {
1753 beacon_updated = true;
1754 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1755 }
1756 }
1757 }
1758
1759 if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) {
1760 if (!psta->no_short_slot_time_set) {
1761 psta->no_short_slot_time_set = 1;
1762
1763 pmlmepriv->num_sta_no_short_slot_time++;
1764
1765 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1766 (pmlmepriv->num_sta_no_short_slot_time == 1)) {
1767 beacon_updated = true;
1768 update_beacon(padapter, 0xFF, NULL, true);
1769 }
1770 }
1771 } else {
1772 if (psta->no_short_slot_time_set) {
1773 psta->no_short_slot_time_set = 0;
1774
1775 pmlmepriv->num_sta_no_short_slot_time--;
1776
1777 if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1778 (pmlmepriv->num_sta_no_short_slot_time == 0)) {
1779 beacon_updated = true;
1780 update_beacon(padapter, 0xFF, NULL, true);
1781 }
1782 }
1783 }
1784
1785 if (psta->flags & WLAN_STA_HT) {
1786 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
1787
1788 if (psta->no_ht_set) {
1789 psta->no_ht_set = 0;
1790 pmlmepriv->num_sta_no_ht--;
1791 }
1792
1793 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) {
1794 if (!psta->no_ht_gf_set) {
1795 psta->no_ht_gf_set = 1;
1796 pmlmepriv->num_sta_ht_no_gf++;
1797 }
1798 }
1799
1800 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) {
1801 if (!psta->ht_20mhz_set) {
1802 psta->ht_20mhz_set = 1;
1803 pmlmepriv->num_sta_ht_20mhz++;
1804 }
1805 }
1806
1807 } else {
1808 if (!psta->no_ht_set) {
1809 psta->no_ht_set = 1;
1810 pmlmepriv->num_sta_no_ht++;
1811 }
1812 }
1813
1814 if (rtw_ht_operation_update(padapter) > 0) {
1815 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1816 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1817 }
1818
1819
1820 associated_clients_update(padapter, beacon_updated);
1821}
1822
1823u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta)
1824{
1825 u8 beacon_updated = false;
1826 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1827 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1828
1829 if (!psta)
1830 return beacon_updated;
1831
1832 if (psta->no_short_preamble_set) {
1833 psta->no_short_preamble_set = 0;
1834 pmlmepriv->num_sta_no_short_preamble--;
1835 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1836 && pmlmepriv->num_sta_no_short_preamble == 0){
1837 beacon_updated = true;
1838 update_beacon(padapter, 0xFF, NULL, true);
1839 }
1840 }
1841
1842 if (psta->nonerp_set) {
1843 psta->nonerp_set = 0;
1844 pmlmepriv->num_sta_non_erp--;
1845 if (pmlmepriv->num_sta_non_erp == 0) {
1846 beacon_updated = true;
1847 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1848 }
1849 }
1850
1851 if (psta->no_short_slot_time_set) {
1852 psta->no_short_slot_time_set = 0;
1853 pmlmepriv->num_sta_no_short_slot_time--;
1854 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1855 && pmlmepriv->num_sta_no_short_slot_time == 0){
1856 beacon_updated = true;
1857 update_beacon(padapter, 0xFF, NULL, true);
1858 }
1859 }
1860
1861 if (psta->no_ht_gf_set) {
1862 psta->no_ht_gf_set = 0;
1863 pmlmepriv->num_sta_ht_no_gf--;
1864 }
1865
1866 if (psta->no_ht_set) {
1867 psta->no_ht_set = 0;
1868 pmlmepriv->num_sta_no_ht--;
1869 }
1870
1871 if (psta->ht_20mhz_set) {
1872 psta->ht_20mhz_set = 0;
1873 pmlmepriv->num_sta_ht_20mhz--;
1874 }
1875
1876 if (rtw_ht_operation_update(padapter) > 0) {
1877 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1878 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1879 }
1880
1881 return beacon_updated;
1882}
1883
1884u8 ap_free_sta(
1885 struct adapter *padapter,
1886 struct sta_info *psta,
1887 bool active,
1888 u16 reason
1889)
1890{
1891 u8 beacon_updated = false;
1892
1893 if (!psta)
1894 return beacon_updated;
1895
1896 if (active) {
1897
1898 send_delba(padapter, 0, psta->hwaddr);
1899
1900
1901 send_delba(padapter, 1, psta->hwaddr);
1902
1903 issue_deauth(padapter, psta->hwaddr, reason);
1904 }
1905
1906 psta->htpriv.agg_enable_bitmap = 0x0;
1907 psta->htpriv.candidate_tid_bitmap = 0x0;
1908
1909
1910
1911
1912 rtw_clearstakey_cmd(padapter, psta, true);
1913
1914 spin_lock_bh(&psta->lock);
1915 psta->state &= ~_FW_LINKED;
1916 spin_unlock_bh(&psta->lock);
1917
1918 rtw_cfg80211_indicate_sta_disassoc(padapter, psta->hwaddr, reason);
1919
1920 report_del_sta_event(padapter, psta->hwaddr, reason);
1921
1922 beacon_updated = bss_cap_update_on_sta_leave(padapter, psta);
1923
1924 rtw_free_stainfo(padapter, psta);
1925
1926 return beacon_updated;
1927}
1928
1929void rtw_sta_flush(struct adapter *padapter)
1930{
1931 struct list_head *phead, *plist, *tmp;
1932 struct sta_info *psta = NULL;
1933 struct sta_priv *pstapriv = &padapter->stapriv;
1934 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1935 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1936 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1937
1938 if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
1939 return;
1940
1941 spin_lock_bh(&pstapriv->asoc_list_lock);
1942 phead = &pstapriv->asoc_list;
1943
1944 list_for_each_safe(plist, tmp, phead) {
1945 psta = list_entry(plist, struct sta_info, asoc_list);
1946
1947 list_del_init(&psta->asoc_list);
1948 pstapriv->asoc_list_cnt--;
1949
1950
1951 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
1952
1953 }
1954 spin_unlock_bh(&pstapriv->asoc_list_lock);
1955
1956 issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
1957
1958 associated_clients_update(padapter, true);
1959}
1960
1961
1962void sta_info_update(struct adapter *padapter, struct sta_info *psta)
1963{
1964 int flags = psta->flags;
1965 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1966
1967
1968 if (WLAN_STA_WME & flags)
1969 psta->qos_option = 1;
1970 else
1971 psta->qos_option = 0;
1972
1973 if (pmlmepriv->qospriv.qos_option == 0)
1974 psta->qos_option = 0;
1975
1976
1977 if (WLAN_STA_HT & flags) {
1978 psta->htpriv.ht_option = true;
1979 psta->qos_option = 1;
1980 } else {
1981 psta->htpriv.ht_option = false;
1982 }
1983
1984 if (!pmlmepriv->htpriv.ht_option)
1985 psta->htpriv.ht_option = false;
1986
1987 update_sta_info_apmode(padapter, psta);
1988}
1989
1990
1991void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta)
1992{
1993 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1994 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1995
1996 if (psta->state & _FW_LINKED) {
1997 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
1998
1999
2000 add_RATid(padapter, psta, 0);
2001 }
2002}
2003
2004void rtw_ap_restore_network(struct adapter *padapter)
2005{
2006 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2007 struct sta_priv *pstapriv = &padapter->stapriv;
2008 struct sta_info *psta;
2009 struct security_priv *psecuritypriv = &(padapter->securitypriv);
2010 struct list_head *phead, *plist;
2011 u8 chk_alive_num = 0;
2012 char chk_alive_list[NUM_STA];
2013 int i;
2014
2015 rtw_setopmode_cmd(padapter, Ndis802_11APMode, false);
2016
2017 set_channel_bwmode(
2018 padapter,
2019 pmlmeext->cur_channel,
2020 pmlmeext->cur_ch_offset,
2021 pmlmeext->cur_bwmode
2022 );
2023
2024 start_bss_network(padapter);
2025
2026 if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
2027 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
2028
2029 rtw_set_key(
2030 padapter,
2031 psecuritypriv,
2032 psecuritypriv->dot118021XGrpKeyid,
2033 0,
2034 false
2035 );
2036 }
2037
2038 spin_lock_bh(&pstapriv->asoc_list_lock);
2039
2040 phead = &pstapriv->asoc_list;
2041 list_for_each(plist, phead) {
2042 int stainfo_offset;
2043
2044 psta = list_entry(plist, struct sta_info, asoc_list);
2045
2046 stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
2047 if (stainfo_offset_valid(stainfo_offset))
2048 chk_alive_list[chk_alive_num++] = stainfo_offset;
2049 }
2050
2051 spin_unlock_bh(&pstapriv->asoc_list_lock);
2052
2053 for (i = 0; i < chk_alive_num; i++) {
2054 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
2055
2056 if (!psta)
2057 continue;
2058
2059 if (psta->state & _FW_LINKED) {
2060 rtw_sta_media_status_rpt(padapter, psta, 1);
2061 Update_RA_Entry(padapter, psta);
2062
2063
2064 if ((psecuritypriv->dot11PrivacyAlgrthm == _TKIP_) ||
2065 (psecuritypriv->dot11PrivacyAlgrthm == _AES_)) {
2066 rtw_setstakey_cmd(padapter, psta, true, false);
2067 }
2068 }
2069 }
2070}
2071
2072void start_ap_mode(struct adapter *padapter)
2073{
2074 int i;
2075 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2076 struct sta_priv *pstapriv = &padapter->stapriv;
2077 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2078 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2079
2080 pmlmepriv->update_bcn = false;
2081
2082
2083 pmlmeext->bstart_bss = false;
2084
2085 pmlmepriv->num_sta_non_erp = 0;
2086
2087 pmlmepriv->num_sta_no_short_slot_time = 0;
2088
2089 pmlmepriv->num_sta_no_short_preamble = 0;
2090
2091 pmlmepriv->num_sta_ht_no_gf = 0;
2092 pmlmepriv->num_sta_no_ht = 0;
2093 pmlmepriv->num_sta_ht_20mhz = 0;
2094
2095 pmlmepriv->olbc = false;
2096
2097 pmlmepriv->olbc_ht = false;
2098
2099 pmlmepriv->ht_op_mode = 0;
2100
2101 for (i = 0; i < NUM_STA; i++)
2102 pstapriv->sta_aid[i] = NULL;
2103
2104 pmlmepriv->wps_beacon_ie = NULL;
2105 pmlmepriv->wps_probe_resp_ie = NULL;
2106 pmlmepriv->wps_assoc_resp_ie = NULL;
2107
2108 pmlmepriv->p2p_beacon_ie = NULL;
2109 pmlmepriv->p2p_probe_resp_ie = NULL;
2110
2111
2112 INIT_LIST_HEAD(&(pacl_list->acl_node_q.queue));
2113 pacl_list->num = 0;
2114 pacl_list->mode = 0;
2115 for (i = 0; i < NUM_ACL; i++) {
2116 INIT_LIST_HEAD(&pacl_list->aclnode[i].list);
2117 pacl_list->aclnode[i].valid = false;
2118 }
2119}
2120
2121void stop_ap_mode(struct adapter *padapter)
2122{
2123 struct list_head *phead, *plist, *tmp;
2124 struct rtw_wlan_acl_node *paclnode;
2125 struct sta_info *psta = NULL;
2126 struct sta_priv *pstapriv = &padapter->stapriv;
2127 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2128 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2129 struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2130 struct __queue *pacl_node_q = &pacl_list->acl_node_q;
2131
2132 pmlmepriv->update_bcn = false;
2133 pmlmeext->bstart_bss = false;
2134
2135
2136 memset(
2137 (unsigned char *)&padapter->securitypriv,
2138 0,
2139 sizeof(struct security_priv)
2140 );
2141 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
2142 padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
2143
2144
2145 spin_lock_bh(&(pacl_node_q->lock));
2146 phead = get_list_head(pacl_node_q);
2147 list_for_each_safe(plist, tmp, phead) {
2148 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
2149
2150 if (paclnode->valid) {
2151 paclnode->valid = false;
2152
2153 list_del_init(&paclnode->list);
2154
2155 pacl_list->num--;
2156 }
2157 }
2158 spin_unlock_bh(&(pacl_node_q->lock));
2159
2160 rtw_sta_flush(padapter);
2161
2162
2163 rtw_free_all_stainfo(padapter);
2164
2165 psta = rtw_get_bcmc_stainfo(padapter);
2166 rtw_free_stainfo(padapter, psta);
2167
2168 rtw_init_bcmc_stainfo(padapter);
2169
2170 rtw_free_mlme_priv_ie_data(pmlmepriv);
2171
2172 rtw_btcoex_MediaStatusNotify(padapter, 0);
2173}
2174
