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