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