drivers/net/wireless/rockchip_wlan/rtl8723bu/core/rtw_vht.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_VHT_C
  21
  22 #include <drv_types.h>
  23
  24 #ifdef CONFIG_80211AC_VHT
  25 //                              20/40/80,       ShortGI,        MCS Rate
  26 const u16 VHT_MCS_DATA_RATE[3][2][30] =
  27         {       {       {13, 26, 39, 52, 78, 104, 117, 130, 156, 156,
  28                          26, 52, 78, 104, 156, 208, 234, 260, 312, 312,
  29                          39, 78, 117, 156, 234, 312, 351, 390, 468, 520},                       // Long GI, 20MHz
  30                         {14, 29, 43, 58, 87, 116, 130, 144, 173, 173,
  31                         29, 58, 87, 116, 173, 231, 260, 289, 347, 347,
  32                         43,     87, 130, 173, 260, 347,390,     433,    520, 578}       },              // Short GI, 20MHz
  33                 {       {27, 54, 81, 108, 162, 216, 243, 270, 324, 360,
  34                         54, 108, 162, 216, 324, 432, 486, 540, 648, 720,
  35                         81, 162, 243, 324, 486, 648, 729, 810, 972, 1080},              // Long GI, 40MHz
  36                         {30, 60, 90, 120, 180, 240, 270, 300,360, 400,
  37                         60, 120, 180, 240, 360, 480, 540, 600, 720, 800,
  38                         90, 180, 270, 360, 540, 720, 810, 900, 1080, 1200}},            // Short GI, 40MHz
  39                 {       {59, 117,  176, 234, 351, 468, 527, 585, 702, 780,
  40                         117, 234, 351, 468, 702, 936, 1053, 1170, 1404, 1560,
  41                         176, 351, 527, 702, 1053, 1404, 1580, 1755, 2106, 2106},        // Long GI, 80MHz
  42                         {65, 130, 195, 260, 390, 520, 585, 650, 780, 867,
  43                         130, 260, 390, 520, 780, 1040, 1170, 1300, 1560,1734,
  44                         195, 390, 585, 780, 1170, 1560, 1755, 1950, 2340, 2340} }       // Short GI, 80MHz
  45         };
  46
  47 u8      rtw_get_vht_highest_rate(u8 *pvht_mcs_map)
  48 {
  49         u8      i, j;
  50         u8      bit_map;
  51         u8      vht_mcs_rate = 0;
  52
  53         for(i = 0; i < 2; i++)
  54         {
  55                 if(pvht_mcs_map[i] != 0xff)
  56                 {
  57                         for(j = 0; j < 8; j += 2)
  58                         {
  59                                 bit_map = (pvht_mcs_map[i] >> j) & 3;
  60
  61                                 if(bit_map != 3)
  62                                         vht_mcs_rate = MGN_VHT1SS_MCS7 + 10*j/2 + i*40 + bit_map;  //VHT rate indications begin from 0x90
  63                         }
  64                 }
  65         }
  66
  67         /* DBG_871X("HighestVHTMCSRate is %x\n", vht_mcs_rate); */
  68         return vht_mcs_rate;
  69 }
  70
  71 u8      rtw_vht_mcsmap_to_nss(u8 *pvht_mcs_map)
  72 {
  73         u8      i, j;
  74         u8      bit_map;
  75         u8      nss = 0;
  76
  77         for(i = 0; i < 2; i++)
  78         {
  79                 if(pvht_mcs_map[i] != 0xff)
  80                 {
  81                         for(j = 0; j < 8; j += 2)
  82                         {
  83                                 bit_map = (pvht_mcs_map[i] >> j) & 3;
  84
  85                                 if(bit_map != 3)
  86                                         nss++;
  87                         }
  88                 }
  89         }
  90
  91         DBG_871X("%s : %dSS\n", __FUNCTION__, nss);
  92         return nss;
  93 }
  94
  95 void    rtw_vht_nss_to_mcsmap(u8 nss, u8 *target_mcs_map, u8 *cur_mcs_map)
  96 {
  97         u8      i, j;
  98         u8      cur_rate, target_rate;
  99
 100         for(i = 0; i < 2; i++)
 101         {
 102                 target_mcs_map[i] = 0;
 103                 for(j = 0; j < 8; j+=2)
 104                 {
 105                         cur_rate = (cur_mcs_map[i] >> j) & 3;
 106                         if(cur_rate == 3)  //0x3 indicates not supported that num of SS
 107                                 target_rate = 3;
 108                         else if(nss <= ((j/2)+i*4))
 109                                 target_rate = 3;
 110                         else
 111                                 target_rate = cur_rate;
 112
 113                         target_mcs_map[i] |= (target_rate << j);
 114                 }
 115         }
 116
 117         //DBG_871X("%s : %dSS\n", __FUNCTION__, nss);
 118 }
 119
 120 u16     rtw_vht_mcs_to_data_rate(u8 bw, u8 short_GI, u8 vht_mcs_rate)
 121 {
 122         if(vht_mcs_rate > MGN_VHT3SS_MCS9)
 123                 vht_mcs_rate = MGN_VHT3SS_MCS9;
 124         /* DBG_871X("bw=%d, short_GI=%d, ((vht_mcs_rate - MGN_VHT1SS_MCS0)&0x3f)=%d\n", bw, short_GI, ((vht_mcs_rate - MGN_VHT1SS_MCS0)&0x3f)); */
 125         return VHT_MCS_DATA_RATE[bw][short_GI][((vht_mcs_rate - MGN_VHT1SS_MCS0)&0x3f)];
 126 }
 127
 128 void    rtw_vht_use_default_setting(_adapter *padapter)
 129 {
 130         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 131         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 132         struct registry_priv    *pregistrypriv = &padapter->registrypriv;
 133         BOOLEAN         bHwLDPCSupport = _FALSE, bHwSTBCSupport = _FALSE;
 134         BOOLEAN         bHwSupportBeamformer = _FALSE, bHwSupportBeamformee = _FALSE;
 135         u8      rf_type = 0;
 136
 137         pvhtpriv->sgi_80m = TEST_FLAG(pregistrypriv->short_gi, BIT2) ? _TRUE : _FALSE;
 138
 139         // LDPC support
 140         rtw_hal_get_def_var(padapter, HAL_DEF_RX_LDPC, (u8 *)&bHwLDPCSupport);
 141         CLEAR_FLAGS(pvhtpriv->ldpc_cap);
 142         if(bHwLDPCSupport)
 143         {
 144                 if(TEST_FLAG(pregistrypriv->ldpc_cap, BIT0))
 145                         SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX);
 146         }
 147         rtw_hal_get_def_var(padapter, HAL_DEF_TX_LDPC, (u8 *)&bHwLDPCSupport);
 148         if(bHwLDPCSupport)
 149         {
 150                 if(TEST_FLAG(pregistrypriv->ldpc_cap, BIT1))
 151                         SET_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX);
 152         }
 153         if (pvhtpriv->ldpc_cap)
 154                 DBG_871X("[VHT] Support LDPC = 0x%02X\n", pvhtpriv->ldpc_cap);
 155
 156         // STBC
 157         rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport);
 158         CLEAR_FLAGS(pvhtpriv->stbc_cap);
 159         if(bHwSTBCSupport)
 160         {
 161                 if(TEST_FLAG(pregistrypriv->stbc_cap, BIT1))
 162                         SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX);
 163         }
 164         rtw_hal_get_def_var(padapter, HAL_DEF_RX_STBC, (u8 *)&bHwSTBCSupport);
 165         if(bHwSTBCSupport)
 166         {
 167                 if(TEST_FLAG(pregistrypriv->stbc_cap, BIT0))
 168                         SET_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX);
 169         }
 170         if (pvhtpriv->stbc_cap)
 171                 DBG_871X("[VHT] Support STBC = 0x%02X\n", pvhtpriv->stbc_cap);
 172
 173         // Beamforming setting
 174         rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer);
 175         rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE, (u8 *)&bHwSupportBeamformee);
 176         CLEAR_FLAGS(pvhtpriv->beamform_cap);
 177         if(TEST_FLAG(pregistrypriv->beamform_cap, BIT0) && bHwSupportBeamformer)
 178         {
 179                 SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
 180                 DBG_871X("[VHT] Support Beamformer\n");
 181         }
 182         if(TEST_FLAG(pregistrypriv->beamform_cap, BIT1) && bHwSupportBeamformee)
 183         {
 184                 SET_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
 185                 DBG_871X("[VHT] Support Beamformee\n");
 186         }
 187
 188         pvhtpriv->ampdu_len = pregistrypriv->ampdu_factor;
 189
 190         rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 191
 192         if (rf_type == RF_3T3R)
 193                 pvhtpriv->vht_mcs_map[0] = 0xea;        /* support 1SS MCS 0~9 2SS MCS 0~9 3SS MCS 0~9 */
 194         else if(rf_type == RF_2T2R)
 195                 pvhtpriv->vht_mcs_map[0] = 0xfa;        /* support 1SS MCS 0~9 2SS MCS 0~9 */
 196         else
 197                 pvhtpriv->vht_mcs_map[0] = 0xfe;        /* Only support 1SS MCS 0~9; */
 198         pvhtpriv->vht_mcs_map[1] = 0xff;
 199
 200         if(pregistrypriv->vht_rate_sel == 1)
 201         {
 202                 pvhtpriv->vht_mcs_map[0] = 0xfc;        // support 1SS MCS 0~7
 203         }
 204         else if(pregistrypriv->vht_rate_sel == 2)
 205         {
 206                 pvhtpriv->vht_mcs_map[0] = 0xfd;        // Support 1SS MCS 0~8
 207         }
 208         else if(pregistrypriv->vht_rate_sel == 3)
 209         {
 210                 pvhtpriv->vht_mcs_map[0] = 0xfe;        // Support 1SS MCS 0~9
 211         }
 212         else if(pregistrypriv->vht_rate_sel == 4)
 213         {
 214                 pvhtpriv->vht_mcs_map[0] = 0xf0;        // support 1SS MCS 0~7 2SS MCS 0~7
 215         }
 216         else if(pregistrypriv->vht_rate_sel == 5)
 217         {
 218                 pvhtpriv->vht_mcs_map[0] = 0xf5;        // support 1SS MCS 0~8 2SS MCS 0~8
 219         }
 220         else if(pregistrypriv->vht_rate_sel == 6)
 221         {
 222                 pvhtpriv->vht_mcs_map[0] = 0xfa;        // support 1SS MCS 0~9 2SS MCS 0~9
 223         }
 224         else if(pregistrypriv->vht_rate_sel == 7)
 225         {
 226                 pvhtpriv->vht_mcs_map[0] = 0xf8;        // support 1SS MCS 0-7 2SS MCS 0~9
 227         }
 228         else if(pregistrypriv->vht_rate_sel == 8)
 229         {
 230                 pvhtpriv->vht_mcs_map[0] = 0xf9;        // support 1SS MCS 0-8 2SS MCS 0~9
 231         }
 232         else if(pregistrypriv->vht_rate_sel == 9)
 233         {
 234                 pvhtpriv->vht_mcs_map[0] = 0xf4;        // support 1SS MCS 0-7 2SS MCS 0~8
 235         }
 236
 237         pvhtpriv->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv->vht_mcs_map);
 238 }
 239
 240 u64     rtw_vht_rate_to_bitmap(u8 *pVHTRate)
 241 {
 242
 243         u8      i,j , tmpRate;
 244         u64     RateBitmap = 0;
 245         u8 Bits_3ss = 6;
 246
 247         for(i = j= 0; i < Bits_3ss; i+=2, j+=10)
 248         {
 249                 /* every two bits means single sptial stream */
 250                 tmpRate = (pVHTRate[0] >> i) & 3;
 251
 252                 switch(tmpRate){
 253                 case 2:
 254                         RateBitmap = RateBitmap | (0x03ff << j);
 255                         break;
 256                 case 1:
 257                         RateBitmap = RateBitmap | (0x01ff << j);
 258                 break;
 259
 260                 case 0:
 261                         RateBitmap = RateBitmap | (0x00ff << j);
 262                 break;
 263
 264                 default:
 265                         break;
 266                 }
 267         }
 268         DBG_871X("RateBitmap=%016llx , pVHTRate[0]=%02x\n", RateBitmap, pVHTRate[0]);
 269         return RateBitmap;
 270 }
 271
 272 void    update_sta_vht_info_apmode(_adapter *padapter, PVOID sta)
 273 {
 274         struct sta_info *psta = (struct sta_info *)sta;
 275         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 276         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 277         struct vht_priv *pvhtpriv_ap = &pmlmepriv->vhtpriv;
 278         struct vht_priv *pvhtpriv_sta = &psta->vhtpriv;
 279         struct ht_priv          *phtpriv_sta = &psta->htpriv;
 280         u8      cur_ldpc_cap=0, cur_stbc_cap=0, cur_beamform_cap=0, bw_mode = 0;
 281         u8      *pcap_mcs;
 282
 283         if (pvhtpriv_sta->vht_option == _FALSE) {
 284                 return;
 285         }
 286
 287         bw_mode = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(&pvhtpriv_sta->vht_op_mode_notify);
 288
 289         //if (bw_mode > psta->bw_mode)
 290         psta->bw_mode = bw_mode;
 291
 292         // B4 Rx LDPC
 293         if (TEST_FLAG(pvhtpriv_ap->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
 294                 GET_VHT_CAPABILITY_ELE_RX_LDPC(pvhtpriv_sta->vht_cap))
 295         {
 296                 SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
 297                 DBG_871X("Current STA(%d) VHT LDPC = %02X\n", psta->aid, cur_ldpc_cap);
 298         }
 299         pvhtpriv_sta->ldpc_cap = cur_ldpc_cap;
 300
 301         if (psta->bw_mode > pmlmeext->cur_bwmode)
 302                 psta->bw_mode = pmlmeext->cur_bwmode;
 303
 304         if (psta->bw_mode == CHANNEL_WIDTH_80) {
 305                 // B5 Short GI for 80 MHz
 306                 pvhtpriv_sta->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(pvhtpriv_sta->vht_cap) & pvhtpriv_ap->sgi_80m) ? _TRUE : _FALSE;
 307                 //DBG_871X("Current STA ShortGI80MHz = %d\n", pvhtpriv_sta->sgi_80m);
 308         } else if (psta->bw_mode >= CHANNEL_WIDTH_160) {
 309                 // B5 Short GI for 80 MHz
 310                 pvhtpriv_sta->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI160M(pvhtpriv_sta->vht_cap) & pvhtpriv_ap->sgi_80m) ? _TRUE : _FALSE;
 311                 //DBG_871X("Current STA ShortGI160MHz = %d\n", pvhtpriv_sta->sgi_80m);
 312         }
 313
 314         // B8 B9 B10 Rx STBC
 315         if (TEST_FLAG(pvhtpriv_ap->stbc_cap, STBC_VHT_ENABLE_TX) &&
 316                 GET_VHT_CAPABILITY_ELE_RX_STBC(pvhtpriv_sta->vht_cap))
 317         {
 318                 SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
 319                 DBG_871X("Current STA(%d) VHT STBC = %02X\n", psta->aid, cur_stbc_cap);
 320         }
 321         pvhtpriv_sta->stbc_cap = cur_stbc_cap;
 322
 323         // B11 SU Beamformer Capable, the target supports Beamformer and we are Beamformee
 324         if (TEST_FLAG(pvhtpriv_ap->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE) &&
 325                 GET_VHT_CAPABILITY_ELE_SU_BFEE(pvhtpriv_sta->vht_cap))
 326         {
 327                 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
 328         }
 329
 330         // B12 SU Beamformee Capable, the target supports Beamformee and we are Beamformer
 331         if (TEST_FLAG(pvhtpriv_ap->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE) &&
 332                 GET_VHT_CAPABILITY_ELE_SU_BFER(pvhtpriv_sta->vht_cap))
 333         {
 334                 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
 335         }
 336         pvhtpriv_sta->beamform_cap = cur_beamform_cap;
 337         if (cur_beamform_cap) {
 338                 DBG_871X("Current STA(%d) VHT Beamforming Setting = %02X\n", psta->aid, cur_beamform_cap);
 339         }
 340
 341         // B23 B24 B25 Maximum A-MPDU Length Exponent
 342         pvhtpriv_sta->ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pvhtpriv_sta->vht_cap);
 343
 344         pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pvhtpriv_sta->vht_cap);
 345         _rtw_memcpy(pvhtpriv_sta->vht_mcs_map, pcap_mcs, 2);
 346
 347         pvhtpriv_sta->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv_sta->vht_mcs_map);
 348
 349 }
 350
 351 void    update_hw_vht_param(_adapter *padapter)
 352 {
 353         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 354         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 355         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 356         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 357         u8      ht_AMPDU_len;
 358
 359         ht_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
 360
 361         if(pvhtpriv->ampdu_len > ht_AMPDU_len)
 362                 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&pvhtpriv->ampdu_len));
 363 }
 364
 365 void VHT_caps_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
 366 {
 367         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 368         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 369         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 370         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 371         u8      cur_ldpc_cap=0, cur_stbc_cap=0, cur_beamform_cap=0, rf_type = RF_1T1R;
 372         u8      *pcap_mcs;
 373         u8      vht_mcs[2];
 374
 375         if(pIE==NULL) return;
 376
 377         if(pvhtpriv->vht_option == _FALSE)      return;
 378
 379         pmlmeinfo->VHT_enable = 1;
 380
 381         // B4 Rx LDPC
 382         if (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX) &&
 383                 GET_VHT_CAPABILITY_ELE_RX_LDPC(pIE->data))
 384         {
 385                 SET_FLAG(cur_ldpc_cap, (LDPC_VHT_ENABLE_TX | LDPC_VHT_CAP_TX));
 386                 DBG_871X("Current VHT LDPC Setting = %02X\n", cur_ldpc_cap);
 387         }
 388         pvhtpriv->ldpc_cap = cur_ldpc_cap;
 389
 390         // B5 Short GI for 80 MHz
 391         pvhtpriv->sgi_80m = (GET_VHT_CAPABILITY_ELE_SHORT_GI80M(pIE->data) & pvhtpriv->sgi_80m) ? _TRUE : _FALSE;
 392         //DBG_871X("Current ShortGI80MHz = %d\n", pvhtpriv->sgi_80m);
 393
 394         // B8 B9 B10 Rx STBC
 395         if (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX) &&
 396                 GET_VHT_CAPABILITY_ELE_RX_STBC(pIE->data))
 397         {
 398                 SET_FLAG(cur_stbc_cap, (STBC_VHT_ENABLE_TX | STBC_VHT_CAP_TX));
 399                 DBG_871X("Current VHT STBC Setting = %02X\n", cur_stbc_cap);
 400         }
 401         pvhtpriv->stbc_cap = cur_stbc_cap;
 402
 403         // B11 SU Beamformer Capable, the target supports Beamformer and we are Beamformee
 404         if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE) &&
 405                 GET_VHT_CAPABILITY_ELE_SU_BFEE(pIE->data))
 406         {
 407                 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE);
 408         }
 409
 410         // B12 SU Beamformee Capable, the target supports Beamformee and we are Beamformer
 411         if (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE) &&
 412                 GET_VHT_CAPABILITY_ELE_SU_BFER(pIE->data))
 413         {
 414                 SET_FLAG(cur_beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE);
 415         }
 416         pvhtpriv->beamform_cap = cur_beamform_cap;
 417         if (cur_beamform_cap) {
 418                 DBG_871X("Current VHT Beamforming Setting = %02X\n", cur_beamform_cap);
 419         }
 420
 421         // B23 B24 B25 Maximum A-MPDU Length Exponent
 422         pvhtpriv->ampdu_len = GET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pIE->data);
 423
 424         pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pIE->data);
 425         _rtw_memcpy(vht_mcs, pcap_mcs, 2);
 426
 427         rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 428         if ((rf_type == RF_1T1R) || (rf_type == RF_1T2R))
 429                 vht_mcs[0] |= 0xfc;
 430         else if (rf_type == RF_2T2R)
 431                 vht_mcs[0] |= 0xf0;
 432         else if (rf_type == RF_3T3R)
 433                 vht_mcs[0] |= 0xc0;
 434
 435         _rtw_memcpy(pvhtpriv->vht_mcs_map, vht_mcs, 2);
 436
 437         pvhtpriv->vht_highest_rate = rtw_get_vht_highest_rate(pvhtpriv->vht_mcs_map);
 438 }
 439
 440 void VHT_operation_handler(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
 441 {
 442         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 443         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 444
 445         if(pIE==NULL) return;
 446
 447         if(pvhtpriv->vht_option == _FALSE)      return;
 448 }
 449
 450 void rtw_process_vht_op_mode_notify(_adapter *padapter, u8 *pframe, PVOID sta)
 451 {
 452         struct sta_info         *psta = (struct sta_info *)sta;
 453         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 454         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 455         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 456         u8      target_bw;
 457         u8      target_rxss, current_rxss;
 458         u8      update_ra = _FALSE;
 459         u8      vht_mcs_map[2] = {};
 460
 461         if(pvhtpriv->vht_option == _FALSE)
 462                 return;
 463
 464         target_bw = GET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(pframe);
 465         target_rxss = (GET_VHT_OPERATING_MODE_FIELD_RX_NSS(pframe)+1);
 466
 467         if (target_bw != psta->bw_mode) {
 468                 if (target_bw <= (padapter->registrypriv.bw_mode >> 4)) {
 469                         update_ra = _TRUE;
 470                         psta->bw_mode = target_bw;
 471                 }
 472         }
 473
 474         current_rxss = rtw_vht_mcsmap_to_nss(psta->vhtpriv.vht_mcs_map);
 475         if (target_rxss != current_rxss) {
 476                 update_ra = _TRUE;
 477
 478                 rtw_vht_nss_to_mcsmap(target_rxss, vht_mcs_map, psta->vhtpriv.vht_mcs_map);
 479                 _rtw_memcpy(psta->vhtpriv.vht_mcs_map, vht_mcs_map, 2);
 480
 481                 rtw_hal_update_sta_rate_mask(padapter, psta);
 482         }
 483
 484         if (update_ra) {
 485                 rtw_dm_ra_mask_wk_cmd(padapter, (u8 *)psta);
 486         }
 487 }
 488
 489 u32     rtw_build_vht_operation_ie(_adapter *padapter, u8 *pbuf, u8 channel)
 490 {
 491         struct registry_priv    *pregistrypriv = &padapter->registrypriv;
 492         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 493         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 494         //struct mlme_ext_priv  *pmlmeext = &padapter->mlmeextpriv;
 495         u8      ChnlWidth, center_freq, bw_mode;
 496         u32     len = 0;
 497         u8      operation[5];
 498
 499         _rtw_memset(operation, 0, 5);
 500
 501         bw_mode = pregistrypriv->bw_mode >> 4;
 502
 503         if (bw_mode >= CHANNEL_WIDTH_80)
 504         {
 505                 center_freq = rtw_get_center_ch(channel, bw_mode, HAL_PRIME_CHNL_OFFSET_LOWER);
 506                 ChnlWidth = 1;
 507         }
 508         else
 509         {
 510                 center_freq = 0;
 511                 ChnlWidth = 0;
 512         }
 513
 514
 515         SET_VHT_OPERATION_ELE_CHL_WIDTH(operation, ChnlWidth);
 516         //center frequency
 517         SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ1(operation, center_freq);//Todo: need to set correct center channel
 518         SET_VHT_OPERATION_ELE_CHL_CENTER_FREQ2(operation,0);
 519         operation[3] = 0xff;
 520         operation[4] = 0xff;
 521
 522         rtw_set_ie(pbuf, EID_VHTOperation, 5, operation, &len);
 523
 524         return len;
 525 }
 526
 527 u32     rtw_build_vht_op_mode_notify_ie(_adapter *padapter, u8 *pbuf, u8 bw)
 528 {
 529         //struct registry_priv *pregistrypriv = &padapter->registrypriv;
 530         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 531         struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
 532         u32     len = 0;
 533         u8      opmode = 0, rf_type = 0;
 534         u8      chnl_width, rx_nss;
 535
 536         chnl_width = bw;
 537
 538         rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 539         if(rf_type == RF_3T3R)
 540                 rx_nss = 3;
 541         else if(rf_type == RF_2T2R)
 542                 rx_nss = 2;
 543         else
 544                 rx_nss = 1;
 545
 546         SET_VHT_OPERATING_MODE_FIELD_CHNL_WIDTH(&opmode, chnl_width);
 547         SET_VHT_OPERATING_MODE_FIELD_RX_NSS(&opmode, (rx_nss-1));
 548         SET_VHT_OPERATING_MODE_FIELD_RX_NSS_TYPE(&opmode, 0); //Todo
 549
 550         pvhtpriv->vht_op_mode_notify = opmode;
 551
 552         pbuf = rtw_set_ie(pbuf, EID_OpModeNotification, 1, &opmode, &len);
 553
 554         return len;
 555 }
 556
 557 u32     rtw_build_vht_cap_ie(_adapter *padapter, u8 *pbuf)
 558 {
 559         u8      bw, rf_type;
 560         u16     HighestRate;
 561         u8      *pcap, *pcap_mcs;
 562         u32     len = 0;
 563         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 564         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 565         struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
 566
 567         pcap = pvhtpriv->vht_cap;
 568         _rtw_memset(pcap, 0, 32);
 569
 570         /* B0 B1 Maximum MPDU Length */
 571         SET_VHT_CAPABILITY_ELE_MAX_MPDU_LENGTH(pcap, 2);
 572
 573         // B2 B3 Supported Channel Width Set
 574         SET_VHT_CAPABILITY_ELE_CHL_WIDTH(pcap, 0);  //indicate we don't support neither 160M nor 80+80M bandwidth.
 575
 576         // B4 Rx LDPC
 577         if(TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX))
 578         {
 579                 SET_VHT_CAPABILITY_ELE_RX_LDPC(pcap, 1);
 580         }
 581
 582         // B5 ShortGI for 80MHz
 583         SET_VHT_CAPABILITY_ELE_SHORT_GI80M(pcap, pvhtpriv->sgi_80m? 1 : 0); // We can receive Short GI of 80M
 584
 585         // B6 ShortGI for 160MHz
 586         //SET_VHT_CAPABILITY_ELE_SHORT_GI160M(pcap, pvhtpriv->sgi_80m? 1 : 0);
 587
 588         // B7 Tx STBC
 589         if(TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX))
 590         {
 591                 SET_VHT_CAPABILITY_ELE_TX_STBC(pcap, 1);
 592         }
 593
 594         // B8 B9 B10 Rx STBC
 595         if(TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX))
 596         {
 597                 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 598                 if ((rf_type == RF_2T2R) || (rf_type == RF_1T2R)) {
 599                         SET_VHT_CAPABILITY_ELE_RX_STBC(pcap, 2);
 600                 }
 601                 else if (rf_type == RF_1T1R) {
 602                         SET_VHT_CAPABILITY_ELE_RX_STBC(pcap, 1);
 603                 }
 604         }
 605
 606         // B11 SU Beamformer Capable
 607         if(TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE))
 608         {
 609                 SET_VHT_CAPABILITY_ELE_SU_BFER(pcap, 1);
 610                 // B16 17 18 Number of Sounding Dimensions
 611                 SET_VHT_CAPABILITY_ELE_SOUNDING_DIMENSIONS(pcap, 1);
 612         }
 613
 614         // B12 SU Beamformee Capable
 615         if(TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE))
 616         {
 617                 SET_VHT_CAPABILITY_ELE_SU_BFEE(pcap, 1);
 618                 // B13 14 15 Compressed Steering Number of Beamformer Antennas Supported
 619                 SET_VHT_CAPABILITY_ELE_BFER_ANT_SUPP(pcap, 1);
 620         }
 621
 622         // B19 MU Beamformer Capable
 623         SET_VHT_CAPABILITY_ELE_MU_BFER(pcap, 0);  //HW don't support mu bfee/bfer
 624         // B20 MU Beamformee Capable
 625         SET_VHT_CAPABILITY_ELE_MU_BFEE(pcap, 0);
 626         // B21 VHT TXOP PS
 627         SET_VHT_CAPABILITY_ELE_TXOP_PS(pcap, 0);
 628         // B22 +HTC-VHT Capable
 629         SET_VHT_CAPABILITY_ELE_HTC_VHT(pcap, 1);
 630         // B23 24 25 Maximum A-MPDU Length Exponent
 631         if (pregistrypriv->ampdu_factor != 0xFE)
 632         {
 633                 SET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pcap, pregistrypriv->ampdu_factor);
 634         }
 635         else
 636         {
 637                 SET_VHT_CAPABILITY_ELE_MAX_RXAMPDU_FACTOR(pcap, 7);
 638         }
 639         // B26 27 VHT Link Adaptation Capable
 640         SET_VHT_CAPABILITY_ELE_LINK_ADAPTION(pcap, 0);
 641
 642         pcap_mcs = GET_VHT_CAPABILITY_ELE_RX_MCS(pcap);
 643         _rtw_memcpy(pcap_mcs, pvhtpriv->vht_mcs_map, 2);
 644
 645         pcap_mcs = GET_VHT_CAPABILITY_ELE_TX_MCS(pcap);
 646         _rtw_memcpy(pcap_mcs, pvhtpriv->vht_mcs_map, 2);
 647
 648         bw = (pregistrypriv->bw_mode >> 4);
 649         HighestRate = VHT_MCS_DATA_RATE[bw][pvhtpriv->sgi_80m][((pvhtpriv->vht_highest_rate - MGN_VHT1SS_MCS0)&0x3f)];
 650         HighestRate = (HighestRate+1) >> 1;
 651
 652         SET_VHT_CAPABILITY_ELE_MCS_RX_HIGHEST_RATE(pcap, HighestRate); //indicate we support highest rx rate is 600Mbps.
 653         SET_VHT_CAPABILITY_ELE_MCS_TX_HIGHEST_RATE(pcap, HighestRate); //indicate we support highest tx rate is 600Mbps.
 654
 655         pbuf = rtw_set_ie(pbuf, EID_VHTCapability, 12, pcap, &len);
 656
 657         return len;
 658 }
 659
 660 u32 rtw_restructure_vht_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len)
 661 {
 662         u32     ielen=0, out_len=0;
 663         u8      cap_len=0, notify_len=0, notify_bw=0, operation_bw=0, supported_chnl_width=0;
 664         u8      *p, *pframe;
 665         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 666         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 667         struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
 668
 669         rtw_vht_use_default_setting(padapter);
 670
 671         p = rtw_get_ie(in_ie+12, EID_VHTCapability, &ielen, in_len-12);
 672         if (p && ielen>0) {
 673                 supported_chnl_width = GET_VHT_CAPABILITY_ELE_CHL_WIDTH(p+2);
 674
 675                 // VHT Capabilities element
 676                 cap_len = rtw_build_vht_cap_ie(padapter, out_ie+*pout_len);
 677                 *pout_len += cap_len;
 678
 679                 // Get HT BW
 680                 p = rtw_get_ie(in_ie+12, _HT_EXTRA_INFO_IE_, &ielen, in_len-12);
 681                 if (p && ielen>0) {
 682                         struct HT_info_element *pht_info = (struct HT_info_element *)(p+2);
 683                         if (pht_info->infos[0] & BIT(2))
 684                                 operation_bw = CHANNEL_WIDTH_40;
 685                         else
 686                                 operation_bw = CHANNEL_WIDTH_20;
 687                 }
 688
 689                 // VHT Operation element
 690                 p = rtw_get_ie(in_ie+12, EID_VHTOperation, &ielen, in_len-12);
 691                 if (p && ielen>0) {
 692                         out_len = *pout_len;
 693                         if (GET_VHT_OPERATION_ELE_CHL_WIDTH(p+2) >= 1) {
 694                                 if (supported_chnl_width == 2)
 695                                         operation_bw = CHANNEL_WIDTH_80_80;
 696                                 else if (supported_chnl_width == 1)
 697                                         operation_bw = CHANNEL_WIDTH_160;
 698                                 else
 699                                         operation_bw = CHANNEL_WIDTH_80;
 700                         }
 701                         pframe = rtw_set_ie(out_ie+out_len, EID_VHTOperation, ielen, p+2 , pout_len);
 702                 }
 703
 704                 notify_bw = pregistrypriv->bw_mode >> 4;
 705
 706                 if (notify_bw > operation_bw)
 707                         notify_bw = operation_bw;
 708
 709                 // Operating Mode Notification element
 710                 notify_len = rtw_build_vht_op_mode_notify_ie(padapter, out_ie+*pout_len, notify_bw);
 711                 *pout_len += notify_len;
 712
 713                 pvhtpriv->vht_option = _TRUE;
 714         }
 715
 716         return (pvhtpriv->vht_option);
 717
 718 }
 719
 720 void VHTOnAssocRsp(_adapter *padapter)
 721 {
 722         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 723         struct vht_priv         *pvhtpriv = &pmlmepriv->vhtpriv;
 724         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 725         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 726         u8      ht_AMPDU_len;
 727
 728         DBG_871X("%s\n", __FUNCTION__);
 729
 730         if (!pmlmeinfo->HT_enable)
 731                 return;
 732
 733         if (!pmlmeinfo->VHT_enable)
 734                 return;
 735
 736         ht_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
 737
 738         if(pvhtpriv->ampdu_len > ht_AMPDU_len)
 739                 rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&pvhtpriv->ampdu_len));
 740
 741         rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MAX_TIME, (u8 *)(&pvhtpriv->vht_highest_rate));
 742 }
 743
 744 #endif //CONFIG_80211AC_VHT
 745