drivers/net/wireless/rockchip_wlan/rtl8723cs/core/rtw_tdls.c

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