1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #define _RTW_TDLS_C_
16
17 #include <drv_types.h>
18 #include <hal_data.h>
19
20 #ifdef CONFIG_TDLS
21 #define ONE_SEC 1000 /* 1000 ms */
22
23 extern unsigned char MCS_rate_2R[16];
24 extern unsigned char MCS_rate_1R[16];
25
rtw_tdls_set_link_established(_adapter * adapter,bool en)26 inline void rtw_tdls_set_link_established(_adapter *adapter, bool en)
27 {
28 adapter->tdlsinfo.link_established = en;
29 rtw_mi_update_iface_status(&(adapter->mlmepriv), 0);
30 }
31
rtw_reset_tdls_info(_adapter * padapter)32 void rtw_reset_tdls_info(_adapter *padapter)
33 {
34 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
35
36 ptdlsinfo->ap_prohibited = _FALSE;
37
38 /* For TDLS channel switch, currently we only allow it to work in wifi logo test mode */
39 if (padapter->registrypriv.wifi_spec == 1)
40 ptdlsinfo->ch_switch_prohibited = _FALSE;
41 else
42 ptdlsinfo->ch_switch_prohibited = _TRUE;
43
44 rtw_tdls_set_link_established(padapter, _FALSE);
45 ptdlsinfo->sta_cnt = 0;
46 ptdlsinfo->sta_maximum = _FALSE;
47
48 #ifdef CONFIG_TDLS_CH_SW
49 ptdlsinfo->chsw_info.ch_sw_state = TDLS_STATE_NONE;
50 ATOMIC_SET(&ptdlsinfo->chsw_info.chsw_on, _FALSE);
51 ptdlsinfo->chsw_info.off_ch_num = 0;
52 ptdlsinfo->chsw_info.ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
53 ptdlsinfo->chsw_info.cur_time = 0;
54 ptdlsinfo->chsw_info.delay_switch_back = _FALSE;
55 ptdlsinfo->chsw_info.dump_stack = _FALSE;
56 #endif
57
58 ptdlsinfo->ch_sensing = 0;
59 ptdlsinfo->watchdog_count = 0;
60 ptdlsinfo->dev_discovered = _FALSE;
61
62 #ifdef CONFIG_WFD
63 ptdlsinfo->wfd_info = &padapter->wfd_info;
64 #endif
65
66 ptdlsinfo->tdls_sctx = NULL;
67 }
68
rtw_init_tdls_info(_adapter * padapter)69 int rtw_init_tdls_info(_adapter *padapter)
70 {
71 int res = _SUCCESS;
72 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
73
74 rtw_reset_tdls_info(padapter);
75
76 #ifdef CONFIG_TDLS_DRIVER_SETUP
77 ptdlsinfo->driver_setup = _TRUE;
78 #else
79 ptdlsinfo->driver_setup = _FALSE;
80 #endif /* CONFIG_TDLS_DRIVER_SETUP */
81
82 _rtw_spinlock_init(&ptdlsinfo->cmd_lock);
83 _rtw_spinlock_init(&ptdlsinfo->hdl_lock);
84
85 return res;
86
87 }
88
rtw_free_tdls_info(struct tdls_info * ptdlsinfo)89 void rtw_free_tdls_info(struct tdls_info *ptdlsinfo)
90 {
91 _rtw_spinlock_free(&ptdlsinfo->cmd_lock);
92 _rtw_spinlock_free(&ptdlsinfo->hdl_lock);
93
94 _rtw_memset(ptdlsinfo, 0, sizeof(struct tdls_info));
95
96 }
97
rtw_free_all_tdls_sta(_adapter * padapter,u8 enqueue_cmd)98 void rtw_free_all_tdls_sta(_adapter *padapter, u8 enqueue_cmd)
99 {
100 struct sta_priv *pstapriv = &padapter->stapriv;
101 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
102 _irqL irqL;
103 _list *plist, *phead;
104 s32 index;
105 struct sta_info *psta = NULL;
106 struct sta_info *ptdls_sta[NUM_STA];
107 u8 empty_hwaddr[ETH_ALEN] = { 0x00 };
108
109 _rtw_memset(ptdls_sta, 0x00, sizeof(ptdls_sta));
110
111 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
112 for (index = 0; index < NUM_STA; index++) {
113 phead = &(pstapriv->sta_hash[index]);
114 plist = get_next(phead);
115
116 while (rtw_end_of_queue_search(phead, plist) == _FALSE) {
117 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
118
119 plist = get_next(plist);
120
121 if (psta->tdls_sta_state != TDLS_STATE_NONE)
122 ptdls_sta[index] = psta;
123 }
124 }
125 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
126
127 for (index = 0; index < NUM_STA; index++) {
128 if (ptdls_sta[index]) {
129 struct TDLSoption_param tdls_param;
130
131 psta = ptdls_sta[index];
132
133 RTW_INFO("Do tear down to "MAC_FMT" by enqueue_cmd = %d\n", MAC_ARG(psta->cmn.mac_addr), enqueue_cmd);
134
135 _rtw_memcpy(&(tdls_param.addr), psta->cmn.mac_addr, ETH_ALEN);
136 tdls_param.option = TDLS_TEARDOWN_STA_NO_WAIT;
137 tdls_hdl(padapter, (unsigned char *)&(tdls_param));
138
139 rtw_tdls_teardown_pre_hdl(padapter, psta);
140
141 if (enqueue_cmd == _TRUE)
142 rtw_tdls_cmd(padapter, psta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
143 else
144 {
145 tdls_param.option = TDLS_TEARDOWN_STA_LOCALLY_POST;
146 tdls_hdl(padapter, (unsigned char *)&(tdls_param));
147 }
148 }
149 }
150 }
151
check_ap_tdls_prohibited(u8 * pframe,u8 pkt_len)152 int check_ap_tdls_prohibited(u8 *pframe, u8 pkt_len)
153 {
154 u8 tdls_prohibited_bit = 0x40; /* bit(38); TDLS_prohibited */
155
156 if (pkt_len < 5)
157 return _FALSE;
158
159 pframe += 4;
160 if ((*pframe) & tdls_prohibited_bit)
161 return _TRUE;
162
163 return _FALSE;
164 }
165
check_ap_tdls_ch_switching_prohibited(u8 * pframe,u8 pkt_len)166 int check_ap_tdls_ch_switching_prohibited(u8 *pframe, u8 pkt_len)
167 {
168 u8 tdls_ch_swithcing_prohibited_bit = 0x80; /* bit(39); TDLS_channel_switching prohibited */
169
170 if (pkt_len < 5)
171 return _FALSE;
172
173 pframe += 4;
174 if ((*pframe) & tdls_ch_swithcing_prohibited_bit)
175 return _TRUE;
176
177 return _FALSE;
178 }
179
rtw_is_tdls_enabled(_adapter * padapter)180 u8 rtw_is_tdls_enabled(_adapter *padapter)
181 {
182 return padapter->registrypriv.en_tdls;
183 }
184
rtw_set_tdls_enable(_adapter * padapter,u8 enable)185 void rtw_set_tdls_enable(_adapter *padapter, u8 enable)
186 {
187 padapter->registrypriv.en_tdls = enable;
188 RTW_INFO("%s: en_tdls = %d\n", __func__, rtw_is_tdls_enabled(padapter));
189 }
190
rtw_enable_tdls_func(_adapter * padapter)191 void rtw_enable_tdls_func(_adapter *padapter)
192 {
193 if (rtw_is_tdls_enabled(padapter) == _TRUE)
194 return;
195
196 #if 0
197 #ifdef CONFIG_MCC_MODE
198 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC) == _TRUE) {
199 RTW_INFO("[TDLS] MCC is running, can't enable TDLS !\n");
200 return;
201 }
202 #endif
203 #endif
204 rtw_set_tdls_enable(padapter, _TRUE);
205 }
206
rtw_disable_tdls_func(_adapter * padapter,u8 enqueue_cmd)207 void rtw_disable_tdls_func(_adapter *padapter, u8 enqueue_cmd)
208 {
209 if (rtw_is_tdls_enabled(padapter) == _FALSE)
210 return;
211
212 rtw_free_all_tdls_sta(padapter, enqueue_cmd);
213 rtw_tdls_cmd(padapter, NULL, TDLS_RS_RCR);
214 rtw_reset_tdls_info(padapter);
215
216 rtw_set_tdls_enable(padapter, _FALSE);
217 }
218
rtw_is_tdls_sta_existed(_adapter * padapter)219 u8 rtw_is_tdls_sta_existed(_adapter *padapter)
220 {
221 struct sta_priv *pstapriv = &padapter->stapriv;
222 struct sta_info *psta;
223 int i = 0;
224 _irqL irqL;
225 _list *plist, *phead;
226 u8 ret = _FALSE;
227
228 if (rtw_is_tdls_enabled(padapter) == _FALSE)
229 return _FALSE;
230
231 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
232
233 for (i = 0; i < NUM_STA; i++) {
234 phead = &(pstapriv->sta_hash[i]);
235 plist = get_next(phead);
236 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
237 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
238 plist = get_next(plist);
239 if (psta->tdls_sta_state != TDLS_STATE_NONE) {
240 ret = _TRUE;
241 goto Exit;
242 }
243 }
244 }
245
246 Exit:
247
248 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
249
250 return ret;
251 }
252
rtw_tdls_is_setup_allowed(_adapter * padapter)253 u8 rtw_tdls_is_setup_allowed(_adapter *padapter)
254 {
255 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
256
257 if (is_client_associated_to_ap(padapter) == _FALSE)
258 return _FALSE;
259
260 if (ptdlsinfo->ap_prohibited == _TRUE)
261 return _FALSE;
262
263 return _TRUE;
264 }
265
266 #ifdef CONFIG_TDLS_CH_SW
rtw_tdls_is_chsw_allowed(_adapter * padapter)267 u8 rtw_tdls_is_chsw_allowed(_adapter *padapter)
268 {
269 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
270
271 if (ptdlsinfo->ch_switch_prohibited == _TRUE)
272 return _FALSE;
273
274 if (padapter->registrypriv.wifi_spec == 0)
275 return _FALSE;
276
277 return _TRUE;
278 }
279 #endif
280
_issue_nulldata_to_TDLS_peer_STA(_adapter * padapter,unsigned char * da,unsigned int power_mode,int wait_ms)281 int _issue_nulldata_to_TDLS_peer_STA(_adapter *padapter, unsigned char *da, unsigned int power_mode, int wait_ms)
282 {
283 int ret = _FAIL;
284 struct xmit_frame *pmgntframe;
285 struct pkt_attrib *pattrib;
286 unsigned char *pframe;
287 struct rtw_ieee80211_hdr *pwlanhdr;
288 unsigned short *fctrl, *qc;
289 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
290 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
291 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
292
293 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
294 if (pmgntframe == NULL)
295 goto exit;
296
297 pattrib = &pmgntframe->attrib;
298 update_mgntframe_attrib(padapter, pattrib);
299
300 pattrib->hdrlen += 2;
301 pattrib->qos_en = _TRUE;
302 pattrib->eosp = 1;
303 pattrib->ack_policy = 0;
304 pattrib->mdata = 0;
305 pattrib->retry_ctrl = _FALSE;
306
307 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
308
309 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
310 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
311
312 fctrl = &(pwlanhdr->frame_ctl);
313 *(fctrl) = 0;
314
315 if (power_mode)
316 SetPwrMgt(fctrl);
317
318 qc = (unsigned short *)(pframe + pattrib->hdrlen - 2);
319
320 SetPriority(qc, 7); /* Set priority to VO */
321
322 SetEOSP(qc, pattrib->eosp);
323
324 SetAckpolicy(qc, pattrib->ack_policy);
325
326 _rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
327 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
328 _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
329
330 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
331 pmlmeext->mgnt_seq++;
332 set_frame_sub_type(pframe, WIFI_QOS_DATA_NULL);
333
334 pframe += sizeof(struct rtw_ieee80211_hdr_3addr_qos);
335 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
336
337 pattrib->last_txcmdsz = pattrib->pktlen;
338
339 if (wait_ms)
340 ret = dump_mgntframe_and_wait_ack_timeout(padapter, pmgntframe, wait_ms);
341 else {
342 dump_mgntframe(padapter, pmgntframe);
343 ret = _SUCCESS;
344 }
345
346 exit:
347 return ret;
348
349 }
350
351 /*
352 *wait_ms == 0 means that there is no need to wait ack through C2H_CCX_TX_RPT
353 *wait_ms > 0 means you want to wait ack through C2H_CCX_TX_RPT, and the value of wait_ms means the interval between each TX
354 *try_cnt means the maximal TX count to try
355 */
issue_nulldata_to_TDLS_peer_STA(_adapter * padapter,unsigned char * da,unsigned int power_mode,int try_cnt,int wait_ms)356 int issue_nulldata_to_TDLS_peer_STA(_adapter *padapter, unsigned char *da, unsigned int power_mode, int try_cnt, int wait_ms)
357 {
358 int ret;
359 int i = 0;
360 systime start = rtw_get_current_time();
361 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
362 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
363
364 #if 0
365 psta = rtw_get_stainfo(&padapter->stapriv, da);
366 if (psta) {
367 if (power_mode)
368 rtw_hal_macid_sleep(padapter, psta->cmn.mac_id);
369 else
370 rtw_hal_macid_wakeup(padapter, psta->cmn.mac_id);
371 } else {
372 RTW_INFO(FUNC_ADPT_FMT ": Can't find sta info for " MAC_FMT ", skip macid %s!!\n",
373 FUNC_ADPT_ARG(padapter), MAC_ARG(da), power_mode ? "sleep" : "wakeup");
374 rtw_warn_on(1);
375 }
376 #endif
377
378 do {
379 ret = _issue_nulldata_to_TDLS_peer_STA(padapter, da, power_mode, wait_ms);
380
381 i++;
382
383 if (RTW_CANNOT_RUN(padapter))
384 break;
385
386 if (i < try_cnt && wait_ms > 0 && ret == _FAIL)
387 rtw_msleep_os(wait_ms);
388
389 } while ((i < try_cnt) && (ret == _FAIL || wait_ms == 0));
390
391 if (ret != _FAIL) {
392 ret = _SUCCESS;
393 #ifndef DBG_XMIT_ACK
394 goto exit;
395 #endif
396 }
397
398 if (try_cnt && wait_ms) {
399 if (da)
400 RTW_INFO(FUNC_ADPT_FMT" to "MAC_FMT", ch:%u%s, %d/%d in %u ms\n",
401 FUNC_ADPT_ARG(padapter), MAC_ARG(da), rtw_get_oper_ch(padapter),
402 ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
403 else
404 RTW_INFO(FUNC_ADPT_FMT", ch:%u%s, %d/%d in %u ms\n",
405 FUNC_ADPT_ARG(padapter), rtw_get_oper_ch(padapter),
406 ret == _SUCCESS ? ", acked" : "", i, try_cnt, rtw_get_passing_time_ms(start));
407 }
408 exit:
409 return ret;
410 }
411
412 /* TDLS encryption(if needed) will always be CCMP */
rtw_tdls_set_key(_adapter * padapter,struct sta_info * ptdls_sta)413 void rtw_tdls_set_key(_adapter *padapter, struct sta_info *ptdls_sta)
414 {
415 ptdls_sta->dot118021XPrivacy = _AES_;
416 rtw_setstakey_cmd(padapter, ptdls_sta, TDLS_KEY, _TRUE);
417 }
418
419 #ifdef CONFIG_80211N_HT
rtw_tdls_process_ht_cap(_adapter * padapter,struct sta_info * ptdls_sta,u8 * data,u8 Length)420 void rtw_tdls_process_ht_cap(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
421 {
422 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
423 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
424 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
425 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
426 u8 max_AMPDU_len, min_MPDU_spacing;
427 u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0;
428
429 /* Save HT capabilities in the sta object */
430 _rtw_memset(&ptdls_sta->htpriv.ht_cap, 0, sizeof(struct rtw_ieee80211_ht_cap));
431 if (data && Length >= sizeof(struct rtw_ieee80211_ht_cap)) {
432 ptdls_sta->flags |= WLAN_STA_HT;
433 ptdls_sta->flags |= WLAN_STA_WME;
434
435 _rtw_memcpy(&ptdls_sta->htpriv.ht_cap, data, sizeof(struct rtw_ieee80211_ht_cap));
436 } else {
437 ptdls_sta->flags &= ~WLAN_STA_HT;
438 return;
439 }
440
441 if (ptdls_sta->flags & WLAN_STA_HT) {
442 if (padapter->registrypriv.ht_enable == _TRUE && is_supported_ht(padapter->registrypriv.wireless_mode) ) {
443 ptdls_sta->htpriv.ht_option = _TRUE;
444 ptdls_sta->qos_option = _TRUE;
445 } else {
446 ptdls_sta->htpriv.ht_option = _FALSE;
447 ptdls_sta->qos_option = _FALSE;
448 }
449 }
450
451 /* HT related cap */
452 if (ptdls_sta->htpriv.ht_option) {
453 /* Check if sta supports rx ampdu */
454 if (padapter->registrypriv.ampdu_enable == 1)
455 ptdls_sta->htpriv.ampdu_enable = _TRUE;
456
457 /* AMPDU Parameters field */
458 /* Get MIN of MAX AMPDU Length Exp */
459 if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3) > (data[2] & 0x3))
460 max_AMPDU_len = (data[2] & 0x3);
461 else
462 max_AMPDU_len = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3);
463 /* Get MAX of MIN MPDU Start Spacing */
464 if ((pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) > (data[2] & 0x1c))
465 min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c);
466 else
467 min_MPDU_spacing = (data[2] & 0x1c);
468 ptdls_sta->htpriv.rx_ampdu_min_spacing = max_AMPDU_len | min_MPDU_spacing;
469
470 /* Check if sta support s Short GI 20M */
471 if ((phtpriv->sgi_20m == _TRUE) && (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SGI_20)))
472 ptdls_sta->htpriv.sgi_20m = _TRUE;
473
474 /* Check if sta support s Short GI 40M */
475 if ((phtpriv->sgi_40m == _TRUE) && (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)))
476 ptdls_sta->htpriv.sgi_40m = _TRUE;
477
478 /* Bwmode would still followed AP's setting */
479 if (ptdls_sta->htpriv.ht_cap.cap_info & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH)) {
480 if (padapter->mlmeextpriv.cur_bwmode >= CHANNEL_WIDTH_40)
481 ptdls_sta->cmn.bw_mode = CHANNEL_WIDTH_40;
482 ptdls_sta->htpriv.ch_offset = padapter->mlmeextpriv.cur_ch_offset;
483 }
484
485 /* Config LDPC Coding Capability */
486 if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX) && GET_HT_CAP_ELE_LDPC_CAP(data)) {
487 SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
488 RTW_INFO("Enable HT Tx LDPC!\n");
489 }
490 ptdls_sta->htpriv.ldpc_cap = cur_ldpc_cap;
491
492 /* Config STBC setting */
493 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) && GET_HT_CAP_ELE_RX_STBC(data)) {
494 SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
495 RTW_INFO("Enable HT Tx STBC!\n");
496 }
497 ptdls_sta->htpriv.stbc_cap = cur_stbc_cap;
498
499 #ifdef CONFIG_BEAMFORMING
500 /* Config Tx beamforming setting */
501 if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE) &&
502 GET_HT_CAP_TXBF_EXPLICIT_COMP_STEERING_CAP(data))
503 SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
504
505 if (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE) &&
506 GET_HT_CAP_TXBF_EXPLICIT_COMP_FEEDBACK_CAP(data))
507 SET_FLAG(cur_beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
508 ptdls_sta->htpriv.beamform_cap = cur_beamform_cap;
509 if (cur_beamform_cap)
510 RTW_INFO("Client HT Beamforming Cap = 0x%02X\n", cur_beamform_cap);
511 #endif /* CONFIG_BEAMFORMING */
512 }
513
514 }
515
rtw_tdls_set_ht_cap(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)516 u8 *rtw_tdls_set_ht_cap(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
517 {
518 rtw_ht_use_default_setting(padapter);
519
520 if (padapter->registrypriv.wifi_spec == 1) {
521 padapter->mlmepriv.htpriv.sgi_20m = _FALSE;
522 padapter->mlmepriv.htpriv.sgi_40m = _FALSE;
523 }
524
525 rtw_restructure_ht_ie(padapter, NULL, pframe, 0, &(pattrib->pktlen), padapter->mlmeextpriv.cur_channel);
526
527 return pframe + pattrib->pktlen;
528 }
529 #endif
530
531 #ifdef CONFIG_80211AC_VHT
rtw_tdls_process_vht_cap(_adapter * padapter,struct sta_info * ptdls_sta,u8 * data,u8 Length)532 void rtw_tdls_process_vht_cap(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
533 {
534 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
535 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
536 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
537 u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, tx_nss = 0;
538 u16 cur_beamform_cap = 0;
539 u8 *pcap_mcs;
540
541 _rtw_memset(&ptdls_sta->vhtpriv, 0, sizeof(struct vht_priv));
542 if (data && Length == 12) {
543 ptdls_sta->flags |= WLAN_STA_VHT;
544
545 _rtw_memcpy(ptdls_sta->vhtpriv.vht_cap, data, 12);
546
547 #if 0
548 if (elems.vht_op_mode_notify && elems.vht_op_mode_notify_len == 1)
549 _rtw_memcpy(&pstat->vhtpriv.vht_op_mode_notify, elems.vht_op_mode_notify, 1);
550 else /* for Frame without Operating Mode notify ie; default: 80M */
551 pstat->vhtpriv.vht_op_mode_notify = CHANNEL_WIDTH_80;
552 #else
553 ptdls_sta->vhtpriv.vht_op_mode_notify = CHANNEL_WIDTH_80;
554 #endif
555 } else {
556 ptdls_sta->flags &= ~WLAN_STA_VHT;
557 return;
558 }
559
560 if (ptdls_sta->flags & WLAN_STA_VHT) {
561 if (REGSTY_IS_11AC_ENABLE(&padapter->registrypriv)
562 && is_supported_vht(padapter->registrypriv.wireless_mode)
563 && (!rfctl->country_ent || COUNTRY_CHPLAN_EN_11AC(rfctl->country_ent))) {
564 ptdls_sta->vhtpriv.vht_option = _TRUE;
565 ptdls_sta->cmn.ra_info.is_vht_enable = _TRUE;
566 }
567 else
568 ptdls_sta->vhtpriv.vht_option = _FALSE;
569 }
570
571 /* B4 Rx LDPC */
572 if (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
573 GET_VHT_CAPABILITY_ELE_RX_LDPC(data)) {
574 SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
575 RTW_INFO("Current VHT LDPC Setting = %02X\n", cur_ldpc_cap);
576 }
577 ptdls_sta->vhtpriv.ldpc_cap = cur_ldpc_cap;
578
579 /* B5 Short GI for 80 MHz */
580 ptdls_sta->vhtpriv.sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(data) & pvhtpriv->sgi_80m) ? _TRUE : _FALSE;
581
582 /* B8 B9 B10 Rx STBC */
583 if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX) &&
584 GET_VHT_CAPABILITY_ELE_RX_STBC(data)) {
585 SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
586 RTW_INFO("Current VHT STBC Setting = %02X\n", cur_stbc_cap);
587 }
588 ptdls_sta->vhtpriv.stbc_cap = cur_stbc_cap;
589
590 #ifdef CONFIG_BEAMFORMING
591 /* B11 SU Beamformer Capable, the target supports Beamformer and we are Beamformee */
592 if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE) &&
593 GET_VHT_CAPABILITY_ELE_SU_BFEE(data))
594 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
595
596 /* B12 SU Beamformee Capable, the target supports Beamformee and we are Beamformer */
597 if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE) &&
598 GET_VHT_CAPABILITY_ELE_SU_BFER(data))
599 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
600 ptdls_sta->vhtpriv.beamform_cap = cur_beamform_cap;
601 ptdls_sta->cmn.bf_info.vht_beamform_cap = cur_beamform_cap;
602 if (cur_beamform_cap)
603 RTW_INFO("Current VHT Beamforming Setting = %02X\n", cur_beamform_cap);
604 #endif /*CONFIG_BEAMFORMING*/
605
606 /* B23 B24 B25 Maximum A-MPDU Length Exponent */
607 ptdls_sta->vhtpriv.ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(data);
608
609 pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(data);
610 tx_nss = GET_HAL_TX_NSS(padapter);
611 rtw_vht_nss_to_mcsmap(tx_nss, ptdls_sta->vhtpriv.vht_mcs_map, pcap_mcs);
612 ptdls_sta->vhtpriv.vht_highest_rate = rtw_get_vht_highest_rate(ptdls_sta->vhtpriv.vht_mcs_map);
613 }
614
rtw_tdls_process_vht_operation(_adapter * padapter,struct sta_info * ptdls_sta,u8 * data,u8 Length)615 void rtw_tdls_process_vht_operation(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
616 {
617 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
618 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
619 struct registry_priv *regsty = adapter_to_regsty(padapter);
620 u8 operation_bw = 0;
621
622 if (GET_VHT_OPERATION_ELE_CHL_WIDTH(data) >= 1) {
623
624 operation_bw = CHANNEL_WIDTH_80;
625
626 if (hal_is_bw_support(padapter, operation_bw) && REGSTY_IS_BW_5G_SUPPORT(regsty, operation_bw)
627 && (operation_bw <= pmlmeext->cur_bwmode))
628 ptdls_sta->cmn.bw_mode = operation_bw;
629 else
630 ptdls_sta->cmn.bw_mode = pmlmeext->cur_bwmode;
631 } else
632 ptdls_sta->cmn.bw_mode = pmlmeext->cur_bwmode;
633 }
634
rtw_tdls_process_vht_op_mode_notify(_adapter * padapter,struct sta_info * ptdls_sta,u8 * data,u8 Length)635 void rtw_tdls_process_vht_op_mode_notify(_adapter *padapter, struct sta_info *ptdls_sta, u8 *data, u8 Length)
636 {
637 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
638 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
639 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
640 struct registry_priv *regsty = adapter_to_regsty(padapter);
641 u8 target_bw;
642 u8 target_rxss, current_rxss;
643
644 if (pvhtpriv->vht_option == _FALSE)
645 return;
646
647 target_bw = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(data);
648 target_rxss = (GET_VHT_OPERATING_MODE_FIELD_RX_NSS(data) + 1);
649
650 if (hal_is_bw_support(padapter, target_bw) && REGSTY_IS_BW_5G_SUPPORT(regsty, target_bw)
651 && (target_bw <= pmlmeext->cur_bwmode))
652 ptdls_sta->cmn.bw_mode = target_bw;
653 else
654 ptdls_sta->cmn.bw_mode = pmlmeext->cur_bwmode;
655
656 current_rxss = rtw_vht_mcsmap_to_nss(ptdls_sta->vhtpriv.vht_mcs_map);
657 if (target_rxss != current_rxss) {
658 u8 vht_mcs_map[2] = {};
659
660 rtw_vht_nss_to_mcsmap(target_rxss, vht_mcs_map, ptdls_sta->vhtpriv.vht_mcs_map);
661 _rtw_memcpy(ptdls_sta->vhtpriv.vht_mcs_map, vht_mcs_map, 2);
662 }
663 }
664
rtw_tdls_set_aid(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)665 u8 *rtw_tdls_set_aid(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
666 {
667 return rtw_set_ie(pframe, EID_AID, 2, (u8 *)&(padapter->mlmepriv.cur_network.aid), &(pattrib->pktlen));
668 }
669
rtw_tdls_set_vht_cap(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)670 u8 *rtw_tdls_set_vht_cap(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
671 {
672 u32 ie_len = 0;
673
674 rtw_vht_use_default_setting(padapter);
675
676 ie_len = rtw_build_vht_cap_ie(padapter, pframe);
677 pattrib->pktlen += ie_len;
678
679 return pframe + ie_len;
680 }
681
rtw_tdls_set_vht_operation(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib,u8 channel)682 u8 *rtw_tdls_set_vht_operation(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 channel)
683 {
684 u32 ie_len = 0;
685
686 ie_len = rtw_build_vht_operation_ie(padapter, pframe, channel);
687 pattrib->pktlen += ie_len;
688
689 return pframe + ie_len;
690 }
691
rtw_tdls_set_vht_op_mode_notify(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib,u8 bw)692 u8 *rtw_tdls_set_vht_op_mode_notify(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 bw)
693 {
694 u32 ie_len = 0;
695
696 ie_len = rtw_build_vht_op_mode_notify_ie(padapter, pframe, bw);
697 pattrib->pktlen += ie_len;
698
699 return pframe + ie_len;
700 }
701 #endif
702
703
rtw_tdls_set_sup_ch(_adapter * adapter,u8 * pframe,struct pkt_attrib * pattrib)704 u8 *rtw_tdls_set_sup_ch(_adapter *adapter, u8 *pframe, struct pkt_attrib *pattrib)
705 {
706 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
707 u8 sup_ch[30 * 2] = {0x00}, ch_set_idx = 0, sup_ch_idx = 2;
708
709 while (ch_set_idx < rfctl->max_chan_nums && rfctl->channel_set[ch_set_idx].ChannelNum != 0) {
710 if (rfctl->channel_set[ch_set_idx].ChannelNum <= 14) {
711 /* TODO: fix 2.4G supported channel when channel doesn't start from 1 and continuous */
712 sup_ch[0] = 1; /* First channel number */
713 sup_ch[1] = rfctl->channel_set[ch_set_idx].ChannelNum; /* Number of channel */
714 } else {
715 sup_ch[sup_ch_idx++] = rfctl->channel_set[ch_set_idx].ChannelNum;
716 sup_ch[sup_ch_idx++] = 1;
717 }
718 ch_set_idx++;
719 }
720
721 return rtw_set_ie(pframe, _SUPPORTED_CH_IE_, sup_ch_idx, sup_ch, &(pattrib->pktlen));
722 }
723
rtw_tdls_set_rsnie(struct tdls_txmgmt * ptxmgmt,u8 * pframe,struct pkt_attrib * pattrib,int init,struct sta_info * ptdls_sta)724 u8 *rtw_tdls_set_rsnie(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, int init, struct sta_info *ptdls_sta)
725 {
726 u8 *p = NULL;
727 int len = 0;
728
729 if (ptxmgmt->len > 0)
730 p = rtw_get_ie(ptxmgmt->buf, _RSN_IE_2_, &len, ptxmgmt->len);
731
732 if (p != NULL)
733 return rtw_set_ie(pframe, _RSN_IE_2_, len, p + 2, &(pattrib->pktlen));
734 else if (init == _TRUE)
735 return rtw_set_ie(pframe, _RSN_IE_2_, sizeof(TDLS_RSNIE), TDLS_RSNIE, &(pattrib->pktlen));
736 else
737 return rtw_set_ie(pframe, _RSN_IE_2_, sizeof(ptdls_sta->TDLS_RSNIE), ptdls_sta->TDLS_RSNIE, &(pattrib->pktlen));
738 }
739
rtw_tdls_set_ext_cap(u8 * pframe,struct pkt_attrib * pattrib)740 u8 *rtw_tdls_set_ext_cap(u8 *pframe, struct pkt_attrib *pattrib)
741 {
742 return rtw_set_ie(pframe, WLAN_EID_EXT_CAP , sizeof(TDLS_EXT_CAPIE), TDLS_EXT_CAPIE, &(pattrib->pktlen));
743 }
744
rtw_tdls_set_qos_cap(u8 * pframe,struct pkt_attrib * pattrib)745 u8 *rtw_tdls_set_qos_cap(u8 *pframe, struct pkt_attrib *pattrib)
746 {
747 return rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, sizeof(TDLS_WMMIE), TDLS_WMMIE, &(pattrib->pktlen));
748 }
749
rtw_tdls_set_ftie(struct tdls_txmgmt * ptxmgmt,u8 * pframe,struct pkt_attrib * pattrib,u8 * ANonce,u8 * SNonce)750 u8 *rtw_tdls_set_ftie(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, u8 *ANonce, u8 *SNonce)
751 {
752 struct wpa_tdls_ftie FTIE = {0};
753 u8 *p = NULL;
754 int len = 0;
755
756 if (ptxmgmt->len > 0)
757 p = rtw_get_ie(ptxmgmt->buf, _FTIE_, &len, ptxmgmt->len);
758
759 if (p != NULL)
760 return rtw_set_ie(pframe, _FTIE_, len, p + 2, &(pattrib->pktlen));
761 else {
762 if (ANonce != NULL)
763 _rtw_memcpy(FTIE.Anonce, ANonce, WPA_NONCE_LEN);
764 if (SNonce != NULL)
765 _rtw_memcpy(FTIE.Snonce, SNonce, WPA_NONCE_LEN);
766
767 return rtw_set_ie(pframe, _FTIE_, TDLS_FTIE_DATA_LEN,
768 (u8 *)FTIE.data, &(pattrib->pktlen));
769 }
770 }
771
rtw_tdls_set_timeout_interval(struct tdls_txmgmt * ptxmgmt,u8 * pframe,struct pkt_attrib * pattrib,int init,struct sta_info * ptdls_sta)772 u8 *rtw_tdls_set_timeout_interval(struct tdls_txmgmt *ptxmgmt, u8 *pframe, struct pkt_attrib *pattrib, int init, struct sta_info *ptdls_sta)
773 {
774 u8 timeout_itvl[5]; /* set timeout interval to maximum value */
775 u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
776 u8 *p = NULL;
777 int len = 0;
778
779 if (ptxmgmt->len > 0)
780 p = rtw_get_ie(ptxmgmt->buf, _TIMEOUT_ITVL_IE_, &len, ptxmgmt->len);
781
782 if (p != NULL)
783 return rtw_set_ie(pframe, _TIMEOUT_ITVL_IE_, len, p + 2, &(pattrib->pktlen));
784 else {
785 /* Timeout interval */
786 timeout_itvl[0] = 0x02;
787 if (init == _TRUE)
788 _rtw_memcpy(timeout_itvl + 1, &timeout_interval, 4);
789 else
790 _rtw_memcpy(timeout_itvl + 1, (u8 *)(&ptdls_sta->TDLS_PeerKey_Lifetime), 4);
791
792 return rtw_set_ie(pframe, _TIMEOUT_ITVL_IE_, 5, timeout_itvl, &(pattrib->pktlen));
793 }
794 }
795
rtw_tdls_set_bss_coexist(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)796 u8 *rtw_tdls_set_bss_coexist(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
797 {
798 u8 iedata = 0;
799
800 if (padapter->mlmepriv.num_FortyMHzIntolerant > 0)
801 iedata |= BIT(2); /* 20 MHz BSS Width Request */
802
803 /* Information Bit should be set by TDLS test plan 5.9 */
804 iedata |= BIT(0);
805 return rtw_set_ie(pframe, EID_BSSCoexistence, 1, &iedata, &(pattrib->pktlen));
806 }
807
rtw_tdls_set_payload_type(u8 * pframe,struct pkt_attrib * pattrib)808 u8 *rtw_tdls_set_payload_type(u8 *pframe, struct pkt_attrib *pattrib)
809 {
810 u8 payload_type = 0x02;
811 return rtw_set_fixed_ie(pframe, 1, &(payload_type), &(pattrib->pktlen));
812 }
813
rtw_tdls_set_category(u8 * pframe,struct pkt_attrib * pattrib,u8 category)814 u8 *rtw_tdls_set_category(u8 *pframe, struct pkt_attrib *pattrib, u8 category)
815 {
816 return rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
817 }
818
rtw_tdls_set_action(u8 * pframe,struct pkt_attrib * pattrib,struct tdls_txmgmt * ptxmgmt)819 u8 *rtw_tdls_set_action(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
820 {
821 return rtw_set_fixed_ie(pframe, 1, &(ptxmgmt->action_code), &(pattrib->pktlen));
822 }
823
rtw_tdls_set_status_code(u8 * pframe,struct pkt_attrib * pattrib,struct tdls_txmgmt * ptxmgmt)824 u8 *rtw_tdls_set_status_code(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
825 {
826 return rtw_set_fixed_ie(pframe, 2, (u8 *)&(ptxmgmt->status_code), &(pattrib->pktlen));
827 }
828
rtw_tdls_set_dialog(u8 * pframe,struct pkt_attrib * pattrib,struct tdls_txmgmt * ptxmgmt)829 u8 *rtw_tdls_set_dialog(u8 *pframe, struct pkt_attrib *pattrib, struct tdls_txmgmt *ptxmgmt)
830 {
831 u8 dialogtoken = 1;
832 if (ptxmgmt->dialog_token)
833 return rtw_set_fixed_ie(pframe, 1, &(ptxmgmt->dialog_token), &(pattrib->pktlen));
834 else
835 return rtw_set_fixed_ie(pframe, 1, &(dialogtoken), &(pattrib->pktlen));
836 }
837
rtw_tdls_set_reg_class(u8 * pframe,struct pkt_attrib * pattrib,struct sta_info * ptdls_sta)838 u8 *rtw_tdls_set_reg_class(u8 *pframe, struct pkt_attrib *pattrib, struct sta_info *ptdls_sta)
839 {
840 u8 reg_class = 22;
841 return rtw_set_fixed_ie(pframe, 1, &(reg_class), &(pattrib->pktlen));
842 }
843
rtw_tdls_set_second_channel_offset(u8 * pframe,struct pkt_attrib * pattrib,u8 ch_offset)844 u8 *rtw_tdls_set_second_channel_offset(u8 *pframe, struct pkt_attrib *pattrib, u8 ch_offset)
845 {
846 return rtw_set_ie(pframe, EID_SecondaryChnlOffset , 1, &ch_offset, &(pattrib->pktlen));
847 }
848
rtw_tdls_set_capability(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)849 u8 *rtw_tdls_set_capability(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
850 {
851 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
852 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
853 u8 cap_from_ie[2] = {0};
854
855 _rtw_memcpy(cap_from_ie, rtw_get_capability_from_ie(pmlmeinfo->network.IEs), 2);
856
857 return rtw_set_fixed_ie(pframe, 2, cap_from_ie, &(pattrib->pktlen));
858 }
859
rtw_tdls_set_supported_rate(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)860 u8 *rtw_tdls_set_supported_rate(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
861 {
862 u8 bssrate[NDIS_802_11_LENGTH_RATES_EX];
863 int bssrate_len = 0;
864 u8 more_supportedrates = 0;
865
866 rtw_set_supported_rate(bssrate, (padapter->registrypriv.wireless_mode == WIRELESS_MODE_MAX) ? padapter->mlmeextpriv.cur_wireless_mode : padapter->registrypriv.wireless_mode);
867 bssrate_len = rtw_get_rateset_len(bssrate);
868
869 if (bssrate_len > 8) {
870 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &(pattrib->pktlen));
871 more_supportedrates = 1;
872 } else
873 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &(pattrib->pktlen));
874
875 /* extended supported rates */
876 if (more_supportedrates == 1)
877 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &(pattrib->pktlen));
878
879 return pframe;
880 }
881
rtw_tdls_set_sup_reg_class(u8 * pframe,struct pkt_attrib * pattrib)882 u8 *rtw_tdls_set_sup_reg_class(u8 *pframe, struct pkt_attrib *pattrib)
883 {
884 return rtw_set_ie(pframe, _SRC_IE_ , sizeof(TDLS_SRC), TDLS_SRC, &(pattrib->pktlen));
885 }
886
rtw_tdls_set_linkid(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib,u8 init)887 u8 *rtw_tdls_set_linkid(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib, u8 init)
888 {
889 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
890 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
891
892 u8 link_id_addr[18] = {0};
893
894 _rtw_memcpy(link_id_addr, get_my_bssid(&(pmlmeinfo->network)), 6);
895
896 if (init == _TRUE) {
897 _rtw_memcpy((link_id_addr + 6), pattrib->src, 6);
898 _rtw_memcpy((link_id_addr + 12), pattrib->dst, 6);
899 } else {
900 _rtw_memcpy((link_id_addr + 6), pattrib->dst, 6);
901 _rtw_memcpy((link_id_addr + 12), pattrib->src, 6);
902 }
903 return rtw_set_ie(pframe, _LINK_ID_IE_, 18, link_id_addr, &(pattrib->pktlen));
904 }
905
906 #ifdef CONFIG_TDLS_CH_SW
rtw_tdls_set_target_ch(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)907 u8 *rtw_tdls_set_target_ch(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
908 {
909 u8 target_ch = 1;
910 if (padapter->tdlsinfo.chsw_info.off_ch_num)
911 return rtw_set_fixed_ie(pframe, 1, &(padapter->tdlsinfo.chsw_info.off_ch_num), &(pattrib->pktlen));
912 else
913 return rtw_set_fixed_ie(pframe, 1, &(target_ch), &(pattrib->pktlen));
914 }
915
rtw_tdls_set_ch_sw(u8 * pframe,struct pkt_attrib * pattrib,struct sta_info * ptdls_sta)916 u8 *rtw_tdls_set_ch_sw(u8 *pframe, struct pkt_attrib *pattrib, struct sta_info *ptdls_sta)
917 {
918 u8 ch_switch_timing[4] = {0};
919 u16 switch_time = (ptdls_sta->ch_switch_time >= TDLS_CH_SWITCH_TIME * 1000) ?
920 ptdls_sta->ch_switch_time : TDLS_CH_SWITCH_TIME;
921 u16 switch_timeout = (ptdls_sta->ch_switch_timeout >= TDLS_CH_SWITCH_TIMEOUT * 1000) ?
922 ptdls_sta->ch_switch_timeout : TDLS_CH_SWITCH_TIMEOUT;
923
924 _rtw_memcpy(ch_switch_timing, &switch_time, 2);
925 _rtw_memcpy(ch_switch_timing + 2, &switch_timeout, 2);
926
927 return rtw_set_ie(pframe, _CH_SWITCH_TIMING_, 4, ch_switch_timing, &(pattrib->pktlen));
928 }
929
rtw_tdls_set_ch_sw_oper_control(_adapter * padapter,u8 enable)930 void rtw_tdls_set_ch_sw_oper_control(_adapter *padapter, u8 enable)
931 {
932 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
933 u8 bcn_early_case;
934
935 if (enable == _TRUE) {
936 #ifdef CONFIG_TDLS_CH_SW_V2
937 pHalData->ch_switch_offload = _TRUE;
938 #endif
939
940 #ifdef CONFIG_TDLS_CH_SW_BY_DRV
941 pHalData->ch_switch_offload = _FALSE;
942 #endif
943 bcn_early_case = TDLS_BCN_ERLY_ON;
944 }
945 else {
946 pHalData->ch_switch_offload = _FALSE;
947 bcn_early_case = TDLS_BCN_ERLY_OFF;
948 }
949
950 if (ATOMIC_READ(&padapter->tdlsinfo.chsw_info.chsw_on) != enable)
951 ATOMIC_SET(&padapter->tdlsinfo.chsw_info.chsw_on, enable);
952
953 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_EARLY_C2H_RPT, &enable);
954 rtw_hal_set_hwreg(padapter, HW_VAR_SET_DRV_ERLY_INT, &bcn_early_case);
955 RTW_INFO("[TDLS] %s Bcn Early C2H Report\n", (enable == _TRUE) ? "Start" : "Stop");
956 }
957
rtw_tdls_ch_sw_back_to_base_chnl(_adapter * padapter)958 void rtw_tdls_ch_sw_back_to_base_chnl(_adapter *padapter)
959 {
960 struct mlme_priv *pmlmepriv;
961 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
962
963 pmlmepriv = &padapter->mlmepriv;
964
965 if ((ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE) &&
966 (padapter->mlmeextpriv.cur_channel != rtw_get_oper_ch(padapter)))
967 rtw_tdls_cmd(padapter, pchsw_info->addr, TDLS_CH_SW_TO_BASE_CHNL_UNSOLICITED);
968 }
969
970 #ifndef CONFIG_TDLS_CH_SW_V2
rtw_tdls_chsw_oper_init(_adapter * padapter,u32 timeout_ms)971 static void rtw_tdls_chsw_oper_init(_adapter *padapter, u32 timeout_ms)
972 {
973 struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
974
975 rtw_sctx_init(chsw_sctx, timeout_ms);
976 }
977
rtw_tdls_chsw_oper_wait(_adapter * padapter)978 static int rtw_tdls_chsw_oper_wait(_adapter *padapter)
979 {
980 struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
981
982 return rtw_sctx_wait(chsw_sctx, __func__);
983 }
984
rtw_tdls_chsw_oper_done(_adapter * padapter)985 void rtw_tdls_chsw_oper_done(_adapter *padapter)
986 {
987 struct submit_ctx *chsw_sctx = &padapter->tdlsinfo.chsw_info.chsw_sctx;
988
989 rtw_sctx_done(&chsw_sctx);
990 }
991 #endif
992
rtw_tdls_do_ch_sw(_adapter * padapter,struct sta_info * ptdls_sta,u8 chnl_type,u8 channel,u8 channel_offset,u16 bwmode,u16 ch_switch_time)993 s32 rtw_tdls_do_ch_sw(_adapter *padapter, struct sta_info *ptdls_sta, u8 chnl_type, u8 channel, u8 channel_offset, u16 bwmode, u16 ch_switch_time)
994 {
995 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
996 u8 center_ch, chnl_offset80 = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
997 u32 ch_sw_time_start, ch_sw_time_spent, wait_time;
998 u8 take_care_iqk;
999 s32 ret = _FAIL;
1000
1001 ch_sw_time_start = rtw_systime_to_ms(rtw_get_current_time());
1002
1003 /* set mac_id sleep before channel switch */
1004 rtw_hal_macid_sleep(padapter, ptdls_sta->cmn.mac_id);
1005
1006 #if defined(CONFIG_TDLS_CH_SW_BY_DRV) || defined(CONFIG_TDLS_CH_SW_V2)
1007 set_channel_bwmode(padapter, channel, channel_offset, bwmode);
1008 ret = _SUCCESS;
1009 #else
1010 rtw_tdls_chsw_oper_init(padapter, TDLS_CH_SWITCH_OPER_OFFLOAD_TIMEOUT);
1011
1012 /* channel switch IOs offload to FW */
1013 if (rtw_hal_ch_sw_oper_offload(padapter, channel, channel_offset, bwmode) == _SUCCESS) {
1014 if (rtw_tdls_chsw_oper_wait(padapter) == _SUCCESS) {
1015 /* set channel and bw related variables in driver */
1016 _enter_critical_mutex(&(adapter_to_dvobj(padapter)->setch_mutex), NULL);
1017
1018 rtw_set_oper_ch(padapter, channel);
1019 rtw_set_oper_choffset(padapter, channel_offset);
1020 rtw_set_oper_bw(padapter, bwmode);
1021
1022 center_ch = rtw_get_center_ch(channel, bwmode, channel_offset);
1023 pHalData->current_channel = center_ch;
1024 pHalData->CurrentCenterFrequencyIndex1 = center_ch;
1025 pHalData->current_channel_bw = bwmode;
1026 pHalData->nCur40MhzPrimeSC = channel_offset;
1027
1028 if (bwmode == CHANNEL_WIDTH_80) {
1029 if (center_ch > channel)
1030 chnl_offset80 = HAL_PRIME_CHNL_OFFSET_LOWER;
1031 else if (center_ch < channel)
1032 chnl_offset80 = HAL_PRIME_CHNL_OFFSET_UPPER;
1033 else
1034 chnl_offset80 = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
1035 }
1036 pHalData->nCur80MhzPrimeSC = chnl_offset80;
1037
1038 pHalData->CurrentCenterFrequencyIndex1 = center_ch;
1039
1040 _exit_critical_mutex(&(adapter_to_dvobj(padapter)->setch_mutex), NULL);
1041
1042 rtw_hal_get_hwreg(padapter, HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO, &take_care_iqk);
1043 if (take_care_iqk == _TRUE)
1044 rtw_hal_ch_sw_iqk_info_restore(padapter, CH_SW_USE_CASE_TDLS);
1045
1046 ret = _SUCCESS;
1047 } else
1048 RTW_INFO("[TDLS] chsw oper wait fail !!\n");
1049 }
1050 #endif
1051
1052 if (ret == _SUCCESS) {
1053 ch_sw_time_spent = rtw_systime_to_ms(rtw_get_current_time()) - ch_sw_time_start;
1054 if (chnl_type == TDLS_CH_SW_OFF_CHNL) {
1055 if ((u32)ch_switch_time / 1000 > ch_sw_time_spent)
1056 wait_time = (u32)ch_switch_time / 1000 - ch_sw_time_spent;
1057 else
1058 wait_time = 0;
1059
1060 if (wait_time > 0)
1061 rtw_msleep_os(wait_time);
1062 }
1063 }
1064
1065 /* set mac_id wakeup after channel switch */
1066 rtw_hal_macid_wakeup(padapter, ptdls_sta->cmn.mac_id);
1067
1068 return ret;
1069 }
1070 #endif
1071
rtw_tdls_set_wmm_params(_adapter * padapter,u8 * pframe,struct pkt_attrib * pattrib)1072 u8 *rtw_tdls_set_wmm_params(_adapter *padapter, u8 *pframe, struct pkt_attrib *pattrib)
1073 {
1074 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1075 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1076 u8 wmm_param_ele[24] = {0};
1077
1078 if (&pmlmeinfo->WMM_param) {
1079 _rtw_memcpy(wmm_param_ele, WMM_PARA_OUI, 6);
1080 if (_rtw_memcmp(&pmlmeinfo->WMM_param, &wmm_param_ele[6], 18) == _TRUE)
1081 /* Use default WMM Param */
1082 _rtw_memcpy(wmm_param_ele + 6, (u8 *)&TDLS_WMM_PARAM_IE, sizeof(TDLS_WMM_PARAM_IE));
1083 else
1084 _rtw_memcpy(wmm_param_ele + 6, (u8 *)&pmlmeinfo->WMM_param, sizeof(pmlmeinfo->WMM_param));
1085 return rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, 24, wmm_param_ele, &(pattrib->pktlen));
1086 } else
1087 return pframe;
1088 }
1089
1090 #ifdef CONFIG_WFD
rtw_tdls_process_wfd_ie(struct tdls_info * ptdlsinfo,u8 * ptr,u8 length)1091 void rtw_tdls_process_wfd_ie(struct tdls_info *ptdlsinfo, u8 *ptr, u8 length)
1092 {
1093 u8 *wfd_ie;
1094 u32 wfd_ielen = 0;
1095
1096 if (!hal_chk_wl_func(tdls_info_to_adapter(ptdlsinfo), WL_FUNC_MIRACAST))
1097 return;
1098
1099 /* Try to get the TCP port information when receiving the negotiation response. */
1100
1101 wfd_ie = rtw_get_wfd_ie(ptr, length, NULL, &wfd_ielen);
1102 while (wfd_ie) {
1103 u8 *attr_content;
1104 u32 attr_contentlen = 0;
1105 int i;
1106
1107 RTW_INFO("[%s] WFD IE Found!!\n", __FUNCTION__);
1108 attr_content = rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, NULL, &attr_contentlen);
1109 if (attr_content && attr_contentlen) {
1110 ptdlsinfo->wfd_info->peer_rtsp_ctrlport = RTW_GET_BE16(attr_content + 2);
1111 RTW_INFO("[%s] Peer PORT NUM = %d\n", __FUNCTION__, ptdlsinfo->wfd_info->peer_rtsp_ctrlport);
1112 }
1113
1114 attr_content = rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_LOCAL_IP_ADDR, NULL, &attr_contentlen);
1115 if (attr_content && attr_contentlen) {
1116 _rtw_memcpy(ptdlsinfo->wfd_info->peer_ip_address, (attr_content + 1), 4);
1117 RTW_INFO("[%s] Peer IP = %02u.%02u.%02u.%02u\n", __FUNCTION__,
1118 ptdlsinfo->wfd_info->peer_ip_address[0], ptdlsinfo->wfd_info->peer_ip_address[1],
1119 ptdlsinfo->wfd_info->peer_ip_address[2], ptdlsinfo->wfd_info->peer_ip_address[3]);
1120 }
1121
1122 wfd_ie = rtw_get_wfd_ie(wfd_ie + wfd_ielen, (ptr + length) - (wfd_ie + wfd_ielen), NULL, &wfd_ielen);
1123 }
1124 }
1125
issue_tunneled_probe_req(_adapter * padapter)1126 int issue_tunneled_probe_req(_adapter *padapter)
1127 {
1128 struct xmit_frame *pmgntframe;
1129 struct pkt_attrib *pattrib;
1130 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1131 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1132 u8 baddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1133 struct tdls_txmgmt txmgmt;
1134 int ret = _FAIL;
1135
1136 RTW_INFO("[%s]\n", __FUNCTION__);
1137
1138 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1139 txmgmt.action_code = TUNNELED_PROBE_REQ;
1140
1141 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1142 if (pmgntframe == NULL)
1143 goto exit;
1144
1145 pattrib = &pmgntframe->attrib;
1146
1147 pmgntframe->frame_tag = DATA_FRAMETAG;
1148 pattrib->ether_type = 0x890d;
1149
1150 _rtw_memcpy(pattrib->dst, baddr, ETH_ALEN);
1151 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1152 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1153 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1154
1155 update_tdls_attrib(padapter, pattrib);
1156 pattrib->qsel = pattrib->priority;
1157 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
1158 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1159 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1160 goto exit;
1161 }
1162 dump_mgntframe(padapter, pmgntframe);
1163 ret = _SUCCESS;
1164 exit:
1165
1166 return ret;
1167 }
1168
issue_tunneled_probe_rsp(_adapter * padapter,union recv_frame * precv_frame)1169 int issue_tunneled_probe_rsp(_adapter *padapter, union recv_frame *precv_frame)
1170 {
1171 struct xmit_frame *pmgntframe;
1172 struct pkt_attrib *pattrib;
1173 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1174 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1175 struct tdls_txmgmt txmgmt;
1176 int ret = _FAIL;
1177
1178 RTW_INFO("[%s]\n", __FUNCTION__);
1179
1180 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1181 txmgmt.action_code = TUNNELED_PROBE_RSP;
1182
1183 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1184 if (pmgntframe == NULL)
1185 goto exit;
1186
1187 pattrib = &pmgntframe->attrib;
1188
1189 pmgntframe->frame_tag = DATA_FRAMETAG;
1190 pattrib->ether_type = 0x890d;
1191
1192 _rtw_memcpy(pattrib->dst, precv_frame->u.hdr.attrib.src, ETH_ALEN);
1193 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1194 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1195 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1196
1197 update_tdls_attrib(padapter, pattrib);
1198 pattrib->qsel = pattrib->priority;
1199 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
1200 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1201 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1202 goto exit;
1203 }
1204 dump_mgntframe(padapter, pmgntframe);
1205 ret = _SUCCESS;
1206 exit:
1207
1208 return ret;
1209 }
1210 #endif /* CONFIG_WFD */
1211
issue_tdls_setup_req(_adapter * padapter,struct tdls_txmgmt * ptxmgmt,int wait_ack)1212 int issue_tdls_setup_req(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, int wait_ack)
1213 {
1214 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
1215 struct xmit_frame *pmgntframe;
1216 struct pkt_attrib *pattrib;
1217 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1218 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1219 struct sta_priv *pstapriv = &padapter->stapriv;
1220 struct sta_info *ptdls_sta = NULL;
1221 _irqL irqL;
1222 int ret = _FAIL;
1223 /* Retry timer should be set at least 301 sec, using TPK_count counting 301 times. */
1224 u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
1225
1226 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1227
1228 if (rtw_tdls_is_setup_allowed(padapter) == _FALSE)
1229 goto exit;
1230
1231 if (IS_MCAST(ptxmgmt->peer))
1232 goto exit;
1233
1234 ptdls_sta = rtw_get_stainfo(pstapriv, ptxmgmt->peer);
1235 if (ptdlsinfo->sta_maximum == _TRUE) {
1236 if (ptdls_sta == NULL)
1237 goto exit;
1238 else if (!(ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE))
1239 goto exit;
1240 }
1241
1242 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1243 if (pmgntframe == NULL)
1244 goto exit;
1245
1246 if (ptdls_sta == NULL) {
1247 ptdls_sta = rtw_alloc_stainfo(pstapriv, ptxmgmt->peer);
1248 if (ptdls_sta == NULL) {
1249 RTW_INFO("[%s] rtw_alloc_stainfo fail\n", __FUNCTION__);
1250 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1251 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1252 goto exit;
1253 }
1254 ptdlsinfo->sta_cnt++;
1255 }
1256
1257 ptxmgmt->action_code = TDLS_SETUP_REQUEST;
1258
1259 pattrib = &pmgntframe->attrib;
1260 pmgntframe->frame_tag = DATA_FRAMETAG;
1261 pattrib->ether_type = 0x890d;
1262
1263 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1264 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1265 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1266 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1267
1268 update_tdls_attrib(padapter, pattrib);
1269
1270 if (ptdlsinfo->sta_cnt == MAX_ALLOWED_TDLS_STA_NUM)
1271 ptdlsinfo->sta_maximum = _TRUE;
1272
1273 ptdls_sta->tdls_sta_state |= TDLS_RESPONDER_STATE;
1274
1275 if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
1276 ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
1277 _set_timer(&ptdls_sta->handshake_timer, TDLS_HANDSHAKE_TIME);
1278 }
1279
1280 pattrib->qsel = pattrib->priority;
1281
1282 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1283 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1284 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1285 goto exit;
1286 }
1287
1288 if (wait_ack)
1289 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
1290 else {
1291 dump_mgntframe(padapter, pmgntframe);
1292 ret = _SUCCESS;
1293 }
1294
1295 exit:
1296
1297 return ret;
1298 }
1299
_issue_tdls_teardown(_adapter * padapter,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta,u8 wait_ack)1300 int _issue_tdls_teardown(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta, u8 wait_ack)
1301 {
1302 struct xmit_frame *pmgntframe;
1303 struct pkt_attrib *pattrib;
1304 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1305 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1306 struct sta_priv *pstapriv = &padapter->stapriv;
1307 _irqL irqL;
1308 int ret = _FAIL;
1309
1310 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1311
1312 ptxmgmt->action_code = TDLS_TEARDOWN;
1313
1314 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1315 if (pmgntframe == NULL)
1316 goto exit;
1317
1318 rtw_mi_set_scan_deny(padapter, 550);
1319 rtw_mi_scan_abort(padapter, _TRUE);
1320
1321 pattrib = &pmgntframe->attrib;
1322
1323 pmgntframe->frame_tag = DATA_FRAMETAG;
1324 pattrib->ether_type = 0x890d;
1325
1326 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1327 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1328
1329 if (ptxmgmt->status_code == _RSON_TDLS_TEAR_UN_RSN_)
1330 _rtw_memcpy(pattrib->ra, ptxmgmt->peer, ETH_ALEN);
1331 else
1332 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1333
1334 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1335
1336 update_tdls_attrib(padapter, pattrib);
1337 pattrib->qsel = pattrib->priority;
1338 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1339 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1340 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1341 goto exit;
1342 }
1343
1344 if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
1345 if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
1346 if (pattrib->encrypt)
1347 _cancel_timer_ex(&ptdls_sta->TPK_timer);
1348
1349 if (wait_ack)
1350 ret = dump_mgntframe_and_wait_ack(padapter, pmgntframe);
1351 else {
1352 dump_mgntframe(padapter, pmgntframe);
1353 ret = _SUCCESS;
1354 }
1355
1356 exit:
1357
1358 return ret;
1359 }
1360
issue_tdls_teardown(_adapter * padapter,struct tdls_txmgmt * ptxmgmt,u8 wait_ack)1361 int issue_tdls_teardown(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, u8 wait_ack)
1362 {
1363 struct sta_info *ptdls_sta = NULL;
1364 int ret = _FAIL;
1365
1366 ptdls_sta = rtw_get_stainfo(&(padapter->stapriv), ptxmgmt->peer);
1367 if (ptdls_sta == NULL) {
1368 RTW_INFO("No tdls_sta for tearing down\n");
1369 goto exit;
1370 }
1371
1372 ret = _issue_tdls_teardown(padapter, ptxmgmt, ptdls_sta, wait_ack);
1373 if ((ptxmgmt->status_code == _RSON_TDLS_TEAR_UN_RSN_) && (ret == _FAIL)) {
1374 /* Change status code and send teardown again via AP */
1375 ptxmgmt->status_code = _RSON_TDLS_TEAR_TOOFAR_;
1376 ret = _issue_tdls_teardown(padapter, ptxmgmt, ptdls_sta, wait_ack);
1377 }
1378
1379 if (rtw_tdls_is_driver_setup(padapter)) {
1380 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
1381 rtw_tdls_cmd(padapter, ptxmgmt->peer, TDLS_TEARDOWN_STA_LOCALLY_POST);
1382 }
1383
1384 exit:
1385 return ret;
1386 }
1387
issue_tdls_dis_req(_adapter * padapter,struct tdls_txmgmt * ptxmgmt)1388 int issue_tdls_dis_req(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
1389 {
1390 struct xmit_frame *pmgntframe;
1391 struct pkt_attrib *pattrib;
1392 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1393 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1394 int ret = _FAIL;
1395
1396 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1397
1398 ptxmgmt->action_code = TDLS_DISCOVERY_REQUEST;
1399 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1400 if (pmgntframe == NULL)
1401 goto exit;
1402
1403 pattrib = &pmgntframe->attrib;
1404 pmgntframe->frame_tag = DATA_FRAMETAG;
1405 pattrib->ether_type = 0x890d;
1406
1407 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1408 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1409 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1410 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1411
1412 update_tdls_attrib(padapter, pattrib);
1413 pattrib->qsel = pattrib->priority;
1414 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1415 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1416 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1417 goto exit;
1418 }
1419 dump_mgntframe(padapter, pmgntframe);
1420 RTW_INFO("issue tdls dis req\n");
1421
1422 ret = _SUCCESS;
1423 exit:
1424
1425 return ret;
1426 }
1427
issue_tdls_setup_rsp(_adapter * padapter,struct tdls_txmgmt * ptxmgmt)1428 int issue_tdls_setup_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
1429 {
1430 struct xmit_frame *pmgntframe;
1431 struct pkt_attrib *pattrib;
1432 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1433 int ret = _FAIL;
1434
1435 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1436
1437 ptxmgmt->action_code = TDLS_SETUP_RESPONSE;
1438 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1439 if (pmgntframe == NULL)
1440 goto exit;
1441
1442 pattrib = &pmgntframe->attrib;
1443 pmgntframe->frame_tag = DATA_FRAMETAG;
1444 pattrib->ether_type = 0x890d;
1445
1446 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1447 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1448 _rtw_memcpy(pattrib->ra, get_bssid(&(padapter->mlmepriv)), ETH_ALEN);
1449 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1450
1451 update_tdls_attrib(padapter, pattrib);
1452 pattrib->qsel = pattrib->priority;
1453 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1454 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1455 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1456 goto exit;
1457 }
1458
1459 dump_mgntframe(padapter, pmgntframe);
1460
1461 ret = _SUCCESS;
1462 exit:
1463
1464 return ret;
1465
1466 }
1467
issue_tdls_setup_cfm(_adapter * padapter,struct tdls_txmgmt * ptxmgmt)1468 int issue_tdls_setup_cfm(_adapter *padapter, struct tdls_txmgmt *ptxmgmt)
1469 {
1470 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
1471 struct xmit_frame *pmgntframe;
1472 struct pkt_attrib *pattrib;
1473 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1474 int ret = _FAIL;
1475
1476 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1477
1478 ptxmgmt->action_code = TDLS_SETUP_CONFIRM;
1479 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1480 if (pmgntframe == NULL)
1481 goto exit;
1482
1483 pattrib = &pmgntframe->attrib;
1484 pmgntframe->frame_tag = DATA_FRAMETAG;
1485 pattrib->ether_type = 0x890d;
1486
1487 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1488 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1489 _rtw_memcpy(pattrib->ra, get_bssid(&padapter->mlmepriv), ETH_ALEN);
1490 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1491
1492 update_tdls_attrib(padapter, pattrib);
1493 pattrib->qsel = pattrib->priority;
1494 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1495 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1496 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1497 goto exit;
1498 }
1499
1500 dump_mgntframe(padapter, pmgntframe);
1501
1502 ret = _SUCCESS;
1503 exit:
1504
1505 return ret;
1506
1507 }
1508
1509 /* TDLS Discovery Response frame is a management action frame */
issue_tdls_dis_rsp(_adapter * padapter,struct tdls_txmgmt * ptxmgmt,u8 privacy)1510 int issue_tdls_dis_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, u8 privacy)
1511 {
1512 struct xmit_frame *pmgntframe;
1513 struct pkt_attrib *pattrib;
1514 unsigned char *pframe;
1515 struct rtw_ieee80211_hdr *pwlanhdr;
1516 unsigned short *fctrl;
1517 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1518 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1519 int ret = _FAIL;
1520
1521 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1522
1523 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1524 if (pmgntframe == NULL)
1525 goto exit;
1526
1527 pattrib = &pmgntframe->attrib;
1528 update_mgntframe_attrib(padapter, pattrib);
1529
1530 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
1531
1532 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
1533 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
1534
1535 fctrl = &(pwlanhdr->frame_ctl);
1536 *(fctrl) = 0;
1537
1538 /* unicast probe request frame */
1539 _rtw_memcpy(pwlanhdr->addr1, ptxmgmt->peer, ETH_ALEN);
1540 _rtw_memcpy(pattrib->dst, pwlanhdr->addr1, ETH_ALEN);
1541 _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
1542 _rtw_memcpy(pattrib->src, pwlanhdr->addr2, ETH_ALEN);
1543 _rtw_memcpy(pwlanhdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN);
1544 _rtw_memcpy(pattrib->ra, pwlanhdr->addr3, ETH_ALEN);
1545
1546 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
1547 pmlmeext->mgnt_seq++;
1548 set_frame_sub_type(pframe, WIFI_ACTION);
1549
1550 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
1551 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
1552
1553 rtw_build_tdls_dis_rsp_ies(padapter, pmgntframe, pframe, ptxmgmt, privacy);
1554
1555 pattrib->nr_frags = 1;
1556 pattrib->last_txcmdsz = pattrib->pktlen;
1557
1558 dump_mgntframe(padapter, pmgntframe);
1559 ret = _SUCCESS;
1560
1561 exit:
1562 return ret;
1563 }
1564
issue_tdls_peer_traffic_rsp(_adapter * padapter,struct sta_info * ptdls_sta,struct tdls_txmgmt * ptxmgmt)1565 int issue_tdls_peer_traffic_rsp(_adapter *padapter, struct sta_info *ptdls_sta, struct tdls_txmgmt *ptxmgmt)
1566 {
1567 struct xmit_frame *pmgntframe;
1568 struct pkt_attrib *pattrib;
1569 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1570 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1571 int ret = _FAIL;
1572
1573 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1574
1575 ptxmgmt->action_code = TDLS_PEER_TRAFFIC_RESPONSE;
1576
1577 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1578 if (pmgntframe == NULL)
1579 goto exit;
1580
1581 pattrib = &pmgntframe->attrib;
1582
1583 pmgntframe->frame_tag = DATA_FRAMETAG;
1584 pattrib->ether_type = 0x890d;
1585
1586 _rtw_memcpy(pattrib->dst, ptdls_sta->cmn.mac_addr, ETH_ALEN);
1587 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1588 _rtw_memcpy(pattrib->ra, ptdls_sta->cmn.mac_addr, ETH_ALEN);
1589 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1590
1591 update_tdls_attrib(padapter, pattrib);
1592 pattrib->qsel = pattrib->priority;
1593
1594 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1595 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1596 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1597 goto exit;
1598 }
1599
1600 dump_mgntframe(padapter, pmgntframe);
1601 ret = _SUCCESS;
1602
1603 exit:
1604
1605 return ret;
1606 }
1607
issue_tdls_peer_traffic_indication(_adapter * padapter,struct sta_info * ptdls_sta)1608 int issue_tdls_peer_traffic_indication(_adapter *padapter, struct sta_info *ptdls_sta)
1609 {
1610 struct xmit_frame *pmgntframe;
1611 struct pkt_attrib *pattrib;
1612 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1613 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1614 struct tdls_txmgmt txmgmt;
1615 int ret = _FAIL;
1616
1617 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1618
1619 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1620 txmgmt.action_code = TDLS_PEER_TRAFFIC_INDICATION;
1621
1622 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1623 if (pmgntframe == NULL)
1624 goto exit;
1625
1626 pattrib = &pmgntframe->attrib;
1627
1628 pmgntframe->frame_tag = DATA_FRAMETAG;
1629 pattrib->ether_type = 0x890d;
1630
1631 _rtw_memcpy(pattrib->dst, ptdls_sta->cmn.mac_addr, ETH_ALEN);
1632 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1633 _rtw_memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
1634 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1635
1636 /* PTI frame's priority should be AC_VO */
1637 pattrib->priority = 7;
1638
1639 update_tdls_attrib(padapter, pattrib);
1640 pattrib->qsel = pattrib->priority;
1641 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
1642 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1643 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1644 goto exit;
1645 }
1646
1647 dump_mgntframe(padapter, pmgntframe);
1648 ret = _SUCCESS;
1649
1650 exit:
1651
1652 return ret;
1653 }
1654
1655 #ifdef CONFIG_TDLS_CH_SW
issue_tdls_ch_switch_req(_adapter * padapter,struct sta_info * ptdls_sta)1656 int issue_tdls_ch_switch_req(_adapter *padapter, struct sta_info *ptdls_sta)
1657 {
1658 struct xmit_frame *pmgntframe;
1659 struct pkt_attrib *pattrib;
1660 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1661 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1662 struct tdls_txmgmt txmgmt;
1663 int ret = _FAIL;
1664
1665 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1666
1667 if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
1668 RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
1669 goto exit;
1670 }
1671
1672 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1673 txmgmt.action_code = TDLS_CHANNEL_SWITCH_REQUEST;
1674
1675 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1676 if (pmgntframe == NULL)
1677 goto exit;
1678
1679 pattrib = &pmgntframe->attrib;
1680
1681 pmgntframe->frame_tag = DATA_FRAMETAG;
1682 pattrib->ether_type = 0x890d;
1683
1684 _rtw_memcpy(pattrib->dst, ptdls_sta->cmn.mac_addr, ETH_ALEN);
1685 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1686 _rtw_memcpy(pattrib->ra, ptdls_sta->cmn.mac_addr, ETH_ALEN);
1687 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1688
1689 update_tdls_attrib(padapter, pattrib);
1690 pattrib->qsel = pattrib->priority;
1691 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, &txmgmt) != _SUCCESS) {
1692 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1693 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1694 goto exit;
1695 }
1696
1697 dump_mgntframe(padapter, pmgntframe);
1698 ret = _SUCCESS;
1699 exit:
1700
1701 return ret;
1702 }
1703
issue_tdls_ch_switch_rsp(_adapter * padapter,struct tdls_txmgmt * ptxmgmt,int wait_ack)1704 int issue_tdls_ch_switch_rsp(_adapter *padapter, struct tdls_txmgmt *ptxmgmt, int wait_ack)
1705 {
1706 struct xmit_frame *pmgntframe;
1707 struct pkt_attrib *pattrib;
1708 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1709 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
1710 int ret = _FAIL;
1711
1712 RTW_INFO("[TDLS] %s\n", __FUNCTION__);
1713
1714 if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
1715 RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
1716 goto exit;
1717 }
1718
1719 ptxmgmt->action_code = TDLS_CHANNEL_SWITCH_RESPONSE;
1720
1721 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
1722 if (pmgntframe == NULL)
1723 goto exit;
1724
1725 pattrib = &pmgntframe->attrib;
1726
1727 pmgntframe->frame_tag = DATA_FRAMETAG;
1728 pattrib->ether_type = 0x890d;
1729
1730 _rtw_memcpy(pattrib->dst, ptxmgmt->peer, ETH_ALEN);
1731 _rtw_memcpy(pattrib->src, adapter_mac_addr(padapter), ETH_ALEN);
1732 _rtw_memcpy(pattrib->ra, ptxmgmt->peer, ETH_ALEN);
1733 _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
1734
1735 update_tdls_attrib(padapter, pattrib);
1736 pattrib->qsel = pattrib->priority;
1737 /*
1738 _enter_critical_bh(&pxmitpriv->lock, &irqL);
1739 if(xmitframe_enqueue_for_tdls_sleeping_sta(padapter, pmgntframe)==_TRUE){
1740 _exit_critical_bh(&pxmitpriv->lock, &irqL);
1741 return _FALSE;
1742 }
1743 */
1744 if (rtw_xmit_tdls_coalesce(padapter, pmgntframe, ptxmgmt) != _SUCCESS) {
1745 rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
1746 rtw_free_xmitframe(pxmitpriv, pmgntframe);
1747 goto exit;
1748 }
1749
1750 if (wait_ack)
1751 ret = dump_mgntframe_and_wait_ack_timeout(padapter, pmgntframe, 10);
1752 else {
1753 dump_mgntframe(padapter, pmgntframe);
1754 ret = _SUCCESS;
1755 }
1756 exit:
1757
1758 return ret;
1759 }
1760 #endif
1761
On_TDLS_Dis_Rsp(_adapter * padapter,union recv_frame * precv_frame)1762 int On_TDLS_Dis_Rsp(_adapter *padapter, union recv_frame *precv_frame)
1763 {
1764 struct sta_info *ptdls_sta = NULL, *psta = rtw_get_stainfo(&(padapter->stapriv), get_bssid(&(padapter->mlmepriv)));
1765 struct recv_priv *precvpriv = &(padapter->recvpriv);
1766 u8 *ptr = precv_frame->u.hdr.rx_data, *psa;
1767 struct rx_pkt_attrib *pattrib = &(precv_frame->u.hdr.attrib);
1768 struct tdls_info *ptdlsinfo = &(padapter->tdlsinfo);
1769 u8 empty_addr[ETH_ALEN] = { 0x00 };
1770 int rssi = 0;
1771 struct tdls_txmgmt txmgmt;
1772 int ret = _SUCCESS;
1773
1774 if (psta)
1775 rssi = psta->cmn.rssi_stat.rssi;
1776
1777 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1778 /* WFDTDLS: for sigma test, not to setup direct link automatically */
1779 ptdlsinfo->dev_discovered = _TRUE;
1780
1781 psa = get_sa(ptr);
1782 ptdls_sta = rtw_get_stainfo(&(padapter->stapriv), psa);
1783 if (ptdls_sta != NULL)
1784 ptdls_sta->sta_stats.rx_tdls_disc_rsp_pkts++;
1785
1786 #ifdef CONFIG_TDLS_AUTOSETUP
1787 if (ptdls_sta != NULL) {
1788 /* Record the tdls sta with lowest signal strength */
1789 if (ptdlsinfo->sta_maximum == _TRUE && ptdls_sta->alive_count >= 1) {
1790 if (_rtw_memcmp(ptdlsinfo->ss_record.macaddr, empty_addr, ETH_ALEN)) {
1791 _rtw_memcpy(ptdlsinfo->ss_record.macaddr, psa, ETH_ALEN);
1792 ptdlsinfo->ss_record.RxPWDBAll = pattrib->phy_info.rx_pwdb_all;
1793 } else {
1794 if (ptdlsinfo->ss_record.RxPWDBAll < pattrib->phy_info.rx_pwdb_all) {
1795 _rtw_memcpy(ptdlsinfo->ss_record.macaddr, psa, ETH_ALEN);
1796 ptdlsinfo->ss_record.RxPWDBAll = pattrib->phy_info.rx_pwdb_all;
1797 }
1798 }
1799 }
1800 } else {
1801 if (ptdlsinfo->sta_maximum == _TRUE) {
1802 if (_rtw_memcmp(ptdlsinfo->ss_record.macaddr, empty_addr, ETH_ALEN)) {
1803 /* All traffics are busy, do not set up another direct link. */
1804 ret = _FAIL;
1805 goto exit;
1806 } else {
1807 if (pattrib->phy_info.rx_pwdb_all > ptdlsinfo->ss_record.RxPWDBAll) {
1808 _rtw_memcpy(txmgmt.peer, ptdlsinfo->ss_record.macaddr, ETH_ALEN);
1809 /* issue_tdls_teardown(padapter, ptdlsinfo->ss_record.macaddr, _FALSE); */
1810 } else {
1811 ret = _FAIL;
1812 goto exit;
1813 }
1814 }
1815 }
1816
1817
1818 if (pattrib->phy_info.rx_pwdb_all + TDLS_SIGNAL_THRESH >= rssi) {
1819 RTW_INFO("pattrib->RxPWDBAll=%d, pdmpriv->undecorated_smoothed_pwdb=%d\n", pattrib->phy_info.rx_pwdb_all, rssi);
1820 _rtw_memcpy(txmgmt.peer, psa, ETH_ALEN);
1821 issue_tdls_setup_req(padapter, &txmgmt, _FALSE);
1822 }
1823 }
1824 exit:
1825 #endif /* CONFIG_TDLS_AUTOSETUP */
1826
1827 return ret;
1828
1829 }
1830
On_TDLS_Setup_Req(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)1831 sint On_TDLS_Setup_Req(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
1832 {
1833 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
1834 u8 *psa, *pmyid;
1835 struct sta_priv *pstapriv = &padapter->stapriv;
1836 u8 *ptr = precv_frame->u.hdr.rx_data;
1837 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1838 struct security_priv *psecuritypriv = &padapter->securitypriv;
1839 _irqL irqL;
1840 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
1841 u8 *prsnie, *ppairwise_cipher;
1842 u8 i, k;
1843 u8 ccmp_included = 0, rsnie_included = 0;
1844 u16 j, pairwise_count;
1845 u8 SNonce[32];
1846 u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
1847 sint parsing_length; /* Frame body length, without icv_len */
1848 PNDIS_802_11_VARIABLE_IEs pIE;
1849 u8 FIXED_IE = 5;
1850 unsigned char supportRate[16];
1851 int supportRateNum = 0;
1852 struct tdls_txmgmt txmgmt;
1853
1854 if (rtw_tdls_is_setup_allowed(padapter) == _FALSE)
1855 goto exit;
1856
1857 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
1858 psa = get_sa(ptr);
1859
1860 if (ptdlsinfo->sta_maximum == _TRUE) {
1861 if (ptdls_sta == NULL)
1862 goto exit;
1863 else if (!(ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE))
1864 goto exit;
1865 }
1866
1867 pmyid = adapter_mac_addr(padapter);
1868 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
1869 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
1870 - prx_pkt_attrib->hdrlen
1871 - prx_pkt_attrib->iv_len
1872 - prx_pkt_attrib->icv_len
1873 - LLC_HEADER_SIZE
1874 - ETH_TYPE_LEN
1875 - PAYLOAD_TYPE_LEN;
1876
1877 if (ptdls_sta == NULL) {
1878 ptdls_sta = rtw_alloc_stainfo(pstapriv, psa);
1879 if (ptdls_sta == NULL)
1880 goto exit;
1881
1882 ptdlsinfo->sta_cnt++;
1883 }
1884 else {
1885 if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
1886 /* If the direct link is already set up */
1887 /* Process as re-setup after tear down */
1888 RTW_INFO("re-setup a direct link\n");
1889 }
1890 /* Already receiving TDLS setup request */
1891 else if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE) {
1892 RTW_INFO("receive duplicated TDLS setup request frame in handshaking\n");
1893 goto exit;
1894 }
1895 /* When receiving and sending setup_req to the same link at the same time */
1896 /* STA with higher MAC_addr would be initiator */
1897 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE) {
1898 RTW_INFO("receive setup_req after sending setup_req\n");
1899 for (i = 0; i < 6; i++) {
1900 if (*(pmyid + i) == *(psa + i)) {
1901 } else if (*(pmyid + i) > *(psa + i)) {
1902 ptdls_sta->tdls_sta_state = TDLS_INITIATOR_STATE;
1903 break;
1904 } else if (*(pmyid + i) < *(psa + i))
1905 goto exit;
1906 }
1907 }
1908 }
1909
1910 if (ptdls_sta) {
1911 txmgmt.dialog_token = *(ptr + 2); /* Copy dialog token */
1912 txmgmt.status_code = _STATS_SUCCESSFUL_;
1913
1914 /* Parsing information element */
1915 for (j = FIXED_IE; j < parsing_length;) {
1916
1917 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
1918
1919 switch (pIE->ElementID) {
1920 case _SUPPORTEDRATES_IE_:
1921 if (pIE->Length <= sizeof(supportRate)) {
1922 _rtw_memcpy(supportRate, pIE->data, pIE->Length);
1923 supportRateNum = pIE->Length;
1924 }
1925 break;
1926 case _COUNTRY_IE_:
1927 break;
1928 case _EXT_SUPPORTEDRATES_IE_:
1929 if ((supportRateNum + pIE->Length) <= sizeof(supportRate)) {
1930 _rtw_memcpy(supportRate + supportRateNum, pIE->data, pIE->Length);
1931 supportRateNum += pIE->Length;
1932 }
1933 break;
1934 case _SUPPORTED_CH_IE_:
1935 break;
1936 case _RSN_IE_2_:
1937 rsnie_included = 1;
1938 if (prx_pkt_attrib->encrypt) {
1939 prsnie = (u8 *)pIE;
1940 if (pIE->Length <= sizeof(ptdls_sta->TDLS_RSNIE)) {
1941 /* Check CCMP pairwise_cipher presence. */
1942 ppairwise_cipher = prsnie + 10;
1943 _rtw_memcpy(ptdls_sta->TDLS_RSNIE, pIE->data, pIE->Length);
1944 pairwise_count = *(u16 *)(ppairwise_cipher - 2);
1945 for (k = 0; k < pairwise_count; k++) {
1946 if (_rtw_memcmp(ppairwise_cipher + 4 * k, RSN_CIPHER_SUITE_CCMP, 4) == _TRUE)
1947 ccmp_included = 1;
1948 }
1949
1950 if (ccmp_included == 0)
1951 txmgmt.status_code = _STATS_INVALID_RSNIE_;
1952 }
1953 }
1954 break;
1955 case WLAN_EID_EXT_CAP:
1956 break;
1957 case _VENDOR_SPECIFIC_IE_:
1958 break;
1959 case _FTIE_:
1960 if (prx_pkt_attrib->encrypt)
1961 _rtw_memcpy(SNonce, (ptr + j + 52), 32);
1962 break;
1963 case _TIMEOUT_ITVL_IE_:
1964 if (prx_pkt_attrib->encrypt)
1965 timeout_interval = cpu_to_le32(*(u32 *)(ptr + j + 3));
1966 break;
1967 case _RIC_Descriptor_IE_:
1968 break;
1969 #ifdef CONFIG_80211N_HT
1970 case _HT_CAPABILITY_IE_:
1971 rtw_tdls_process_ht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
1972 break;
1973 #endif
1974 #ifdef CONFIG_80211AC_VHT
1975 case EID_AID:
1976 break;
1977 case EID_VHTCapability:
1978 rtw_tdls_process_vht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
1979 break;
1980 #endif
1981 case EID_BSSCoexistence:
1982 break;
1983 case _LINK_ID_IE_:
1984 if (_rtw_memcmp(get_bssid(pmlmepriv), pIE->data, 6) == _FALSE)
1985 txmgmt.status_code = _STATS_NOT_IN_SAME_BSS_;
1986 break;
1987 default:
1988 break;
1989 }
1990
1991 j += (pIE->Length + 2);
1992
1993 }
1994
1995 /* Check status code */
1996 /* If responder STA has/hasn't security on AP, but request hasn't/has RSNIE, it should reject */
1997 if (txmgmt.status_code == _STATS_SUCCESSFUL_) {
1998 if (rsnie_included && prx_pkt_attrib->encrypt == 0)
1999 txmgmt.status_code = _STATS_SEC_DISABLED_;
2000 else if (rsnie_included == 0 && prx_pkt_attrib->encrypt)
2001 txmgmt.status_code = _STATS_INVALID_PARAMETERS_;
2002
2003 #ifdef CONFIG_WFD
2004 /* WFD test plan version 0.18.2 test item 5.1.5 */
2005 /* SoUT does not use TDLS if AP uses weak security */
2006 if (padapter->wdinfo.wfd_tdls_enable && (rsnie_included && prx_pkt_attrib->encrypt != _AES_))
2007 txmgmt.status_code = _STATS_SEC_DISABLED_;
2008 #endif /* CONFIG_WFD */
2009 }
2010
2011 ptdls_sta->tdls_sta_state |= TDLS_INITIATOR_STATE;
2012 if (prx_pkt_attrib->encrypt) {
2013 _rtw_memcpy(ptdls_sta->SNonce, SNonce, 32);
2014
2015 if (timeout_interval <= 300)
2016 ptdls_sta->TDLS_PeerKey_Lifetime = TDLS_TPK_RESEND_COUNT;
2017 else
2018 ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
2019 }
2020
2021 /* Update station supportRate */
2022 ptdls_sta->bssratelen = supportRateNum;
2023 _rtw_memcpy(ptdls_sta->bssrateset, supportRate, supportRateNum);
2024
2025 /* -2: AP + BC/MC sta, -4: default key */
2026 if (ptdlsinfo->sta_cnt == MAX_ALLOWED_TDLS_STA_NUM)
2027 ptdlsinfo->sta_maximum = _TRUE;
2028
2029 #ifdef CONFIG_WFD
2030 rtw_tdls_process_wfd_ie(ptdlsinfo, ptr + FIXED_IE, parsing_length);
2031 #endif
2032
2033 } else
2034 goto exit;
2035
2036 _rtw_memcpy(txmgmt.peer, prx_pkt_attrib->src, ETH_ALEN);
2037
2038 if (rtw_tdls_is_driver_setup(padapter)) {
2039 issue_tdls_setup_rsp(padapter, &txmgmt);
2040
2041 if (txmgmt.status_code == _STATS_SUCCESSFUL_)
2042 _set_timer(&ptdls_sta->handshake_timer, TDLS_HANDSHAKE_TIME);
2043 else {
2044 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2045 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2046 }
2047 }
2048
2049 exit:
2050
2051 return _SUCCESS;
2052 }
2053
On_TDLS_Setup_Rsp(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2054 int On_TDLS_Setup_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2055 {
2056 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2057 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
2058 struct sta_priv *pstapriv = &padapter->stapriv;
2059 u8 *ptr = precv_frame->u.hdr.rx_data;
2060 _irqL irqL;
2061 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2062 u8 *psa;
2063 u16 status_code = 0;
2064 sint parsing_length; /* Frame body length, without icv_len */
2065 PNDIS_802_11_VARIABLE_IEs pIE;
2066 u8 FIXED_IE = 7;
2067 u8 ANonce[32];
2068 u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL, *ppairwise_cipher = NULL;
2069 u16 pairwise_count, j, k;
2070 u8 verify_ccmp = 0;
2071 unsigned char supportRate[16];
2072 int supportRateNum = 0;
2073 struct tdls_txmgmt txmgmt;
2074 int ret = _SUCCESS;
2075 u32 timeout_interval = TDLS_TPK_RESEND_COUNT;
2076
2077 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
2078 psa = get_sa(ptr);
2079
2080 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2081 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
2082 - prx_pkt_attrib->hdrlen
2083 - prx_pkt_attrib->iv_len
2084 - prx_pkt_attrib->icv_len
2085 - LLC_HEADER_SIZE
2086 - ETH_TYPE_LEN
2087 - PAYLOAD_TYPE_LEN;
2088
2089 _rtw_memcpy(&status_code, ptr + 2, 2);
2090
2091 if (status_code != 0) {
2092 RTW_INFO("[TDLS] %s status_code = %d, free_tdls_sta\n", __FUNCTION__, status_code);
2093 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2094 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2095 ret = _FAIL;
2096 goto exit;
2097 }
2098
2099 status_code = 0;
2100
2101 /* parsing information element */
2102 for (j = FIXED_IE; j < parsing_length;) {
2103 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
2104
2105 switch (pIE->ElementID) {
2106 case _SUPPORTEDRATES_IE_:
2107 if (pIE->Length <= sizeof(supportRate)) {
2108 _rtw_memcpy(supportRate, pIE->data, pIE->Length);
2109 supportRateNum = pIE->Length;
2110 }
2111 break;
2112 case _COUNTRY_IE_:
2113 break;
2114 case _EXT_SUPPORTEDRATES_IE_:
2115 if ((supportRateNum + pIE->Length) <= sizeof(supportRate)) {
2116 _rtw_memcpy(supportRate + supportRateNum, pIE->data, pIE->Length);
2117 supportRateNum += pIE->Length;
2118 }
2119 break;
2120 case _SUPPORTED_CH_IE_:
2121 break;
2122 case _RSN_IE_2_:
2123 prsnie = (u8 *)pIE;
2124 /* Check CCMP pairwise_cipher presence. */
2125 ppairwise_cipher = prsnie + 10;
2126 _rtw_memcpy(&pairwise_count, (u16 *)(ppairwise_cipher - 2), 2);
2127 for (k = 0; k < pairwise_count; k++) {
2128 if (_rtw_memcmp(ppairwise_cipher + 4 * k, RSN_CIPHER_SUITE_CCMP, 4) == _TRUE)
2129 verify_ccmp = 1;
2130 }
2131 case WLAN_EID_EXT_CAP:
2132 break;
2133 case _VENDOR_SPECIFIC_IE_:
2134 if (_rtw_memcmp((u8 *)pIE + 2, WMM_INFO_OUI, 6) == _TRUE) {
2135 /* WMM Info ID and OUI */
2136 if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
2137 ptdls_sta->qos_option = _TRUE;
2138 }
2139 break;
2140 case _FTIE_:
2141 pftie = (u8 *)pIE;
2142 _rtw_memcpy(ANonce, (ptr + j + 20), 32);
2143 break;
2144 case _TIMEOUT_ITVL_IE_:
2145 ptimeout_ie = (u8 *)pIE;
2146 timeout_interval = cpu_to_le32(*(u32 *)(ptimeout_ie + 3));
2147 break;
2148 case _RIC_Descriptor_IE_:
2149 break;
2150 #ifdef CONFIG_80211N_HT
2151 case _HT_CAPABILITY_IE_:
2152 rtw_tdls_process_ht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
2153 break;
2154 #endif
2155 #ifdef CONFIG_80211AC_VHT
2156 case EID_AID:
2157 /* todo in the future if necessary */
2158 break;
2159 case EID_VHTCapability:
2160 rtw_tdls_process_vht_cap(padapter, ptdls_sta, pIE->data, pIE->Length);
2161 break;
2162 case EID_OpModeNotification:
2163 rtw_tdls_process_vht_op_mode_notify(padapter, ptdls_sta, pIE->data, pIE->Length);
2164 break;
2165 #endif
2166 case EID_BSSCoexistence:
2167 break;
2168 case _LINK_ID_IE_:
2169 plinkid_ie = (u8 *)pIE;
2170 break;
2171 default:
2172 break;
2173 }
2174
2175 j += (pIE->Length + 2);
2176
2177 }
2178
2179 ptdls_sta->bssratelen = supportRateNum;
2180 _rtw_memcpy(ptdls_sta->bssrateset, supportRate, supportRateNum);
2181 _rtw_memcpy(ptdls_sta->ANonce, ANonce, 32);
2182
2183 #ifdef CONFIG_WFD
2184 rtw_tdls_process_wfd_ie(ptdlsinfo, ptr + FIXED_IE, parsing_length);
2185 #endif
2186
2187 if (prx_pkt_attrib->encrypt) {
2188 if (verify_ccmp == 1) {
2189 txmgmt.status_code = _STATS_SUCCESSFUL_;
2190 if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
2191 wpa_tdls_generate_tpk(padapter, ptdls_sta);
2192 if (tdls_verify_mic(ptdls_sta->tpk.kck, 2, plinkid_ie, prsnie, ptimeout_ie, pftie) == _FAIL) {
2193 RTW_INFO("[TDLS] %s tdls_verify_mic fail, free_tdls_sta\n", __FUNCTION__);
2194 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2195 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2196 ret = _FAIL;
2197 goto exit;
2198 }
2199 ptdls_sta->TDLS_PeerKey_Lifetime = timeout_interval;
2200 }
2201 } else
2202 txmgmt.status_code = _STATS_INVALID_RSNIE_;
2203 } else
2204 txmgmt.status_code = _STATS_SUCCESSFUL_;
2205
2206 if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
2207 _rtw_memcpy(txmgmt.peer, prx_pkt_attrib->src, ETH_ALEN);
2208 issue_tdls_setup_cfm(padapter, &txmgmt);
2209
2210 if (txmgmt.status_code == _STATS_SUCCESSFUL_) {
2211 rtw_tdls_set_link_established(padapter, _TRUE);
2212
2213 if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE) {
2214 ptdls_sta->tdls_sta_state |= TDLS_LINKED_STATE;
2215 ptdls_sta->state |= WIFI_ASOC_STATE;
2216 _cancel_timer_ex(&ptdls_sta->handshake_timer);
2217 }
2218
2219 if (prx_pkt_attrib->encrypt)
2220 rtw_tdls_set_key(padapter, ptdls_sta);
2221
2222 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_ESTABLISHED);
2223
2224 }
2225 }
2226
2227 exit:
2228 if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
2229 return ret;
2230 else
2231 return _SUCCESS;
2232
2233 }
2234
On_TDLS_Setup_Cfm(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2235 int On_TDLS_Setup_Cfm(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2236 {
2237 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
2238 struct sta_priv *pstapriv = &padapter->stapriv;
2239 u8 *ptr = precv_frame->u.hdr.rx_data;
2240 _irqL irqL;
2241 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2242 u8 *psa;
2243 u16 status_code = 0;
2244 sint parsing_length;
2245 PNDIS_802_11_VARIABLE_IEs pIE;
2246 u8 FIXED_IE = 5;
2247 u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL, *ppairwise_cipher = NULL;
2248 u16 j, pairwise_count;
2249 int ret = _SUCCESS;
2250
2251 psa = get_sa(ptr);
2252
2253 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2254 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
2255 - prx_pkt_attrib->hdrlen
2256 - prx_pkt_attrib->iv_len
2257 - prx_pkt_attrib->icv_len
2258 - LLC_HEADER_SIZE
2259 - ETH_TYPE_LEN
2260 - PAYLOAD_TYPE_LEN;
2261
2262 _rtw_memcpy(&status_code, ptr + 2, 2);
2263
2264 if (status_code != 0) {
2265 RTW_INFO("[%s] status_code = %d\n, free_tdls_sta", __FUNCTION__, status_code);
2266 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2267 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2268 ret = _FAIL;
2269 goto exit;
2270 }
2271
2272 /* Parsing information element */
2273 for (j = FIXED_IE; j < parsing_length;) {
2274
2275 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
2276
2277 switch (pIE->ElementID) {
2278 case _RSN_IE_2_:
2279 prsnie = (u8 *)pIE;
2280 break;
2281 case _VENDOR_SPECIFIC_IE_:
2282 if (_rtw_memcmp((u8 *)pIE + 2, WMM_PARA_OUI, 6) == _TRUE) {
2283 /* WMM Parameter ID and OUI */
2284 ptdls_sta->qos_option = _TRUE;
2285 }
2286 break;
2287 case _FTIE_:
2288 pftie = (u8 *)pIE;
2289 break;
2290 case _TIMEOUT_ITVL_IE_:
2291 ptimeout_ie = (u8 *)pIE;
2292 break;
2293 #ifdef CONFIG_80211N_HT
2294 case _HT_EXTRA_INFO_IE_:
2295 break;
2296 #endif
2297 #ifdef CONFIG_80211AC_VHT
2298 case EID_VHTOperation:
2299 rtw_tdls_process_vht_operation(padapter, ptdls_sta, pIE->data, pIE->Length);
2300 break;
2301 case EID_OpModeNotification:
2302 rtw_tdls_process_vht_op_mode_notify(padapter, ptdls_sta, pIE->data, pIE->Length);
2303 break;
2304 #endif
2305 case _LINK_ID_IE_:
2306 plinkid_ie = (u8 *)pIE;
2307 break;
2308 default:
2309 break;
2310 }
2311
2312 j += (pIE->Length + 2);
2313
2314 }
2315
2316 if (prx_pkt_attrib->encrypt) {
2317 /* Verify mic in FTIE MIC field */
2318 if (rtw_tdls_is_driver_setup(padapter) &&
2319 (tdls_verify_mic(ptdls_sta->tpk.kck, 3, plinkid_ie, prsnie, ptimeout_ie, pftie) == _FAIL)) {
2320 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2321 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2322 ret = _FAIL;
2323 goto exit;
2324 }
2325 }
2326
2327 if (rtw_tdls_is_driver_setup(padapter)) {
2328 rtw_tdls_set_link_established(padapter, _TRUE);
2329
2330 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE) {
2331 ptdls_sta->tdls_sta_state |= TDLS_LINKED_STATE;
2332 ptdls_sta->state |= WIFI_ASOC_STATE;
2333 _cancel_timer_ex(&ptdls_sta->handshake_timer);
2334 }
2335
2336 if (prx_pkt_attrib->encrypt) {
2337 rtw_tdls_set_key(padapter, ptdls_sta);
2338
2339 /* Start TPK timer */
2340 ptdls_sta->TPK_count = 0;
2341 _set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
2342 }
2343
2344 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_ESTABLISHED);
2345 }
2346
2347 exit:
2348 return ret;
2349
2350 }
2351
On_TDLS_Dis_Req(_adapter * padapter,union recv_frame * precv_frame)2352 int On_TDLS_Dis_Req(_adapter *padapter, union recv_frame *precv_frame)
2353 {
2354 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2355 struct sta_priv *pstapriv = &padapter->stapriv;
2356 struct sta_info *psta_ap;
2357 u8 *ptr = precv_frame->u.hdr.rx_data;
2358 sint parsing_length; /* Frame body length, without icv_len */
2359 PNDIS_802_11_VARIABLE_IEs pIE;
2360 u8 FIXED_IE = 3, *dst;
2361 u16 j;
2362 struct tdls_txmgmt txmgmt;
2363 int ret = _SUCCESS;
2364
2365 if (rtw_tdls_is_driver_setup(padapter) == _FALSE)
2366 goto exit;
2367
2368 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
2369 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2370 txmgmt.dialog_token = *(ptr + 2);
2371 _rtw_memcpy(&txmgmt.peer, precv_frame->u.hdr.attrib.src, ETH_ALEN);
2372 txmgmt.action_code = TDLS_DISCOVERY_RESPONSE;
2373 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
2374 - prx_pkt_attrib->hdrlen
2375 - prx_pkt_attrib->iv_len
2376 - prx_pkt_attrib->icv_len
2377 - LLC_HEADER_SIZE
2378 - ETH_TYPE_LEN
2379 - PAYLOAD_TYPE_LEN;
2380
2381 /* Parsing information element */
2382 for (j = FIXED_IE; j < parsing_length;) {
2383
2384 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
2385
2386 switch (pIE->ElementID) {
2387 case _LINK_ID_IE_:
2388 psta_ap = rtw_get_stainfo(pstapriv, pIE->data);
2389 if (psta_ap == NULL)
2390 goto exit;
2391 dst = pIE->data + 12;
2392 if (MacAddr_isBcst(dst) == _FALSE && (_rtw_memcmp(adapter_mac_addr(padapter), dst, ETH_ALEN) == _FALSE))
2393 goto exit;
2394 break;
2395 default:
2396 break;
2397 }
2398
2399 j += (pIE->Length + 2);
2400
2401 }
2402
2403 issue_tdls_dis_rsp(padapter, &txmgmt, prx_pkt_attrib->privacy);
2404
2405 exit:
2406 return ret;
2407
2408 }
2409
On_TDLS_Teardown(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2410 int On_TDLS_Teardown(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2411 {
2412 u8 *ptr = precv_frame->u.hdr.rx_data;
2413 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2414 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2415 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2416 struct sta_priv *pstapriv = &padapter->stapriv;
2417 _irqL irqL;
2418 u8 reason;
2419
2420 reason = *(ptr + prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN + 2);
2421 RTW_INFO("[TDLS] %s Reason code(%d)\n", __FUNCTION__, reason);
2422
2423 if (rtw_tdls_is_driver_setup(padapter)) {
2424 rtw_tdls_teardown_pre_hdl(padapter, ptdls_sta);
2425 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY_POST);
2426 }
2427
2428 return _SUCCESS;
2429
2430 }
2431
2432 #if 0
2433 u8 TDLS_check_ch_state(uint state)
2434 {
2435 if (state & TDLS_CH_SWITCH_ON_STATE &&
2436 state & TDLS_PEER_AT_OFF_STATE) {
2437 if (state & TDLS_PEER_SLEEP_STATE)
2438 return 2; /* U-APSD + ch. switch */
2439 else
2440 return 1; /* ch. switch */
2441 } else
2442 return 0;
2443 }
2444 #endif
2445
On_TDLS_Peer_Traffic_Indication(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2446 int On_TDLS_Peer_Traffic_Indication(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2447 {
2448 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
2449 u8 *ptr = precv_frame->u.hdr.rx_data;
2450 struct tdls_txmgmt txmgmt;
2451
2452 ptr += pattrib->hdrlen + pattrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2453 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
2454
2455 txmgmt.dialog_token = *(ptr + 2);
2456 issue_tdls_peer_traffic_rsp(padapter, ptdls_sta, &txmgmt);
2457 /* issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->cmn.mac_addr, 0, 0, 0); */
2458
2459 return _SUCCESS;
2460 }
2461
2462 /* We process buffered data for 1. U-APSD, 2. ch. switch, 3. U-APSD + ch. switch here */
On_TDLS_Peer_Traffic_Rsp(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2463 int On_TDLS_Peer_Traffic_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2464 {
2465 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
2466 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2467 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
2468 struct sta_priv *pstapriv = &padapter->stapriv;
2469 u8 wmmps_ac = 0;
2470 /* u8 state=TDLS_check_ch_state(ptdls_sta->tdls_sta_state); */
2471 int i;
2472
2473 ptdls_sta->sta_stats.rx_data_pkts++;
2474
2475 ptdls_sta->tdls_sta_state &= ~(TDLS_WAIT_PTR_STATE);
2476
2477 /* Check 4-AC queue bit */
2478 if (ptdls_sta->uapsd_vo || ptdls_sta->uapsd_vi || ptdls_sta->uapsd_be || ptdls_sta->uapsd_bk)
2479 wmmps_ac = 1;
2480
2481 /* If it's a direct link and have buffered frame */
2482 if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE) {
2483 if (wmmps_ac) {
2484 _irqL irqL;
2485 _list *xmitframe_plist, *xmitframe_phead;
2486 struct xmit_frame *pxmitframe = NULL;
2487
2488 _enter_critical_bh(&ptdls_sta->sleep_q.lock, &irqL);
2489
2490 xmitframe_phead = get_list_head(&ptdls_sta->sleep_q);
2491 xmitframe_plist = get_next(xmitframe_phead);
2492
2493 /* transmit buffered frames */
2494 while (rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist) == _FALSE) {
2495 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
2496 xmitframe_plist = get_next(xmitframe_plist);
2497 rtw_list_delete(&pxmitframe->list);
2498
2499 ptdls_sta->sleepq_len--;
2500 ptdls_sta->sleepq_ac_len--;
2501 if (ptdls_sta->sleepq_len > 0) {
2502 pxmitframe->attrib.mdata = 1;
2503 pxmitframe->attrib.eosp = 0;
2504 } else {
2505 pxmitframe->attrib.mdata = 0;
2506 pxmitframe->attrib.eosp = 1;
2507 }
2508 pxmitframe->attrib.triggered = 1;
2509
2510 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2511 }
2512
2513 if (ptdls_sta->sleepq_len == 0)
2514 RTW_INFO("no buffered packets for tdls to xmit\n");
2515 else {
2516 RTW_INFO("error!psta->sleepq_len=%d\n", ptdls_sta->sleepq_len);
2517 ptdls_sta->sleepq_len = 0;
2518 }
2519
2520 _exit_critical_bh(&ptdls_sta->sleep_q.lock, &irqL);
2521
2522 }
2523
2524 }
2525
2526 return _SUCCESS;
2527 }
2528
2529 #ifdef CONFIG_TDLS_CH_SW
On_TDLS_Ch_Switch_Req(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2530 sint On_TDLS_Ch_Switch_Req(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2531 {
2532 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
2533 struct sta_priv *pstapriv = &padapter->stapriv;
2534 u8 *ptr = precv_frame->u.hdr.rx_data;
2535 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2536 sint parsing_length;
2537 PNDIS_802_11_VARIABLE_IEs pIE;
2538 u8 FIXED_IE = 4;
2539 u16 j;
2540 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2541 u8 zaddr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
2542 u16 switch_time = TDLS_CH_SWITCH_TIME * 1000, switch_timeout = TDLS_CH_SWITCH_TIMEOUT * 1000;
2543 u8 take_care_iqk;
2544
2545 if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
2546 RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
2547 return _FAIL;
2548 }
2549
2550 ptdls_sta->ch_switch_time = switch_time;
2551 ptdls_sta->ch_switch_timeout = switch_timeout;
2552
2553 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2554 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
2555 - prx_pkt_attrib->hdrlen
2556 - prx_pkt_attrib->iv_len
2557 - prx_pkt_attrib->icv_len
2558 - LLC_HEADER_SIZE
2559 - ETH_TYPE_LEN
2560 - PAYLOAD_TYPE_LEN;
2561
2562 pchsw_info->off_ch_num = *(ptr + 2);
2563
2564 if ((*(ptr + 2) == 2) && (hal_is_band_support(padapter, BAND_ON_5G)))
2565 pchsw_info->off_ch_num = 44;
2566
2567 if (pchsw_info->off_ch_num != pmlmeext->cur_channel)
2568 pchsw_info->delay_switch_back = _FALSE;
2569
2570 /* Parsing information element */
2571 for (j = FIXED_IE; j < parsing_length;) {
2572 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
2573
2574 switch (pIE->ElementID) {
2575 case EID_SecondaryChnlOffset:
2576 switch (*(pIE->data)) {
2577 case EXTCHNL_OFFSET_UPPER:
2578 pchsw_info->ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
2579 break;
2580
2581 case EXTCHNL_OFFSET_LOWER:
2582 pchsw_info->ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
2583 break;
2584
2585 default:
2586 pchsw_info->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2587 break;
2588 }
2589 break;
2590 case _LINK_ID_IE_:
2591 break;
2592 case _CH_SWITCH_TIMING_:
2593 ptdls_sta->ch_switch_time = (RTW_GET_LE16(pIE->data) >= TDLS_CH_SWITCH_TIME * 1000) ?
2594 RTW_GET_LE16(pIE->data) : TDLS_CH_SWITCH_TIME * 1000;
2595 ptdls_sta->ch_switch_timeout = (RTW_GET_LE16(pIE->data + 2) >= TDLS_CH_SWITCH_TIMEOUT * 1000) ?
2596 RTW_GET_LE16(pIE->data + 2) : TDLS_CH_SWITCH_TIMEOUT * 1000;
2597 RTW_INFO("[TDLS] %s ch_switch_time:%d, ch_switch_timeout:%d\n"
2598 , __FUNCTION__, RTW_GET_LE16(pIE->data), RTW_GET_LE16(pIE->data + 2));
2599 default:
2600 break;
2601 }
2602
2603 j += (pIE->Length + 2);
2604 }
2605
2606 #ifndef CONFIG_TDLS_CH_SW_V2
2607 rtw_hal_get_hwreg(padapter, HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO, &take_care_iqk);
2608 if (take_care_iqk == _TRUE) {
2609 u8 central_chnl;
2610 u8 bw_mode;
2611
2612 bw_mode = (pchsw_info->ch_offset) ? CHANNEL_WIDTH_40 : CHANNEL_WIDTH_20;
2613 central_chnl = rtw_get_center_ch(pchsw_info->off_ch_num, bw_mode, pchsw_info->ch_offset);
2614 if (rtw_hal_ch_sw_iqk_info_search(padapter, central_chnl, bw_mode) < 0) {
2615 if (!(pchsw_info->ch_sw_state & TDLS_CH_SWITCH_PREPARE_STATE))
2616 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_PREPARE);
2617
2618 return _FAIL;
2619 }
2620 }
2621 #endif
2622
2623 /* cancel ch sw monitor timer for responder */
2624 if (!(pchsw_info->ch_sw_state & TDLS_CH_SW_INITIATOR_STATE))
2625 _cancel_timer_ex(&ptdls_sta->ch_sw_monitor_timer);
2626
2627 if (_rtw_memcmp(pchsw_info->addr, zaddr, ETH_ALEN) == _TRUE)
2628 _rtw_memcpy(pchsw_info->addr, ptdls_sta->cmn.mac_addr, ETH_ALEN);
2629
2630 if (ATOMIC_READ(&pchsw_info->chsw_on) == _FALSE)
2631 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_START);
2632
2633 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_RESP);
2634
2635 return _SUCCESS;
2636 }
2637
On_TDLS_Ch_Switch_Rsp(_adapter * padapter,union recv_frame * precv_frame,struct sta_info * ptdls_sta)2638 sint On_TDLS_Ch_Switch_Rsp(_adapter *padapter, union recv_frame *precv_frame, struct sta_info *ptdls_sta)
2639 {
2640 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
2641 struct sta_priv *pstapriv = &padapter->stapriv;
2642 u8 *ptr = precv_frame->u.hdr.rx_data;
2643 struct rx_pkt_attrib *prx_pkt_attrib = &precv_frame->u.hdr.attrib;
2644 sint parsing_length;
2645 PNDIS_802_11_VARIABLE_IEs pIE;
2646 u8 FIXED_IE = 4;
2647 u16 status_code, j, switch_time, switch_timeout;
2648 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2649 int ret = _SUCCESS;
2650
2651 if (rtw_tdls_is_chsw_allowed(padapter) == _FALSE) {
2652 RTW_INFO("[TDLS] Ignore %s since channel switch is not allowed\n", __func__);
2653 return _SUCCESS;
2654 }
2655
2656 /* If we receive Unsolicited TDLS Channel Switch Response when channel switch is running, */
2657 /* we will go back to base channel and terminate this channel switch procedure */
2658 if (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE) {
2659 if (pmlmeext->cur_channel != rtw_get_oper_ch(padapter)) {
2660 RTW_INFO("[TDLS] Rx unsolicited channel switch response\n");
2661 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_TO_BASE_CHNL);
2662 goto exit;
2663 }
2664 }
2665
2666 ptr += prx_pkt_attrib->hdrlen + prx_pkt_attrib->iv_len + LLC_HEADER_SIZE + ETH_TYPE_LEN + PAYLOAD_TYPE_LEN;
2667 parsing_length = ((union recv_frame *)precv_frame)->u.hdr.len
2668 - prx_pkt_attrib->hdrlen
2669 - prx_pkt_attrib->iv_len
2670 - prx_pkt_attrib->icv_len
2671 - LLC_HEADER_SIZE
2672 - ETH_TYPE_LEN
2673 - PAYLOAD_TYPE_LEN;
2674
2675 _rtw_memcpy(&status_code, ptr + 2, 2);
2676
2677 if (status_code != 0) {
2678 RTW_INFO("[TDLS] %s status_code:%d\n", __func__, status_code);
2679 pchsw_info->ch_sw_state &= ~(TDLS_CH_SW_INITIATOR_STATE);
2680 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_END);
2681 ret = _FAIL;
2682 goto exit;
2683 }
2684
2685 /* Parsing information element */
2686 for (j = FIXED_IE; j < parsing_length;) {
2687 pIE = (PNDIS_802_11_VARIABLE_IEs)(ptr + j);
2688
2689 switch (pIE->ElementID) {
2690 case _LINK_ID_IE_:
2691 break;
2692 case _CH_SWITCH_TIMING_:
2693 _rtw_memcpy(&switch_time, pIE->data, 2);
2694 if (switch_time > ptdls_sta->ch_switch_time)
2695 _rtw_memcpy(&ptdls_sta->ch_switch_time, &switch_time, 2);
2696
2697 _rtw_memcpy(&switch_timeout, pIE->data + 2, 2);
2698 if (switch_timeout > ptdls_sta->ch_switch_timeout)
2699 _rtw_memcpy(&ptdls_sta->ch_switch_timeout, &switch_timeout, 2);
2700 break;
2701 default:
2702 break;
2703 }
2704
2705 j += (pIE->Length + 2);
2706 }
2707
2708 if ((pmlmeext->cur_channel == rtw_get_oper_ch(padapter)) &&
2709 (pchsw_info->ch_sw_state & TDLS_WAIT_CH_RSP_STATE)) {
2710 if (ATOMIC_READ(&pchsw_info->chsw_on) == _TRUE)
2711 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_TO_OFF_CHNL);
2712 }
2713
2714 exit:
2715 return ret;
2716 }
2717 #endif /* CONFIG_TDLS_CH_SW */
2718
2719 #ifdef CONFIG_WFD
wfd_ie_tdls(_adapter * padapter,u8 * pframe,u32 * pktlen)2720 void wfd_ie_tdls(_adapter *padapter, u8 *pframe, u32 *pktlen)
2721 {
2722 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2723 struct wifi_display_info *pwfd_info = padapter->tdlsinfo.wfd_info;
2724 u8 wfdie[MAX_WFD_IE_LEN] = { 0x00 };
2725 u32 wfdielen = 0;
2726 u16 v16 = 0;
2727
2728 if (!hal_chk_wl_func(padapter, WL_FUNC_MIRACAST))
2729 return;
2730
2731 /* WFD OUI */
2732 wfdielen = 0;
2733 wfdie[wfdielen++] = 0x50;
2734 wfdie[wfdielen++] = 0x6F;
2735 wfdie[wfdielen++] = 0x9A;
2736 wfdie[wfdielen++] = 0x0A; /* WFA WFD v1.0 */
2737
2738 /*
2739 * Commented by Albert 20110825
2740 * According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
2741 * 1. WFD Device Information
2742 * 2. Associated BSSID ( Optional )
2743 * 3. Local IP Adress ( Optional )
2744 */
2745
2746 /* WFD Device Information ATTR */
2747 /* Type: */
2748 wfdie[wfdielen++] = WFD_ATTR_DEVICE_INFO;
2749
2750 /* Length: */
2751 /* Note: In the WFD specification, the size of length field is 2. */
2752 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
2753 wfdielen += 2;
2754
2755 /* Value1: */
2756 /* WFD device information */
2757 /* available for WFD session + Preferred TDLS + WSD ( WFD Service Discovery ) */
2758 v16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL
2759 | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_WSD;
2760 RTW_PUT_BE16(wfdie + wfdielen, v16);
2761 wfdielen += 2;
2762
2763 /* Value2: */
2764 /* Session Management Control Port */
2765 /* Default TCP port for RTSP messages is 554 */
2766 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->tdls_rtsp_ctrlport);
2767 wfdielen += 2;
2768
2769 /* Value3: */
2770 /* WFD Device Maximum Throughput */
2771 /* 300Mbps is the maximum throughput */
2772 RTW_PUT_BE16(wfdie + wfdielen, 300);
2773 wfdielen += 2;
2774
2775 /* Associated BSSID ATTR */
2776 /* Type: */
2777 wfdie[wfdielen++] = WFD_ATTR_ASSOC_BSSID;
2778
2779 /* Length: */
2780 /* Note: In the WFD specification, the size of length field is 2. */
2781 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
2782 wfdielen += 2;
2783
2784 /* Value: */
2785 /* Associated BSSID */
2786 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
2787 _rtw_memcpy(wfdie + wfdielen, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
2788 else
2789 _rtw_memset(wfdie + wfdielen, 0x00, ETH_ALEN);
2790
2791 /* Local IP Address ATTR */
2792 wfdie[wfdielen++] = WFD_ATTR_LOCAL_IP_ADDR;
2793
2794 /* Length: */
2795 /* Note: In the WFD specification, the size of length field is 2. */
2796 RTW_PUT_BE16(wfdie + wfdielen, 0x0005);
2797 wfdielen += 2;
2798
2799 /* Version: */
2800 /* 0x01: Version1;IPv4 */
2801 wfdie[wfdielen++] = 0x01;
2802
2803 /* IPv4 Address */
2804 _rtw_memcpy(wfdie + wfdielen, pwfd_info->ip_address, 4);
2805 wfdielen += 4;
2806
2807 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, pktlen);
2808
2809 }
2810 #endif /* CONFIG_WFD */
2811
rtw_build_tdls_setup_req_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)2812 void rtw_build_tdls_setup_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
2813 {
2814 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
2815 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2816 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2817 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2818 int i = 0 ;
2819 u32 time;
2820 u8 *pframe_head;
2821
2822 /* SNonce */
2823 if (pattrib->encrypt) {
2824 for (i = 0; i < 8; i++) {
2825 time = rtw_get_current_time();
2826 _rtw_memcpy(&ptdls_sta->SNonce[4 * i], (u8 *)&time, 4);
2827 }
2828 }
2829
2830 pframe_head = pframe; /* For rtw_tdls_set_ht_cap() */
2831
2832 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
2833 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
2834 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
2835 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
2836
2837 pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
2838 pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
2839 pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
2840 pframe = rtw_tdls_set_sup_reg_class(pframe, pattrib);
2841
2842 if (pattrib->encrypt)
2843 pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
2844
2845 pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
2846
2847 if (pattrib->encrypt) {
2848 pframe = rtw_tdls_set_ftie(ptxmgmt
2849 , pframe
2850 , pattrib
2851 , NULL
2852 , ptdls_sta->SNonce);
2853
2854 pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
2855 }
2856
2857 #ifdef CONFIG_80211N_HT
2858 /* Sup_reg_classes(optional) */
2859 if (pregistrypriv->ht_enable == _TRUE)
2860 pframe = rtw_tdls_set_ht_cap(padapter, pframe_head, pattrib);
2861 #endif
2862
2863 pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
2864
2865 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
2866
2867 if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
2868 pframe = rtw_tdls_set_qos_cap(pframe, pattrib);
2869
2870 #ifdef CONFIG_80211AC_VHT
2871 if ((padapter->mlmepriv.htpriv.ht_option == _TRUE) && (pmlmeext->cur_channel > 14)
2872 && REGSTY_IS_11AC_ENABLE(pregistrypriv)
2873 && is_supported_vht(pregistrypriv->wireless_mode)
2874 && (!rfctl->country_ent || COUNTRY_CHPLAN_EN_11AC(rfctl->country_ent))
2875 ) {
2876 pframe = rtw_tdls_set_aid(padapter, pframe, pattrib);
2877 pframe = rtw_tdls_set_vht_cap(padapter, pframe, pattrib);
2878 }
2879 #endif
2880
2881 #ifdef CONFIG_WFD
2882 if (padapter->wdinfo.wfd_tdls_enable == 1)
2883 wfd_ie_tdls(padapter, pframe, &(pattrib->pktlen));
2884 #endif
2885
2886 }
2887
rtw_build_tdls_setup_rsp_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)2888 void rtw_build_tdls_setup_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
2889 {
2890 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
2891 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2892 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2893 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2894 u8 k; /* for random ANonce */
2895 u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL;
2896 u32 time;
2897 u8 *pframe_head;
2898
2899 if (pattrib->encrypt) {
2900 for (k = 0; k < 8; k++) {
2901 time = rtw_get_current_time();
2902 _rtw_memcpy(&ptdls_sta->ANonce[4 * k], (u8 *)&time, 4);
2903 }
2904 }
2905
2906 pframe_head = pframe;
2907
2908 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
2909 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
2910 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
2911 pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
2912
2913 if (ptxmgmt->status_code != 0) {
2914 RTW_INFO("[%s] status_code:%04x\n", __FUNCTION__, ptxmgmt->status_code);
2915 return;
2916 }
2917
2918 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
2919 pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
2920 pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
2921 pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
2922 pframe = rtw_tdls_set_sup_reg_class(pframe, pattrib);
2923
2924 if (pattrib->encrypt) {
2925 prsnie = pframe;
2926 pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _FALSE, ptdls_sta);
2927 }
2928
2929 pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
2930
2931 if (pattrib->encrypt) {
2932 if (rtw_tdls_is_driver_setup(padapter) == _TRUE)
2933 wpa_tdls_generate_tpk(padapter, ptdls_sta);
2934
2935 pftie = pframe;
2936 pftie_mic = pframe + 4;
2937 pframe = rtw_tdls_set_ftie(ptxmgmt
2938 , pframe
2939 , pattrib
2940 , ptdls_sta->ANonce
2941 , ptdls_sta->SNonce);
2942
2943 ptimeout_ie = pframe;
2944 pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _FALSE, ptdls_sta);
2945 }
2946
2947 #ifdef CONFIG_80211N_HT
2948 /* Sup_reg_classes(optional) */
2949 if (pregistrypriv->ht_enable == _TRUE)
2950 pframe = rtw_tdls_set_ht_cap(padapter, pframe_head, pattrib);
2951 #endif
2952
2953 pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
2954
2955 plinkid_ie = pframe;
2956 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
2957
2958 /* Fill FTIE mic */
2959 if (pattrib->encrypt && rtw_tdls_is_driver_setup(padapter) == _TRUE)
2960 wpa_tdls_ftie_mic(ptdls_sta->tpk.kck, 2, plinkid_ie, prsnie, ptimeout_ie, pftie, pftie_mic);
2961
2962 if ((pregistrypriv->wmm_enable == _TRUE) || (padapter->mlmepriv.htpriv.ht_option == _TRUE))
2963 pframe = rtw_tdls_set_qos_cap(pframe, pattrib);
2964
2965 #ifdef CONFIG_80211AC_VHT
2966 if ((padapter->mlmepriv.htpriv.ht_option == _TRUE) && (pmlmeext->cur_channel > 14)
2967 && REGSTY_IS_11AC_ENABLE(pregistrypriv)
2968 && is_supported_vht(pregistrypriv->wireless_mode)
2969 && (!rfctl->country_ent || COUNTRY_CHPLAN_EN_11AC(rfctl->country_ent))
2970 ) {
2971 pframe = rtw_tdls_set_aid(padapter, pframe, pattrib);
2972 pframe = rtw_tdls_set_vht_cap(padapter, pframe, pattrib);
2973 pframe = rtw_tdls_set_vht_op_mode_notify(padapter, pframe, pattrib, pmlmeext->cur_bwmode);
2974 }
2975 #endif
2976
2977 #ifdef CONFIG_WFD
2978 if (padapter->wdinfo.wfd_tdls_enable)
2979 wfd_ie_tdls(padapter, pframe, &(pattrib->pktlen));
2980 #endif
2981
2982 }
2983
rtw_build_tdls_setup_cfm_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)2984 void rtw_build_tdls_setup_cfm_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
2985 {
2986 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
2987 struct registry_priv *pregistrypriv = &padapter->registrypriv;
2988 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2989 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2990 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2991
2992 unsigned int ie_len;
2993 unsigned char *p;
2994 u8 wmm_param_ele[24] = {0};
2995 u8 *pftie = NULL, *ptimeout_ie = NULL, *plinkid_ie = NULL, *prsnie = NULL, *pftie_mic = NULL;
2996
2997 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
2998 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
2999 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3000 pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
3001 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
3002
3003 if (ptxmgmt->status_code != 0)
3004 return;
3005
3006 if (pattrib->encrypt) {
3007 prsnie = pframe;
3008 pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
3009 }
3010
3011 if (pattrib->encrypt) {
3012 pftie = pframe;
3013 pftie_mic = pframe + 4;
3014 pframe = rtw_tdls_set_ftie(ptxmgmt
3015 , pframe
3016 , pattrib
3017 , ptdls_sta->ANonce
3018 , ptdls_sta->SNonce);
3019
3020 ptimeout_ie = pframe;
3021 pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, ptdls_sta);
3022
3023 if (rtw_tdls_is_driver_setup(padapter) == _TRUE) {
3024 /* Start TPK timer */
3025 ptdls_sta->TPK_count = 0;
3026 _set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
3027 }
3028 }
3029
3030 /* HT operation; todo */
3031
3032 plinkid_ie = pframe;
3033 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3034
3035 if (pattrib->encrypt && (rtw_tdls_is_driver_setup(padapter) == _TRUE))
3036 wpa_tdls_ftie_mic(ptdls_sta->tpk.kck, 3, plinkid_ie, prsnie, ptimeout_ie, pftie, pftie_mic);
3037
3038 if (ptdls_sta->qos_option == _TRUE)
3039 pframe = rtw_tdls_set_wmm_params(padapter, pframe, pattrib);
3040
3041 #ifdef CONFIG_80211AC_VHT
3042 if ((padapter->mlmepriv.htpriv.ht_option == _TRUE)
3043 && (ptdls_sta->vhtpriv.vht_option == _TRUE) && (pmlmeext->cur_channel > 14)
3044 && REGSTY_IS_11AC_ENABLE(pregistrypriv)
3045 && is_supported_vht(pregistrypriv->wireless_mode)
3046 && (!rfctl->country_ent || COUNTRY_CHPLAN_EN_11AC(rfctl->country_ent))
3047 ) {
3048 pframe = rtw_tdls_set_vht_operation(padapter, pframe, pattrib, pmlmeext->cur_channel);
3049 pframe = rtw_tdls_set_vht_op_mode_notify(padapter, pframe, pattrib, pmlmeext->cur_bwmode);
3050 }
3051 #endif
3052 }
3053
rtw_build_tdls_teardown_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)3054 void rtw_build_tdls_teardown_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
3055 {
3056 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3057 u8 *pftie = NULL, *pftie_mic = NULL, *plinkid_ie = NULL;
3058
3059 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3060 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3061 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3062 pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
3063
3064 if (pattrib->encrypt) {
3065 pftie = pframe;
3066 pftie_mic = pframe + 4;
3067 pframe = rtw_tdls_set_ftie(ptxmgmt
3068 , pframe
3069 , pattrib
3070 , ptdls_sta->ANonce
3071 , ptdls_sta->SNonce);
3072 }
3073
3074 plinkid_ie = pframe;
3075 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
3076 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3077 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
3078 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3079
3080 if (pattrib->encrypt && (rtw_tdls_is_driver_setup(padapter) == _TRUE))
3081 wpa_tdls_teardown_ftie_mic(ptdls_sta->tpk.kck, plinkid_ie, ptxmgmt->status_code, 1, 4, pftie, pftie_mic);
3082 }
3083
rtw_build_tdls_dis_req_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt)3084 void rtw_build_tdls_dis_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt)
3085 {
3086 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3087
3088 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3089 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3090 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3091 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
3092 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3093
3094 }
3095
rtw_build_tdls_dis_rsp_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,u8 privacy)3096 void rtw_build_tdls_dis_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, u8 privacy)
3097 {
3098 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3099 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3100 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3101 u8 *pframe_head, pktlen_index;
3102
3103 pktlen_index = pattrib->pktlen;
3104 pframe_head = pframe;
3105
3106 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_PUBLIC);
3107 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3108 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
3109 pframe = rtw_tdls_set_capability(padapter, pframe, pattrib);
3110
3111 pframe = rtw_tdls_set_supported_rate(padapter, pframe, pattrib);
3112
3113 pframe = rtw_tdls_set_sup_ch(padapter, pframe, pattrib);
3114
3115 if (privacy)
3116 pframe = rtw_tdls_set_rsnie(ptxmgmt, pframe, pattrib, _TRUE, NULL);
3117
3118 pframe = rtw_tdls_set_ext_cap(pframe, pattrib);
3119
3120 if (privacy) {
3121 pframe = rtw_tdls_set_ftie(ptxmgmt, pframe, pattrib, NULL, NULL);
3122 pframe = rtw_tdls_set_timeout_interval(ptxmgmt, pframe, pattrib, _TRUE, NULL);
3123 }
3124
3125 #ifdef CONFIG_80211N_HT
3126 if (pregistrypriv->ht_enable == _TRUE)
3127 pframe = rtw_tdls_set_ht_cap(padapter, pframe_head - pktlen_index, pattrib);
3128 #endif
3129
3130 pframe = rtw_tdls_set_bss_coexist(padapter, pframe, pattrib);
3131 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3132
3133 }
3134
3135
rtw_build_tdls_peer_traffic_indication_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)3136 void rtw_build_tdls_peer_traffic_indication_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
3137 {
3138
3139 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3140 u8 AC_queue = 0;
3141
3142 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3143 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3144 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3145 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
3146
3147 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
3148 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3149 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
3150 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3151
3152 /* PTI control */
3153 /* PU buffer status */
3154 if (ptdls_sta->uapsd_bk & BIT(1))
3155 AC_queue = BIT(0);
3156 if (ptdls_sta->uapsd_be & BIT(1))
3157 AC_queue = BIT(1);
3158 if (ptdls_sta->uapsd_vi & BIT(1))
3159 AC_queue = BIT(2);
3160 if (ptdls_sta->uapsd_vo & BIT(1))
3161 AC_queue = BIT(3);
3162 pframe = rtw_set_ie(pframe, _PTI_BUFFER_STATUS_, 1, &AC_queue, &(pattrib->pktlen));
3163
3164 }
3165
rtw_build_tdls_peer_traffic_rsp_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)3166 void rtw_build_tdls_peer_traffic_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
3167 {
3168
3169 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3170
3171 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3172 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3173 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3174 pframe = rtw_tdls_set_dialog(pframe, pattrib, ptxmgmt);
3175
3176 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
3177 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3178 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
3179 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3180 }
3181
3182 #ifdef CONFIG_TDLS_CH_SW
rtw_build_tdls_ch_switch_req_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)3183 void rtw_build_tdls_ch_switch_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
3184 {
3185 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3186 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3187 struct sta_priv *pstapriv = &padapter->stapriv;
3188 u16 switch_time = TDLS_CH_SWITCH_TIME * 1000, switch_timeout = TDLS_CH_SWITCH_TIMEOUT * 1000;
3189
3190 ptdls_sta->ch_switch_time = switch_time;
3191 ptdls_sta->ch_switch_timeout = switch_timeout;
3192
3193 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3194 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3195 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3196 pframe = rtw_tdls_set_target_ch(padapter, pframe, pattrib);
3197 pframe = rtw_tdls_set_reg_class(pframe, pattrib, ptdls_sta);
3198
3199 if (ptdlsinfo->chsw_info.ch_offset != HAL_PRIME_CHNL_OFFSET_DONT_CARE) {
3200 switch (ptdlsinfo->chsw_info.ch_offset) {
3201 case HAL_PRIME_CHNL_OFFSET_LOWER:
3202 pframe = rtw_tdls_set_second_channel_offset(pframe, pattrib, SCA);
3203 break;
3204 case HAL_PRIME_CHNL_OFFSET_UPPER:
3205 pframe = rtw_tdls_set_second_channel_offset(pframe, pattrib, SCB);
3206 break;
3207 }
3208 }
3209
3210 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
3211 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3212 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
3213 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3214
3215 pframe = rtw_tdls_set_ch_sw(pframe, pattrib, ptdls_sta);
3216
3217 }
3218
rtw_build_tdls_ch_switch_rsp_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe,struct tdls_txmgmt * ptxmgmt,struct sta_info * ptdls_sta)3219 void rtw_build_tdls_ch_switch_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe, struct tdls_txmgmt *ptxmgmt, struct sta_info *ptdls_sta)
3220 {
3221
3222 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3223 struct sta_priv *pstapriv = &padapter->stapriv;
3224
3225 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3226 pframe = rtw_tdls_set_category(pframe, pattrib, RTW_WLAN_CATEGORY_TDLS);
3227 pframe = rtw_tdls_set_action(pframe, pattrib, ptxmgmt);
3228 pframe = rtw_tdls_set_status_code(pframe, pattrib, ptxmgmt);
3229
3230 if (ptdls_sta->tdls_sta_state & TDLS_INITIATOR_STATE)
3231 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _FALSE);
3232 else if (ptdls_sta->tdls_sta_state & TDLS_RESPONDER_STATE)
3233 pframe = rtw_tdls_set_linkid(padapter, pframe, pattrib, _TRUE);
3234
3235 pframe = rtw_tdls_set_ch_sw(pframe, pattrib, ptdls_sta);
3236 }
3237 #endif
3238
3239 #ifdef CONFIG_WFD
rtw_build_tunneled_probe_req_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe)3240 void rtw_build_tunneled_probe_req_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe)
3241 {
3242 u8 i;
3243 _adapter *iface = NULL;
3244 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3245 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3246 struct wifidirect_info *pwdinfo;
3247
3248 u8 category = RTW_WLAN_CATEGORY_P2P;
3249 u8 WFA_OUI[3] = { 0x50, 0x6f, 0x9a};
3250 u8 probe_req = 4;
3251 u8 wfdielen = 0;
3252
3253 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3254 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
3255 pframe = rtw_set_fixed_ie(pframe, 3, WFA_OUI, &(pattrib->pktlen));
3256 pframe = rtw_set_fixed_ie(pframe, 1, &(probe_req), &(pattrib->pktlen));
3257
3258 for (i = 0; i < dvobj->iface_nums; i++) {
3259 iface = dvobj->padapters[i];
3260 if ((iface) && rtw_is_adapter_up(iface)) {
3261 pwdinfo = &iface->wdinfo;
3262 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
3263 wfdielen = build_probe_req_wfd_ie(pwdinfo, pframe);
3264 pframe += wfdielen;
3265 pattrib->pktlen += wfdielen;
3266 }
3267 }
3268 }
3269 }
3270
rtw_build_tunneled_probe_rsp_ies(_adapter * padapter,struct xmit_frame * pxmitframe,u8 * pframe)3271 void rtw_build_tunneled_probe_rsp_ies(_adapter *padapter, struct xmit_frame *pxmitframe, u8 *pframe)
3272 {
3273 u8 i;
3274 _adapter *iface = NULL;
3275 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3276 struct pkt_attrib *pattrib = &pxmitframe->attrib;
3277 struct wifidirect_info *pwdinfo;
3278 u8 category = RTW_WLAN_CATEGORY_P2P;
3279 u8 WFA_OUI[3] = { 0x50, 0x6f, 0x9a};
3280 u8 probe_rsp = 5;
3281 u8 wfdielen = 0;
3282
3283 pframe = rtw_tdls_set_payload_type(pframe, pattrib);
3284 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
3285 pframe = rtw_set_fixed_ie(pframe, 3, WFA_OUI, &(pattrib->pktlen));
3286 pframe = rtw_set_fixed_ie(pframe, 1, &(probe_rsp), &(pattrib->pktlen));
3287
3288 for (i = 0; i < dvobj->iface_nums; i++) {
3289 iface = dvobj->padapters[i];
3290 if ((iface) && rtw_is_adapter_up(iface)) {
3291 pwdinfo = &iface->wdinfo;
3292 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
3293 wfdielen = build_probe_resp_wfd_ie(pwdinfo, pframe, 1);
3294 pframe += wfdielen;
3295 pattrib->pktlen += wfdielen;
3296 }
3297 }
3298 }
3299 }
3300 #endif /* CONFIG_WFD */
3301
_tdls_tpk_timer_hdl(void * FunctionContext)3302 void _tdls_tpk_timer_hdl(void *FunctionContext)
3303 {
3304 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3305 struct tdls_txmgmt txmgmt;
3306
3307 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
3308 ptdls_sta->TPK_count++;
3309 /* TPK_timer expired in a second */
3310 /* Retry timer should set at least 301 sec. */
3311 if (ptdls_sta->TPK_count >= (ptdls_sta->TDLS_PeerKey_Lifetime - 3)) {
3312 RTW_INFO("[TDLS] %s, Re-Setup TDLS link with "MAC_FMT" since TPK lifetime expires!\n",
3313 __FUNCTION__, MAC_ARG(ptdls_sta->cmn.mac_addr));
3314 ptdls_sta->TPK_count = 0;
3315 _rtw_memcpy(txmgmt.peer, ptdls_sta->cmn.mac_addr, ETH_ALEN);
3316 issue_tdls_setup_req(ptdls_sta->padapter, &txmgmt, _FALSE);
3317 }
3318
3319 _set_timer(&ptdls_sta->TPK_timer, ONE_SEC);
3320 }
3321
3322 #ifdef CONFIG_TDLS_CH_SW
_tdls_ch_switch_timer_hdl(void * FunctionContext)3323 void _tdls_ch_switch_timer_hdl(void *FunctionContext)
3324 {
3325 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3326 _adapter *padapter = ptdls_sta->padapter;
3327 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
3328
3329 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_END_TO_BASE_CHNL);
3330 RTW_INFO("[TDLS] %s, can't get traffic from op_ch:%d\n", __func__, rtw_get_oper_ch(padapter));
3331 }
3332
_tdls_delay_timer_hdl(void * FunctionContext)3333 void _tdls_delay_timer_hdl(void *FunctionContext)
3334 {
3335 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3336 _adapter *padapter = ptdls_sta->padapter;
3337 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
3338
3339 RTW_INFO("[TDLS] %s, op_ch:%d, tdls_state:0x%08x\n", __func__, rtw_get_oper_ch(padapter), ptdls_sta->tdls_sta_state);
3340 pchsw_info->delay_switch_back = _TRUE;
3341 }
3342
_tdls_stay_on_base_chnl_timer_hdl(void * FunctionContext)3343 void _tdls_stay_on_base_chnl_timer_hdl(void *FunctionContext)
3344 {
3345 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3346 _adapter *padapter = ptdls_sta->padapter;
3347 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
3348
3349 if (ptdls_sta != NULL) {
3350 issue_tdls_ch_switch_req(padapter, ptdls_sta);
3351 pchsw_info->ch_sw_state |= TDLS_WAIT_CH_RSP_STATE;
3352 }
3353 }
3354
_tdls_ch_switch_monitor_timer_hdl(void * FunctionContext)3355 void _tdls_ch_switch_monitor_timer_hdl(void *FunctionContext)
3356 {
3357 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3358 _adapter *padapter = ptdls_sta->padapter;
3359 struct tdls_ch_switch *pchsw_info = &padapter->tdlsinfo.chsw_info;
3360
3361 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_CH_SW_END);
3362 RTW_INFO("[TDLS] %s, does not receive ch sw req\n", __func__);
3363 }
3364
3365 #endif
3366
_tdls_handshake_timer_hdl(void * FunctionContext)3367 void _tdls_handshake_timer_hdl(void *FunctionContext)
3368 {
3369 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3370 _adapter *padapter = NULL;
3371 struct tdls_txmgmt txmgmt;
3372
3373 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
3374 _rtw_memcpy(txmgmt.peer, ptdls_sta->cmn.mac_addr, ETH_ALEN);
3375 txmgmt.status_code = _RSON_TDLS_TEAR_UN_RSN_;
3376
3377 if (ptdls_sta != NULL) {
3378 padapter = ptdls_sta->padapter;
3379
3380 RTW_INFO("[TDLS] Handshake time out\n");
3381 if (ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE)
3382 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA);
3383 else
3384 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA_LOCALLY);
3385 }
3386 }
3387
_tdls_pti_timer_hdl(void * FunctionContext)3388 void _tdls_pti_timer_hdl(void *FunctionContext)
3389 {
3390 struct sta_info *ptdls_sta = (struct sta_info *)FunctionContext;
3391 _adapter *padapter = NULL;
3392 struct tdls_txmgmt txmgmt;
3393
3394 _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
3395 _rtw_memcpy(txmgmt.peer, ptdls_sta->cmn.mac_addr, ETH_ALEN);
3396 txmgmt.status_code = _RSON_TDLS_TEAR_TOOFAR_;
3397
3398 if (ptdls_sta != NULL) {
3399 padapter = ptdls_sta->padapter;
3400
3401 if (ptdls_sta->tdls_sta_state & TDLS_WAIT_PTR_STATE) {
3402 RTW_INFO("[TDLS] Doesn't receive PTR from peer dev:"MAC_FMT"; "
3403 "Send TDLS Tear Down\n", MAC_ARG(ptdls_sta->cmn.mac_addr));
3404 rtw_tdls_cmd(padapter, ptdls_sta->cmn.mac_addr, TDLS_TEARDOWN_STA);
3405 }
3406 }
3407 }
3408
rtw_init_tdls_timer(_adapter * padapter,struct sta_info * psta)3409 void rtw_init_tdls_timer(_adapter *padapter, struct sta_info *psta)
3410 {
3411 psta->padapter = padapter;
3412 rtw_init_timer(&psta->TPK_timer, padapter, _tdls_tpk_timer_hdl, psta);
3413 #ifdef CONFIG_TDLS_CH_SW
3414 rtw_init_timer(&psta->ch_sw_timer, padapter, _tdls_ch_switch_timer_hdl, psta);
3415 rtw_init_timer(&psta->delay_timer, padapter, _tdls_delay_timer_hdl, psta);
3416 rtw_init_timer(&psta->stay_on_base_chnl_timer, padapter, _tdls_stay_on_base_chnl_timer_hdl, psta);
3417 rtw_init_timer(&psta->ch_sw_monitor_timer, padapter, _tdls_ch_switch_monitor_timer_hdl, psta);
3418 #endif
3419 rtw_init_timer(&psta->handshake_timer, padapter, _tdls_handshake_timer_hdl, psta);
3420 rtw_init_timer(&psta->pti_timer, padapter, _tdls_pti_timer_hdl, psta);
3421 }
3422
rtw_cancel_tdls_timer(struct sta_info * psta)3423 void rtw_cancel_tdls_timer(struct sta_info *psta)
3424 {
3425 _cancel_timer_ex(&psta->TPK_timer);
3426 #ifdef CONFIG_TDLS_CH_SW
3427 _cancel_timer_ex(&psta->ch_sw_timer);
3428 _cancel_timer_ex(&psta->delay_timer);
3429 _cancel_timer_ex(&psta->stay_on_base_chnl_timer);
3430 _cancel_timer_ex(&psta->ch_sw_monitor_timer);
3431 #endif
3432 _cancel_timer_ex(&psta->handshake_timer);
3433 _cancel_timer_ex(&psta->pti_timer);
3434 }
3435
rtw_tdls_teardown_pre_hdl(_adapter * padapter,struct sta_info * psta)3436 void rtw_tdls_teardown_pre_hdl(_adapter *padapter, struct sta_info *psta)
3437 {
3438 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3439 struct sta_priv *pstapriv = &padapter->stapriv;
3440 _irqL irqL;
3441
3442 rtw_cancel_tdls_timer(psta);
3443
3444 _enter_critical_bh(&(pstapriv->sta_hash_lock), &irqL);
3445 if (ptdlsinfo->sta_cnt != 0)
3446 ptdlsinfo->sta_cnt--;
3447 _exit_critical_bh(&(pstapriv->sta_hash_lock), &irqL);
3448
3449 if (ptdlsinfo->sta_cnt < MAX_ALLOWED_TDLS_STA_NUM) {
3450 ptdlsinfo->sta_maximum = _FALSE;
3451 _rtw_memset(&ptdlsinfo->ss_record, 0x00, sizeof(struct tdls_ss_record));
3452 }
3453
3454 if (ptdlsinfo->sta_cnt == 0)
3455 rtw_tdls_set_link_established(padapter, _FALSE);
3456 else
3457 RTW_INFO("Remain tdls sta:%02x\n", ptdlsinfo->sta_cnt);
3458 }
3459
rtw_tdls_teardown_post_hdl(_adapter * padapter,struct sta_info * psta,u8 enqueue_cmd)3460 void rtw_tdls_teardown_post_hdl(_adapter *padapter, struct sta_info *psta, u8 enqueue_cmd)
3461 {
3462 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3463
3464 /* Clear cam */
3465 rtw_clearstakey_cmd(padapter, psta, enqueue_cmd);
3466
3467 /* Update sta media status */
3468 if (enqueue_cmd)
3469 rtw_sta_media_status_rpt_cmd(padapter, psta, 0);
3470 else
3471 rtw_sta_media_status_rpt(padapter, psta, 0);
3472
3473 /* Set RCR if necessary */
3474 if (ptdlsinfo->sta_cnt == 0) {
3475 if (enqueue_cmd)
3476 rtw_tdls_cmd(padapter, NULL, TDLS_RS_RCR);
3477 else
3478 rtw_hal_rcr_set_chk_bssid(padapter, MLME_TDLS_NOLINK);
3479 }
3480
3481 /* Free tdls sta info */
3482 rtw_free_stainfo(padapter, psta);
3483 }
3484
rtw_tdls_is_driver_setup(_adapter * padapter)3485 int rtw_tdls_is_driver_setup(_adapter *padapter)
3486 {
3487 return padapter->tdlsinfo.driver_setup;
3488 }
3489
rtw_tdls_action_txt(enum TDLS_ACTION_FIELD action)3490 const char *rtw_tdls_action_txt(enum TDLS_ACTION_FIELD action)
3491 {
3492 switch (action) {
3493 case TDLS_SETUP_REQUEST:
3494 return "TDLS_SETUP_REQUEST";
3495 case TDLS_SETUP_RESPONSE:
3496 return "TDLS_SETUP_RESPONSE";
3497 case TDLS_SETUP_CONFIRM:
3498 return "TDLS_SETUP_CONFIRM";
3499 case TDLS_TEARDOWN:
3500 return "TDLS_TEARDOWN";
3501 case TDLS_PEER_TRAFFIC_INDICATION:
3502 return "TDLS_PEER_TRAFFIC_INDICATION";
3503 case TDLS_CHANNEL_SWITCH_REQUEST:
3504 return "TDLS_CHANNEL_SWITCH_REQUEST";
3505 case TDLS_CHANNEL_SWITCH_RESPONSE:
3506 return "TDLS_CHANNEL_SWITCH_RESPONSE";
3507 case TDLS_PEER_PSM_REQUEST:
3508 return "TDLS_PEER_PSM_REQUEST";
3509 case TDLS_PEER_PSM_RESPONSE:
3510 return "TDLS_PEER_PSM_RESPONSE";
3511 case TDLS_PEER_TRAFFIC_RESPONSE:
3512 return "TDLS_PEER_TRAFFIC_RESPONSE";
3513 case TDLS_DISCOVERY_REQUEST:
3514 return "TDLS_DISCOVERY_REQUEST";
3515 case TDLS_DISCOVERY_RESPONSE:
3516 return "TDLS_DISCOVERY_RESPONSE";
3517 default:
3518 return "UNKNOWN";
3519 }
3520 }
3521
3522 #endif /* CONFIG_TDLS */
3523