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