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