drivers/net/wireless/realtek/rtlwifi/rtl8192de/trx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2009-2012  Realtek Corporation.*/
   3
   4 #include "../wifi.h"
   5 #include "../pci.h"
   6 #include "../base.h"
   7 #include "../stats.h"
   8 #include "reg.h"
   9 #include "def.h"
  10 #include "phy.h"
  11 #include "trx.h"
  12 #include "led.h"
  13
  14 static u8 _rtl92de_map_hwqueue_to_fwqueue(struct sk_buff *skb, u8 hw_queue)
  15 {
  16         __le16 fc = rtl_get_fc(skb);
  17
  18         if (unlikely(ieee80211_is_beacon(fc)))
  19                 return QSLT_BEACON;
  20         if (ieee80211_is_mgmt(fc))
  21                 return QSLT_MGNT;
  22
  23         return skb->priority;
  24 }
  25
  26 static u8 _rtl92d_query_rxpwrpercentage(s8 antpower)
  27 {
  28         if ((antpower <= -100) || (antpower >= 20))
  29                 return 0;
  30         else if (antpower >= 0)
  31                 return 100;
  32         else
  33                 return 100 + antpower;
  34 }
  35
  36 static long _rtl92de_translate_todbm(struct ieee80211_hw *hw,
  37                                      u8 signal_strength_index)
  38 {
  39         long signal_power;
  40
  41         signal_power = (long)((signal_strength_index + 1) >> 1);
  42         signal_power -= 95;
  43         return signal_power;
  44 }
  45
  46 static long _rtl92de_signal_scale_mapping(struct ieee80211_hw *hw, long currsig)
  47 {
  48         long retsig;
  49
  50         if (currsig >= 61 && currsig <= 100)
  51                 retsig = 90 + ((currsig - 60) / 4);
  52         else if (currsig >= 41 && currsig <= 60)
  53                 retsig = 78 + ((currsig - 40) / 2);
  54         else if (currsig >= 31 && currsig <= 40)
  55                 retsig = 66 + (currsig - 30);
  56         else if (currsig >= 21 && currsig <= 30)
  57                 retsig = 54 + (currsig - 20);
  58         else if (currsig >= 5 && currsig <= 20)
  59                 retsig = 42 + (((currsig - 5) * 2) / 3);
  60         else if (currsig == 4)
  61                 retsig = 36;
  62         else if (currsig == 3)
  63                 retsig = 27;
  64         else if (currsig == 2)
  65                 retsig = 18;
  66         else if (currsig == 1)
  67                 retsig = 9;
  68         else
  69                 retsig = currsig;
  70         return retsig;
  71 }
  72
  73 static void _rtl92de_query_rxphystatus(struct ieee80211_hw *hw,
  74                                        struct rtl_stats *pstats,
  75                                        struct rx_desc_92d *pdesc,
  76                                        struct rx_fwinfo_92d *p_drvinfo,
  77                                        bool packet_match_bssid,
  78                                        bool packet_toself,
  79                                        bool packet_beacon)
  80 {
  81         struct rtl_priv *rtlpriv = rtl_priv(hw);
  82         struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
  83         struct phy_sts_cck_8192d *cck_buf;
  84         s8 rx_pwr_all, rx_pwr[4];
  85         u8 rf_rx_num = 0, evm, pwdb_all;
  86         u8 i, max_spatial_stream;
  87         u32 rssi, total_rssi = 0;
  88         bool is_cck_rate;
  89
  90         is_cck_rate = RX_HAL_IS_CCK_RATE(pdesc->rxmcs);
  91         pstats->packet_matchbssid = packet_match_bssid;
  92         pstats->packet_toself = packet_toself;
  93         pstats->packet_beacon = packet_beacon;
  94         pstats->is_cck = is_cck_rate;
  95         pstats->rx_mimo_sig_qual[0] = -1;
  96         pstats->rx_mimo_sig_qual[1] = -1;
  97
  98         if (is_cck_rate) {
  99                 u8 report, cck_highpwr;
 100                 cck_buf = (struct phy_sts_cck_8192d *)p_drvinfo;
 101                 if (ppsc->rfpwr_state == ERFON)
 102                         cck_highpwr = (u8) rtl_get_bbreg(hw,
 103                                                  RFPGA0_XA_HSSIPARAMETER2,
 104                                                  BIT(9));
 105                 else
 106                         cck_highpwr = false;
 107                 if (!cck_highpwr) {
 108                         u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
 109                         report = cck_buf->cck_agc_rpt & 0xc0;
 110                         report = report >> 6;
 111                         switch (report) {
 112                         case 0x3:
 113                                 rx_pwr_all = -46 - (cck_agc_rpt & 0x3e);
 114                                 break;
 115                         case 0x2:
 116                                 rx_pwr_all = -26 - (cck_agc_rpt & 0x3e);
 117                                 break;
 118                         case 0x1:
 119                                 rx_pwr_all = -12 - (cck_agc_rpt & 0x3e);
 120                                 break;
 121                         case 0x0:
 122                                 rx_pwr_all = 16 - (cck_agc_rpt & 0x3e);
 123                                 break;
 124                         }
 125                 } else {
 126                         u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
 127                         report = p_drvinfo->cfosho[0] & 0x60;
 128                         report = report >> 5;
 129                         switch (report) {
 130                         case 0x3:
 131                                 rx_pwr_all = -46 - ((cck_agc_rpt & 0x1f) << 1);
 132                                 break;
 133                         case 0x2:
 134                                 rx_pwr_all = -26 - ((cck_agc_rpt & 0x1f) << 1);
 135                                 break;
 136                         case 0x1:
 137                                 rx_pwr_all = -12 - ((cck_agc_rpt & 0x1f) << 1);
 138                                 break;
 139                         case 0x0:
 140                                 rx_pwr_all = 16 - ((cck_agc_rpt & 0x1f) << 1);
 141                                 break;
 142                         }
 143                 }
 144                 pwdb_all = _rtl92d_query_rxpwrpercentage(rx_pwr_all);
 145                 /* CCK gain is smaller than OFDM/MCS gain,  */
 146                 /* so we add gain diff by experiences, the val is 6 */
 147                 pwdb_all += 6;
 148                 if (pwdb_all > 100)
 149                         pwdb_all = 100;
 150                 /* modify the offset to make the same gain index with OFDM. */
 151                 if (pwdb_all > 34 && pwdb_all <= 42)
 152                         pwdb_all -= 2;
 153                 else if (pwdb_all > 26 && pwdb_all <= 34)
 154                         pwdb_all -= 6;
 155                 else if (pwdb_all > 14 && pwdb_all <= 26)
 156                         pwdb_all -= 8;
 157                 else if (pwdb_all > 4 && pwdb_all <= 14)
 158                         pwdb_all -= 4;
 159                 pstats->rx_pwdb_all = pwdb_all;
 160                 pstats->recvsignalpower = rx_pwr_all;
 161                 if (packet_match_bssid) {
 162                         u8 sq;
 163                         if (pstats->rx_pwdb_all > 40) {
 164                                 sq = 100;
 165                         } else {
 166                                 sq = cck_buf->sq_rpt;
 167                                 if (sq > 64)
 168                                         sq = 0;
 169                                 else if (sq < 20)
 170                                         sq = 100;
 171                                 else
 172                                         sq = ((64 - sq) * 100) / 44;
 173                         }
 174                         pstats->signalquality = sq;
 175                         pstats->rx_mimo_sig_qual[0] = sq;
 176                         pstats->rx_mimo_sig_qual[1] = -1;
 177                 }
 178         } else {
 179                 rtlpriv->dm.rfpath_rxenable[0] = true;
 180                 rtlpriv->dm.rfpath_rxenable[1] = true;
 181                 for (i = RF90_PATH_A; i < RF6052_MAX_PATH; i++) {
 182                         if (rtlpriv->dm.rfpath_rxenable[i])
 183                                 rf_rx_num++;
 184                         rx_pwr[i] = ((p_drvinfo->gain_trsw[i] & 0x3f) * 2)
 185                                     - 110;
 186                         rssi = _rtl92d_query_rxpwrpercentage(rx_pwr[i]);
 187                         total_rssi += rssi;
 188                         rtlpriv->stats.rx_snr_db[i] =
 189                                          (long)(p_drvinfo->rxsnr[i] / 2);
 190                         if (packet_match_bssid)
 191                                 pstats->rx_mimo_signalstrength[i] = (u8) rssi;
 192                 }
 193                 rx_pwr_all = ((p_drvinfo->pwdb_all >> 1) & 0x7f) - 106;
 194                 pwdb_all = _rtl92d_query_rxpwrpercentage(rx_pwr_all);
 195                 pstats->rx_pwdb_all = pwdb_all;
 196                 pstats->rxpower = rx_pwr_all;
 197                 pstats->recvsignalpower = rx_pwr_all;
 198                 if (pdesc->rxht && pdesc->rxmcs >= DESC_RATEMCS8 &&
 199                     pdesc->rxmcs <= DESC_RATEMCS15)
 200                         max_spatial_stream = 2;
 201                 else
 202                         max_spatial_stream = 1;
 203                 for (i = 0; i < max_spatial_stream; i++) {
 204                         evm = rtl_evm_db_to_percentage(p_drvinfo->rxevm[i]);
 205                         if (packet_match_bssid) {
 206                                 if (i == 0)
 207                                         pstats->signalquality =
 208                                                  (u8)(evm & 0xff);
 209                                 pstats->rx_mimo_sig_qual[i] =
 210                                                  (u8)(evm & 0xff);
 211                         }
 212                 }
 213         }
 214         if (is_cck_rate)
 215                 pstats->signalstrength = (u8)(_rtl92de_signal_scale_mapping(hw,
 216                                 pwdb_all));
 217         else if (rf_rx_num != 0)
 218                 pstats->signalstrength = (u8)(_rtl92de_signal_scale_mapping(hw,
 219                                 total_rssi /= rf_rx_num));
 220 }
 221
 222 static void rtl92d_loop_over_paths(struct ieee80211_hw *hw,
 223                                    struct rtl_stats *pstats)
 224 {
 225         struct rtl_priv *rtlpriv = rtl_priv(hw);
 226         struct rtl_phy *rtlphy = &(rtlpriv->phy);
 227         u8 rfpath;
 228
 229         for (rfpath = RF90_PATH_A; rfpath < rtlphy->num_total_rfpath;
 230              rfpath++) {
 231                 if (rtlpriv->stats.rx_rssi_percentage[rfpath] == 0) {
 232                         rtlpriv->stats.rx_rssi_percentage[rfpath] =
 233                             pstats->rx_mimo_signalstrength[rfpath];
 234
 235                 }
 236                 if (pstats->rx_mimo_signalstrength[rfpath] >
 237                     rtlpriv->stats.rx_rssi_percentage[rfpath]) {
 238                         rtlpriv->stats.rx_rssi_percentage[rfpath] =
 239                             ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
 240                               (RX_SMOOTH_FACTOR - 1)) +
 241                              (pstats->rx_mimo_signalstrength[rfpath])) /
 242                             (RX_SMOOTH_FACTOR);
 243                         rtlpriv->stats.rx_rssi_percentage[rfpath] =
 244                             rtlpriv->stats.rx_rssi_percentage[rfpath] + 1;
 245                 } else {
 246                         rtlpriv->stats.rx_rssi_percentage[rfpath] =
 247                             ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
 248                               (RX_SMOOTH_FACTOR - 1)) +
 249                              (pstats->rx_mimo_signalstrength[rfpath])) /
 250                             (RX_SMOOTH_FACTOR);
 251                 }
 252         }
 253 }
 254
 255 static void _rtl92de_process_ui_rssi(struct ieee80211_hw *hw,
 256                                      struct rtl_stats *pstats)
 257 {
 258         struct rtl_priv *rtlpriv = rtl_priv(hw);
 259         u32 last_rssi, tmpval;
 260
 261         if (pstats->packet_toself || pstats->packet_beacon) {
 262                 rtlpriv->stats.rssi_calculate_cnt++;
 263                 if (rtlpriv->stats.ui_rssi.total_num++ >=
 264                     PHY_RSSI_SLID_WIN_MAX) {
 265                         rtlpriv->stats.ui_rssi.total_num =
 266                                                  PHY_RSSI_SLID_WIN_MAX;
 267                         last_rssi = rtlpriv->stats.ui_rssi.elements[
 268                                 rtlpriv->stats.ui_rssi.index];
 269                         rtlpriv->stats.ui_rssi.total_val -= last_rssi;
 270                 }
 271                 rtlpriv->stats.ui_rssi.total_val += pstats->signalstrength;
 272                 rtlpriv->stats.ui_rssi.elements
 273                         [rtlpriv->stats.ui_rssi.index++] =
 274                         pstats->signalstrength;
 275                 if (rtlpriv->stats.ui_rssi.index >= PHY_RSSI_SLID_WIN_MAX)
 276                         rtlpriv->stats.ui_rssi.index = 0;
 277                 tmpval = rtlpriv->stats.ui_rssi.total_val /
 278                         rtlpriv->stats.ui_rssi.total_num;
 279                 rtlpriv->stats.signal_strength = _rtl92de_translate_todbm(hw,
 280                         (u8) tmpval);
 281                 pstats->rssi = rtlpriv->stats.signal_strength;
 282         }
 283         if (!pstats->is_cck && pstats->packet_toself)
 284                 rtl92d_loop_over_paths(hw, pstats);
 285 }
 286
 287 static void _rtl92de_update_rxsignalstatistics(struct ieee80211_hw *hw,
 288                                                struct rtl_stats *pstats)
 289 {
 290         struct rtl_priv *rtlpriv = rtl_priv(hw);
 291         int weighting = 0;
 292
 293         if (rtlpriv->stats.recv_signal_power == 0)
 294                 rtlpriv->stats.recv_signal_power = pstats->recvsignalpower;
 295         if (pstats->recvsignalpower > rtlpriv->stats.recv_signal_power)
 296                 weighting = 5;
 297         else if (pstats->recvsignalpower < rtlpriv->stats.recv_signal_power)
 298                 weighting = (-5);
 299         rtlpriv->stats.recv_signal_power = (rtlpriv->stats.recv_signal_power *
 300                 5 + pstats->recvsignalpower + weighting) / 6;
 301 }
 302
 303 static void _rtl92de_process_pwdb(struct ieee80211_hw *hw,
 304                                   struct rtl_stats *pstats)
 305 {
 306         struct rtl_priv *rtlpriv = rtl_priv(hw);
 307         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 308         long undec_sm_pwdb;
 309
 310         if (mac->opmode == NL80211_IFTYPE_ADHOC ||
 311                 mac->opmode == NL80211_IFTYPE_AP)
 312                 return;
 313         else
 314                 undec_sm_pwdb = rtlpriv->dm.undec_sm_pwdb;
 315
 316         if (pstats->packet_toself || pstats->packet_beacon) {
 317                 if (undec_sm_pwdb < 0)
 318                         undec_sm_pwdb = pstats->rx_pwdb_all;
 319                 if (pstats->rx_pwdb_all > (u32) undec_sm_pwdb) {
 320                         undec_sm_pwdb = (((undec_sm_pwdb) *
 321                               (RX_SMOOTH_FACTOR - 1)) +
 322                               (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
 323                         undec_sm_pwdb = undec_sm_pwdb + 1;
 324                 } else {
 325                         undec_sm_pwdb = (((undec_sm_pwdb) *
 326                               (RX_SMOOTH_FACTOR - 1)) +
 327                               (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
 328                 }
 329                 rtlpriv->dm.undec_sm_pwdb = undec_sm_pwdb;
 330                 _rtl92de_update_rxsignalstatistics(hw, pstats);
 331         }
 332 }
 333
 334 static void rtl92d_loop_over_streams(struct ieee80211_hw *hw,
 335                                      struct rtl_stats *pstats)
 336 {
 337         struct rtl_priv *rtlpriv = rtl_priv(hw);
 338         int stream;
 339
 340         for (stream = 0; stream < 2; stream++) {
 341                 if (pstats->rx_mimo_sig_qual[stream] != -1) {
 342                         if (rtlpriv->stats.rx_evm_percentage[stream] == 0) {
 343                                 rtlpriv->stats.rx_evm_percentage[stream] =
 344                                     pstats->rx_mimo_sig_qual[stream];
 345                         }
 346                         rtlpriv->stats.rx_evm_percentage[stream] =
 347                             ((rtlpriv->stats.rx_evm_percentage[stream]
 348                               * (RX_SMOOTH_FACTOR - 1)) +
 349                              (pstats->rx_mimo_sig_qual[stream] * 1)) /
 350                             (RX_SMOOTH_FACTOR);
 351                 }
 352         }
 353 }
 354
 355 static void _rtl92de_process_ui_link_quality(struct ieee80211_hw *hw,
 356                                              struct rtl_stats *pstats)
 357 {
 358         struct rtl_priv *rtlpriv = rtl_priv(hw);
 359         u32 last_evm, tmpval;
 360
 361         if (pstats->signalquality == 0)
 362                 return;
 363         if (pstats->packet_toself || pstats->packet_beacon) {
 364                 if (rtlpriv->stats.ui_link_quality.total_num++ >=
 365                     PHY_LINKQUALITY_SLID_WIN_MAX) {
 366                         rtlpriv->stats.ui_link_quality.total_num =
 367                             PHY_LINKQUALITY_SLID_WIN_MAX;
 368                         last_evm = rtlpriv->stats.ui_link_quality.elements[
 369                                 rtlpriv->stats.ui_link_quality.index];
 370                         rtlpriv->stats.ui_link_quality.total_val -= last_evm;
 371                 }
 372                 rtlpriv->stats.ui_link_quality.total_val +=
 373                                                  pstats->signalquality;
 374                 rtlpriv->stats.ui_link_quality.elements[
 375                         rtlpriv->stats.ui_link_quality.index++] =
 376                                                  pstats->signalquality;
 377                 if (rtlpriv->stats.ui_link_quality.index >=
 378                     PHY_LINKQUALITY_SLID_WIN_MAX)
 379                         rtlpriv->stats.ui_link_quality.index = 0;
 380                 tmpval = rtlpriv->stats.ui_link_quality.total_val /
 381                     rtlpriv->stats.ui_link_quality.total_num;
 382                 rtlpriv->stats.signal_quality = tmpval;
 383                 rtlpriv->stats.last_sigstrength_inpercent = tmpval;
 384                 rtl92d_loop_over_streams(hw, pstats);
 385         }
 386 }
 387
 388 static void _rtl92de_process_phyinfo(struct ieee80211_hw *hw,
 389                                      u8 *buffer,
 390                                      struct rtl_stats *pcurrent_stats)
 391 {
 392
 393         if (!pcurrent_stats->packet_matchbssid &&
 394             !pcurrent_stats->packet_beacon)
 395                 return;
 396
 397         _rtl92de_process_ui_rssi(hw, pcurrent_stats);
 398         _rtl92de_process_pwdb(hw, pcurrent_stats);
 399         _rtl92de_process_ui_link_quality(hw, pcurrent_stats);
 400 }
 401
 402 static void _rtl92de_translate_rx_signal_stuff(struct ieee80211_hw *hw,
 403                                                struct sk_buff *skb,
 404                                                struct rtl_stats *pstats,
 405                                                struct rx_desc_92d *pdesc,
 406                                                struct rx_fwinfo_92d *p_drvinfo)
 407 {
 408         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 409         struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
 410         struct ieee80211_hdr *hdr;
 411         u8 *tmp_buf;
 412         u8 *praddr;
 413         u16 type, cfc;
 414         __le16 fc;
 415         bool packet_matchbssid, packet_toself, packet_beacon = false;
 416
 417         tmp_buf = skb->data + pstats->rx_drvinfo_size + pstats->rx_bufshift;
 418         hdr = (struct ieee80211_hdr *)tmp_buf;
 419         fc = hdr->frame_control;
 420         cfc = le16_to_cpu(fc);
 421         type = WLAN_FC_GET_TYPE(fc);
 422         praddr = hdr->addr1;
 423         packet_matchbssid = ((IEEE80211_FTYPE_CTL != type) &&
 424              ether_addr_equal(mac->bssid,
 425                               (cfc & IEEE80211_FCTL_TODS) ? hdr->addr1 :
 426                               (cfc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 :
 427                               hdr->addr3) &&
 428              (!pstats->hwerror) && (!pstats->crc) && (!pstats->icv));
 429         packet_toself = packet_matchbssid &&
 430                         ether_addr_equal(praddr, rtlefuse->dev_addr);
 431         if (ieee80211_is_beacon(fc))
 432                 packet_beacon = true;
 433         _rtl92de_query_rxphystatus(hw, pstats, pdesc, p_drvinfo,
 434                                    packet_matchbssid, packet_toself,
 435                                    packet_beacon);
 436         _rtl92de_process_phyinfo(hw, tmp_buf, pstats);
 437 }
 438
 439 bool rtl92de_rx_query_desc(struct ieee80211_hw *hw,     struct rtl_stats *stats,
 440                 struct ieee80211_rx_status *rx_status,
 441                 u8 *pdesc, struct sk_buff *skb)
 442 {
 443         struct rx_fwinfo_92d *p_drvinfo;
 444         u32 phystatus = get_rx_desc_physt(pdesc);
 445
 446         stats->length = (u16)get_rx_desc_pkt_len(pdesc);
 447         stats->rx_drvinfo_size = (u8)get_rx_desc_drv_info_size(pdesc) *
 448                                  RX_DRV_INFO_SIZE_UNIT;
 449         stats->rx_bufshift = (u8)(get_rx_desc_shift(pdesc) & 0x03);
 450         stats->icv = (u16)get_rx_desc_icv(pdesc);
 451         stats->crc = (u16)get_rx_desc_crc32(pdesc);
 452         stats->hwerror = (stats->crc | stats->icv);
 453         stats->decrypted = !get_rx_desc_swdec(pdesc);
 454         stats->rate = (u8)get_rx_desc_rxmcs(pdesc);
 455         stats->shortpreamble = (u16)get_rx_desc_splcp(pdesc);
 456         stats->isampdu = (bool)(get_rx_desc_paggr(pdesc) == 1);
 457         stats->isfirst_ampdu = (bool)((get_rx_desc_paggr(pdesc) == 1) &&
 458                                       (get_rx_desc_faggr(pdesc) == 1));
 459         stats->timestamp_low = get_rx_desc_tsfl(pdesc);
 460         stats->rx_is40mhzpacket = (bool)get_rx_desc_bw(pdesc);
 461         stats->is_ht = (bool)get_rx_desc_rxht(pdesc);
 462         rx_status->freq = hw->conf.chandef.chan->center_freq;
 463         rx_status->band = hw->conf.chandef.chan->band;
 464         if (get_rx_desc_crc32(pdesc))
 465                 rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
 466         if (!get_rx_desc_swdec(pdesc))
 467                 rx_status->flag |= RX_FLAG_DECRYPTED;
 468         if (get_rx_desc_bw(pdesc))
 469                 rx_status->bw = RATE_INFO_BW_40;
 470         if (get_rx_desc_rxht(pdesc))
 471                 rx_status->encoding = RX_ENC_HT;
 472         rx_status->flag |= RX_FLAG_MACTIME_START;
 473         if (stats->decrypted)
 474                 rx_status->flag |= RX_FLAG_DECRYPTED;
 475         rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats->is_ht,
 476                                                    false, stats->rate);
 477         rx_status->mactime = get_rx_desc_tsfl(pdesc);
 478         if (phystatus) {
 479                 p_drvinfo = (struct rx_fwinfo_92d *)(skb->data +
 480                                                      stats->rx_bufshift);
 481                 _rtl92de_translate_rx_signal_stuff(hw,
 482                                                    skb, stats,
 483                                                    (struct rx_desc_92d *)pdesc,
 484                                                    p_drvinfo);
 485         }
 486         /*rx_status->qual = stats->signal; */
 487         rx_status->signal = stats->recvsignalpower + 10;
 488         return true;
 489 }
 490
 491 static void _rtl92de_insert_emcontent(struct rtl_tcb_desc *ptcb_desc,
 492                                       u8 *virtualaddress)
 493 {
 494         memset(virtualaddress, 0, 8);
 495
 496         set_earlymode_pktnum(virtualaddress, ptcb_desc->empkt_num);
 497         set_earlymode_len0(virtualaddress, ptcb_desc->empkt_len[0]);
 498         set_earlymode_len1(virtualaddress, ptcb_desc->empkt_len[1]);
 499         set_earlymode_len2_1(virtualaddress, ptcb_desc->empkt_len[2] & 0xF);
 500         set_earlymode_len2_2(virtualaddress, ptcb_desc->empkt_len[2] >> 4);
 501         set_earlymode_len3(virtualaddress, ptcb_desc->empkt_len[3]);
 502         set_earlymode_len4(virtualaddress, ptcb_desc->empkt_len[4]);
 503 }
 504
 505 void rtl92de_tx_fill_desc(struct ieee80211_hw *hw,
 506                           struct ieee80211_hdr *hdr, u8 *pdesc_tx,
 507                           u8 *pbd_desc_tx, struct ieee80211_tx_info *info,
 508                           struct ieee80211_sta *sta,
 509                           struct sk_buff *skb,
 510                           u8 hw_queue, struct rtl_tcb_desc *ptcb_desc)
 511 {
 512         struct rtl_priv *rtlpriv = rtl_priv(hw);
 513         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 514         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 515         struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
 516         struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
 517         u8 *pdesc = pdesc_tx;
 518         u16 seq_number;
 519         __le16 fc = hdr->frame_control;
 520         unsigned int buf_len = 0;
 521         unsigned int skb_len = skb->len;
 522         u8 fw_qsel = _rtl92de_map_hwqueue_to_fwqueue(skb, hw_queue);
 523         bool firstseg = ((hdr->seq_ctrl &
 524                         cpu_to_le16(IEEE80211_SCTL_FRAG)) == 0);
 525         bool lastseg = ((hdr->frame_control &
 526                         cpu_to_le16(IEEE80211_FCTL_MOREFRAGS)) == 0);
 527         dma_addr_t mapping;
 528         u8 bw_40 = 0;
 529
 530         if (mac->opmode == NL80211_IFTYPE_STATION) {
 531                 bw_40 = mac->bw_40;
 532         } else if (mac->opmode == NL80211_IFTYPE_AP ||
 533                 mac->opmode == NL80211_IFTYPE_ADHOC) {
 534                 if (sta)
 535                         bw_40 = sta->bandwidth >= IEEE80211_STA_RX_BW_40;
 536         }
 537         seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
 538         rtl_get_tcb_desc(hw, info, sta, skb, ptcb_desc);
 539         /* reserve 8 byte for AMPDU early mode */
 540         if (rtlhal->earlymode_enable) {
 541                 skb_push(skb, EM_HDR_LEN);
 542                 memset(skb->data, 0, EM_HDR_LEN);
 543         }
 544         buf_len = skb->len;
 545         mapping = pci_map_single(rtlpci->pdev, skb->data, skb->len,
 546                                  PCI_DMA_TODEVICE);
 547         if (pci_dma_mapping_error(rtlpci->pdev, mapping)) {
 548                 RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 549                          "DMA mapping error\n");
 550                 return;
 551         }
 552         CLEAR_PCI_TX_DESC_CONTENT(pdesc, sizeof(struct tx_desc_92d));
 553         if (ieee80211_is_nullfunc(fc) || ieee80211_is_ctl(fc)) {
 554                 firstseg = true;
 555                 lastseg = true;
 556         }
 557         if (firstseg) {
 558                 if (rtlhal->earlymode_enable) {
 559                         set_tx_desc_pkt_offset(pdesc, 1);
 560                         set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN +
 561                                            EM_HDR_LEN);
 562                         if (ptcb_desc->empkt_num) {
 563                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_LOUD,
 564                                          "Insert 8 byte.pTcb->EMPktNum:%d\n",
 565                                          ptcb_desc->empkt_num);
 566                                 _rtl92de_insert_emcontent(ptcb_desc,
 567                                                           (u8 *)(skb->data));
 568                         }
 569                 } else {
 570                         set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
 571                 }
 572                 /* 5G have no CCK rate */
 573                 if (rtlhal->current_bandtype == BAND_ON_5G)
 574                         if (ptcb_desc->hw_rate < DESC_RATE6M)
 575                                 ptcb_desc->hw_rate = DESC_RATE6M;
 576                 set_tx_desc_tx_rate(pdesc, ptcb_desc->hw_rate);
 577                 if (ptcb_desc->use_shortgi || ptcb_desc->use_shortpreamble)
 578                         set_tx_desc_data_shortgi(pdesc, 1);
 579
 580                 if (rtlhal->macphymode == DUALMAC_DUALPHY &&
 581                         ptcb_desc->hw_rate == DESC_RATEMCS7)
 582                         set_tx_desc_data_shortgi(pdesc, 1);
 583
 584                 if (info->flags & IEEE80211_TX_CTL_AMPDU) {
 585                         set_tx_desc_agg_enable(pdesc, 1);
 586                         set_tx_desc_max_agg_num(pdesc, 0x14);
 587                 }
 588                 set_tx_desc_seq(pdesc, seq_number);
 589                 set_tx_desc_rts_enable(pdesc,
 590                                        ((ptcb_desc->rts_enable &&
 591                                         !ptcb_desc->cts_enable) ? 1 : 0));
 592                 set_tx_desc_hw_rts_enable(pdesc, ((ptcb_desc->rts_enable
 593                                           || ptcb_desc->cts_enable) ? 1 : 0));
 594                 set_tx_desc_cts2self(pdesc, ((ptcb_desc->cts_enable) ? 1 : 0));
 595                 set_tx_desc_rts_stbc(pdesc, ((ptcb_desc->rts_stbc) ? 1 : 0));
 596                 /* 5G have no CCK rate */
 597                 if (rtlhal->current_bandtype == BAND_ON_5G)
 598                         if (ptcb_desc->rts_rate < DESC_RATE6M)
 599                                 ptcb_desc->rts_rate = DESC_RATE6M;
 600                 set_tx_desc_rts_rate(pdesc, ptcb_desc->rts_rate);
 601                 set_tx_desc_rts_bw(pdesc, 0);
 602                 set_tx_desc_rts_sc(pdesc, ptcb_desc->rts_sc);
 603                 set_tx_desc_rts_short(pdesc, ((ptcb_desc->rts_rate <=
 604                         DESC_RATE54M) ?
 605                         (ptcb_desc->rts_use_shortpreamble ? 1 : 0) :
 606                         (ptcb_desc->rts_use_shortgi ? 1 : 0)));
 607                 if (bw_40) {
 608                         if (ptcb_desc->packet_bw) {
 609                                 set_tx_desc_data_bw(pdesc, 1);
 610                                 set_tx_desc_tx_sub_carrier(pdesc, 3);
 611                         } else {
 612                                 set_tx_desc_data_bw(pdesc, 0);
 613                                 set_tx_desc_tx_sub_carrier(pdesc,
 614                                                         mac->cur_40_prime_sc);
 615                         }
 616                 } else {
 617                         set_tx_desc_data_bw(pdesc, 0);
 618                         set_tx_desc_tx_sub_carrier(pdesc, 0);
 619                 }
 620                 set_tx_desc_linip(pdesc, 0);
 621                 set_tx_desc_pkt_size(pdesc, (u16)skb_len);
 622                 if (sta) {
 623                         u8 ampdu_density = sta->ht_cap.ampdu_density;
 624                         set_tx_desc_ampdu_density(pdesc, ampdu_density);
 625                 }
 626                 if (info->control.hw_key) {
 627                         struct ieee80211_key_conf *keyconf;
 628
 629                         keyconf = info->control.hw_key;
 630                         switch (keyconf->cipher) {
 631                         case WLAN_CIPHER_SUITE_WEP40:
 632                         case WLAN_CIPHER_SUITE_WEP104:
 633                         case WLAN_CIPHER_SUITE_TKIP:
 634                                 set_tx_desc_sec_type(pdesc, 0x1);
 635                                 break;
 636                         case WLAN_CIPHER_SUITE_CCMP:
 637                                 set_tx_desc_sec_type(pdesc, 0x3);
 638                                 break;
 639                         default:
 640                                 set_tx_desc_sec_type(pdesc, 0x0);
 641                                 break;
 642
 643                         }
 644                 }
 645                 set_tx_desc_pkt_id(pdesc, 0);
 646                 set_tx_desc_queue_sel(pdesc, fw_qsel);
 647                 set_tx_desc_data_rate_fb_limit(pdesc, 0x1F);
 648                 set_tx_desc_rts_rate_fb_limit(pdesc, 0xF);
 649                 set_tx_desc_disable_fb(pdesc, ptcb_desc->disable_ratefallback ?
 650                                        1 : 0);
 651                 set_tx_desc_use_rate(pdesc, ptcb_desc->use_driver_rate ? 1 : 0);
 652
 653                 /* Set TxRate and RTSRate in TxDesc  */
 654                 /* This prevent Tx initial rate of new-coming packets */
 655                 /* from being overwritten by retried  packet rate.*/
 656                 if (!ptcb_desc->use_driver_rate) {
 657                         set_tx_desc_rts_rate(pdesc, 0x08);
 658                         /* set_tx_desc_tx_rate(pdesc, 0x0b); */
 659                 }
 660                 if (ieee80211_is_data_qos(fc)) {
 661                         if (mac->rdg_en) {
 662                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 663                                          "Enable RDG function\n");
 664                                 set_tx_desc_rdg_enable(pdesc, 1);
 665                                 set_tx_desc_htc(pdesc, 1);
 666                         }
 667                 }
 668         }
 669
 670         set_tx_desc_first_seg(pdesc, (firstseg ? 1 : 0));
 671         set_tx_desc_last_seg(pdesc, (lastseg ? 1 : 0));
 672         set_tx_desc_tx_buffer_size(pdesc, (u16)buf_len);
 673         set_tx_desc_tx_buffer_address(pdesc, mapping);
 674         if (rtlpriv->dm.useramask) {
 675                 set_tx_desc_rate_id(pdesc, ptcb_desc->ratr_index);
 676                 set_tx_desc_macid(pdesc, ptcb_desc->mac_id);
 677         } else {
 678                 set_tx_desc_rate_id(pdesc, 0xC + ptcb_desc->ratr_index);
 679                 set_tx_desc_macid(pdesc, ptcb_desc->ratr_index);
 680         }
 681         if (ieee80211_is_data_qos(fc))
 682                 set_tx_desc_qos(pdesc, 1);
 683
 684         if ((!ieee80211_is_data_qos(fc)) && ppsc->fwctrl_lps) {
 685                 set_tx_desc_hwseq_en(pdesc, 1);
 686                 set_tx_desc_pkt_id(pdesc, 8);
 687         }
 688         set_tx_desc_more_frag(pdesc, (lastseg ? 0 : 1));
 689         RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE, "\n");
 690 }
 691
 692 void rtl92de_tx_fill_cmddesc(struct ieee80211_hw *hw,
 693                              u8 *pdesc, bool firstseg,
 694                              bool lastseg, struct sk_buff *skb)
 695 {
 696         struct rtl_priv *rtlpriv = rtl_priv(hw);
 697         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 698         struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
 699         struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
 700         u8 fw_queue = QSLT_BEACON;
 701         dma_addr_t mapping = pci_map_single(rtlpci->pdev,
 702                     skb->data, skb->len, PCI_DMA_TODEVICE);
 703         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 704         __le16 fc = hdr->frame_control;
 705
 706         if (pci_dma_mapping_error(rtlpci->pdev, mapping)) {
 707                 RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 708                          "DMA mapping error\n");
 709                 return;
 710         }
 711         CLEAR_PCI_TX_DESC_CONTENT(pdesc, TX_DESC_SIZE);
 712         if (firstseg)
 713                 set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
 714         /* 5G have no CCK rate
 715          * Caution: The macros below are multi-line expansions.
 716          * The braces are needed no matter what checkpatch says
 717          */
 718         if (rtlhal->current_bandtype == BAND_ON_5G) {
 719                 set_tx_desc_tx_rate(pdesc, DESC_RATE6M);
 720         } else {
 721                 set_tx_desc_tx_rate(pdesc, DESC_RATE1M);
 722         }
 723         set_tx_desc_seq(pdesc, 0);
 724         set_tx_desc_linip(pdesc, 0);
 725         set_tx_desc_queue_sel(pdesc, fw_queue);
 726         set_tx_desc_first_seg(pdesc, 1);
 727         set_tx_desc_last_seg(pdesc, 1);
 728         set_tx_desc_tx_buffer_size(pdesc, (u16)skb->len);
 729         set_tx_desc_tx_buffer_address(pdesc, mapping);
 730         set_tx_desc_rate_id(pdesc, 7);
 731         set_tx_desc_macid(pdesc, 0);
 732         set_tx_desc_pkt_size(pdesc, (u16)(skb->len));
 733         set_tx_desc_first_seg(pdesc, 1);
 734         set_tx_desc_last_seg(pdesc, 1);
 735         set_tx_desc_offset(pdesc, 0x20);
 736         set_tx_desc_use_rate(pdesc, 1);
 737
 738         if (!ieee80211_is_data_qos(fc) && ppsc->fwctrl_lps) {
 739                 set_tx_desc_hwseq_en(pdesc, 1);
 740                 set_tx_desc_pkt_id(pdesc, 8);
 741         }
 742
 743         RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD,
 744                       "H2C Tx Cmd Content", pdesc, TX_DESC_SIZE);
 745         wmb();
 746         set_tx_desc_own(pdesc, 1);
 747 }
 748
 749 void rtl92de_set_desc(struct ieee80211_hw *hw, u8 *pdesc, bool istx,
 750                       u8 desc_name, u8 *val)
 751 {
 752         if (istx) {
 753                 switch (desc_name) {
 754                 case HW_DESC_OWN:
 755                         wmb();
 756                         set_tx_desc_own(pdesc, 1);
 757                         break;
 758                 case HW_DESC_TX_NEXTDESC_ADDR:
 759                         set_tx_desc_next_desc_address(pdesc, *(u32 *)val);
 760                         break;
 761                 default:
 762                         WARN_ONCE(true, "rtl8192de: ERR txdesc :%d not processed\n",
 763                                   desc_name);
 764                         break;
 765                 }
 766         } else {
 767                 switch (desc_name) {
 768                 case HW_DESC_RXOWN:
 769                         wmb();
 770                         set_rx_desc_own(pdesc, 1);
 771                         break;
 772                 case HW_DESC_RXBUFF_ADDR:
 773                         set_rx_desc_buff_addr(pdesc, *(u32 *)val);
 774                         break;
 775                 case HW_DESC_RXPKT_LEN:
 776                         set_rx_desc_pkt_len(pdesc, *(u32 *)val);
 777                         break;
 778                 case HW_DESC_RXERO:
 779                         set_rx_desc_eor(pdesc, 1);
 780                         break;
 781                 default:
 782                         WARN_ONCE(true, "rtl8192de: ERR rxdesc :%d not processed\n",
 783                                   desc_name);
 784                         break;
 785                 }
 786         }
 787 }
 788
 789 u64 rtl92de_get_desc(struct ieee80211_hw *hw,
 790                      u8 *p_desc, bool istx, u8 desc_name)
 791 {
 792         u32 ret = 0;
 793
 794         if (istx) {
 795                 switch (desc_name) {
 796                 case HW_DESC_OWN:
 797                         ret = get_tx_desc_own(p_desc);
 798                         break;
 799                 case HW_DESC_TXBUFF_ADDR:
 800                         ret = get_tx_desc_tx_buffer_address(p_desc);
 801                         break;
 802                 default:
 803                         WARN_ONCE(true, "rtl8192de: ERR txdesc :%d not processed\n",
 804                                   desc_name);
 805                         break;
 806                 }
 807         } else {
 808                 switch (desc_name) {
 809                 case HW_DESC_OWN:
 810                         ret = get_rx_desc_own(p_desc);
 811                         break;
 812                 case HW_DESC_RXPKT_LEN:
 813                         ret = get_rx_desc_pkt_len(p_desc);
 814                 break;
 815                 case HW_DESC_RXBUFF_ADDR:
 816                         ret = get_rx_desc_buff_addr(p_desc);
 817                         break;
 818                 default:
 819                         WARN_ONCE(true, "rtl8192de: ERR rxdesc :%d not processed\n",
 820                                   desc_name);
 821                         break;
 822                 }
 823         }
 824         return ret;
 825 }
 826
 827 bool rtl92de_is_tx_desc_closed(struct ieee80211_hw *hw,
 828                                u8 hw_queue, u16 index)
 829 {
 830         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 831         struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[hw_queue];
 832         u8 *entry = (u8 *)(&ring->desc[ring->idx]);
 833         u8 own = (u8)rtl92de_get_desc(hw, entry, true, HW_DESC_OWN);
 834
 835         /* a beacon packet will only use the first
 836          * descriptor by defaut, and the own bit may not
 837          * be cleared by the hardware
 838          */
 839         if (own)
 840                 return false;
 841         return true;
 842 }
 843
 844 void rtl92de_tx_polling(struct ieee80211_hw *hw, u8 hw_queue)
 845 {
 846         struct rtl_priv *rtlpriv = rtl_priv(hw);
 847         if (hw_queue == BEACON_QUEUE)
 848                 rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG, BIT(4));
 849         else
 850                 rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG,
 851                                BIT(0) << (hw_queue));
 852 }