drivers/staging/rtlwifi/rtl8822be/trx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2016  Realtek Corporation.
   5  *
   6  * Contact Information:
   7  * wlanfae <wlanfae@realtek.com>
   8  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
   9  * Hsinchu 300, Taiwan.
  10  *
  11  * Larry Finger <Larry.Finger@lwfinger.net>
  12  *
  13  *****************************************************************************/
  14
  15 #include "../wifi.h"
  16 #include "../pci.h"
  17 #include "../base.h"
  18 #include "../stats.h"
  19 #include "reg.h"
  20 #include "def.h"
  21 #include "phy.h"
  22 #include "trx.h"
  23 #include "led.h"
  24 #include "fw.h"
  25
  26 #include <linux/vermagic.h>
  27
  28 static u8 _rtl8822be_map_hwqueue_to_fwqueue(struct sk_buff *skb, u8 hw_queue)
  29 {
  30         switch (hw_queue) {
  31         case BEACON_QUEUE:
  32                 return QSLT_BEACON;
  33         case H2C_QUEUE:
  34                 return QSLT_CMD;
  35         case MGNT_QUEUE:
  36                 return QSLT_MGNT;
  37         case HIGH_QUEUE:
  38                 return QSLT_HIGH;
  39         default:
  40                 return skb->priority;
  41         }
  42 }
  43
  44 static void _rtl8822be_query_rxphystatus(struct ieee80211_hw *hw, u8 *phystrpt,
  45                                          struct ieee80211_hdr *hdr,
  46                                          struct rtl_stats *pstatus)
  47 {
  48         struct rtl_priv *rtlpriv = rtl_priv(hw);
  49
  50         rtlpriv->phydm.ops->phydm_query_phy_status(rtlpriv, phystrpt, hdr,
  51                                                    pstatus);
  52
  53         /* UI BSS List signal strength(in percentage),
  54          * make it good looking, from 0~100.
  55          */
  56         pstatus->signalstrength =
  57                 (u8)(rtl_signal_scale_mapping(hw, pstatus->rx_pwdb_all));
  58 }
  59
  60 static void _rtl8822be_translate_rx_signal_stuff(struct ieee80211_hw *hw,
  61                                                  struct sk_buff *skb,
  62                                                  struct rtl_stats *pstatus,
  63                                                  u8 *p_phystrpt)
  64 {
  65         struct ieee80211_hdr *hdr;
  66         u8 *tmp_buf;
  67
  68         tmp_buf = skb->data + pstatus->rx_drvinfo_size + pstatus->rx_bufshift +
  69                   24;
  70
  71         hdr = (struct ieee80211_hdr *)tmp_buf;
  72
  73         /* query phy status */
  74         _rtl8822be_query_rxphystatus(hw, p_phystrpt, hdr, pstatus);
  75
  76         /* packet statistics */
  77         if (pstatus->packet_beacon && pstatus->packet_matchbssid)
  78                 rtl_priv(hw)->dm.dbginfo.num_qry_beacon_pkt++;
  79
  80         if (pstatus->packet_matchbssid &&
  81             ieee80211_is_data_qos(hdr->frame_control) &&
  82             !is_multicast_ether_addr(ieee80211_get_DA(hdr))) {
  83                 struct ieee80211_qos_hdr *hdr_qos =
  84                         (struct ieee80211_qos_hdr *)tmp_buf;
  85                 u16 tid = le16_to_cpu(hdr_qos->qos_ctrl) & 0xf;
  86
  87                 if (tid != 0 && tid != 3)
  88                         rtl_priv(hw)->dm.dbginfo.num_non_be_pkt++;
  89         }
  90
  91         /* signal statistics */
  92         if (p_phystrpt)
  93                 rtl_process_phyinfo(hw, tmp_buf, pstatus);
  94 }
  95
  96 static void _rtl8822be_insert_emcontent(struct rtl_tcb_desc *ptcb_desc,
  97                                         u8 *virtualaddress)
  98 {
  99         u32 dwtmp = 0;
 100
 101         memset(virtualaddress, 0, 8);
 102
 103         SET_EARLYMODE_PKTNUM(virtualaddress, ptcb_desc->empkt_num);
 104         if (ptcb_desc->empkt_num == 1) {
 105                 dwtmp = ptcb_desc->empkt_len[0];
 106         } else {
 107                 dwtmp = ptcb_desc->empkt_len[0];
 108                 dwtmp += ((dwtmp % 4) ? (4 - dwtmp % 4) : 0) + 4;
 109                 dwtmp += ptcb_desc->empkt_len[1];
 110         }
 111         SET_EARLYMODE_LEN0(virtualaddress, dwtmp);
 112
 113         if (ptcb_desc->empkt_num <= 3) {
 114                 dwtmp = ptcb_desc->empkt_len[2];
 115         } else {
 116                 dwtmp = ptcb_desc->empkt_len[2];
 117                 dwtmp += ((dwtmp % 4) ? (4 - dwtmp % 4) : 0) + 4;
 118                 dwtmp += ptcb_desc->empkt_len[3];
 119         }
 120         SET_EARLYMODE_LEN1(virtualaddress, dwtmp);
 121         if (ptcb_desc->empkt_num <= 5) {
 122                 dwtmp = ptcb_desc->empkt_len[4];
 123         } else {
 124                 dwtmp = ptcb_desc->empkt_len[4];
 125                 dwtmp += ((dwtmp % 4) ? (4 - dwtmp % 4) : 0) + 4;
 126                 dwtmp += ptcb_desc->empkt_len[5];
 127         }
 128         SET_EARLYMODE_LEN2_1(virtualaddress, dwtmp & 0xF);
 129         SET_EARLYMODE_LEN2_2(virtualaddress, dwtmp >> 4);
 130         if (ptcb_desc->empkt_num <= 7) {
 131                 dwtmp = ptcb_desc->empkt_len[6];
 132         } else {
 133                 dwtmp = ptcb_desc->empkt_len[6];
 134                 dwtmp += ((dwtmp % 4) ? (4 - dwtmp % 4) : 0) + 4;
 135                 dwtmp += ptcb_desc->empkt_len[7];
 136         }
 137         SET_EARLYMODE_LEN3(virtualaddress, dwtmp);
 138         if (ptcb_desc->empkt_num <= 9) {
 139                 dwtmp = ptcb_desc->empkt_len[8];
 140         } else {
 141                 dwtmp = ptcb_desc->empkt_len[8];
 142                 dwtmp += ((dwtmp % 4) ? (4 - dwtmp % 4) : 0) + 4;
 143                 dwtmp += ptcb_desc->empkt_len[9];
 144         }
 145         SET_EARLYMODE_LEN4(virtualaddress, dwtmp);
 146 }
 147
 148 static bool rtl8822be_get_rxdesc_is_ht(struct ieee80211_hw *hw, u8 *pdesc)
 149 {
 150         struct rtl_priv *rtlpriv = rtl_priv(hw);
 151         u8 rx_rate = 0;
 152
 153         rx_rate = GET_RX_DESC_RX_RATE(pdesc);
 154
 155         RT_TRACE(rtlpriv, COMP_RXDESC, DBG_LOUD, "rx_rate=0x%02x.\n", rx_rate);
 156
 157         if (rx_rate >= DESC_RATEMCS0 && rx_rate <= DESC_RATEMCS15)
 158                 return true;
 159         else
 160                 return false;
 161 }
 162
 163 static bool rtl8822be_get_rxdesc_is_vht(struct ieee80211_hw *hw, u8 *pdesc)
 164 {
 165         struct rtl_priv *rtlpriv = rtl_priv(hw);
 166         u8 rx_rate = 0;
 167
 168         rx_rate = GET_RX_DESC_RX_RATE(pdesc);
 169
 170         RT_TRACE(rtlpriv, COMP_RXDESC, DBG_LOUD, "rx_rate=0x%02x.\n", rx_rate);
 171
 172         if (rx_rate >= DESC_RATEVHT1SS_MCS0)
 173                 return true;
 174         else
 175                 return false;
 176 }
 177
 178 static u8 rtl8822be_get_rx_vht_nss(struct ieee80211_hw *hw, u8 *pdesc)
 179 {
 180         u8 rx_rate = 0;
 181         u8 vht_nss = 0;
 182
 183         rx_rate = GET_RX_DESC_RX_RATE(pdesc);
 184
 185         if (rx_rate >= DESC_RATEVHT1SS_MCS0 &&
 186             rx_rate <= DESC_RATEVHT1SS_MCS9)
 187                 vht_nss = 1;
 188         else if ((rx_rate >= DESC_RATEVHT2SS_MCS0) &&
 189                  (rx_rate <= DESC_RATEVHT2SS_MCS9))
 190                 vht_nss = 2;
 191
 192         return vht_nss;
 193 }
 194
 195 bool rtl8822be_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *status,
 196                              struct ieee80211_rx_status *rx_status, u8 *pdesc,
 197                              struct sk_buff *skb)
 198 {
 199         struct rtl_priv *rtlpriv = rtl_priv(hw);
 200         u8 *p_phystrpt = NULL;
 201         struct ieee80211_hdr *hdr;
 202
 203         u32 phystatus = GET_RX_DESC_PHYST(pdesc);
 204
 205         if (GET_RX_DESC_C2H(pdesc) == 0)
 206                 status->packet_report_type = NORMAL_RX;
 207         else
 208                 status->packet_report_type = C2H_PACKET;
 209
 210         status->length = (u16)GET_RX_DESC_PKT_LEN(pdesc);
 211         status->rx_drvinfo_size =
 212                 (u8)GET_RX_DESC_DRV_INFO_SIZE(pdesc) * RX_DRV_INFO_SIZE_UNIT;
 213         status->rx_bufshift = (u8)(GET_RX_DESC_SHIFT(pdesc) & 0x03);
 214         status->icv = (u16)GET_RX_DESC_ICV_ERR(pdesc);
 215         status->crc = (u16)GET_RX_DESC_CRC32(pdesc);
 216         status->hwerror = (status->crc | status->icv);
 217         status->decrypted = !GET_RX_DESC_SWDEC(pdesc);
 218         status->rate = (u8)GET_RX_DESC_RX_RATE(pdesc);
 219         status->isampdu = (bool)(GET_RX_DESC_PAGGR(pdesc) == 1);
 220         status->isfirst_ampdu = (bool)(GET_RX_DESC_PAGGR(pdesc) == 1);
 221         status->timestamp_low = GET_RX_DESC_TSFL(pdesc);
 222         status->is_ht = rtl8822be_get_rxdesc_is_ht(hw, pdesc);
 223         status->is_vht = rtl8822be_get_rxdesc_is_vht(hw, pdesc);
 224         status->vht_nss = rtl8822be_get_rx_vht_nss(hw, pdesc);
 225         status->is_cck = RX_HAL_IS_CCK_RATE(status->rate);
 226
 227         status->macid = GET_RX_DESC_MACID(pdesc);
 228         if (GET_RX_DESC_PATTERN_MATCH(pdesc))
 229                 status->wake_match = BIT(2);
 230         else if (GET_RX_DESC_MAGIC_WAKE(pdesc))
 231                 status->wake_match = BIT(1);
 232         else if (GET_RX_DESC_UNICAST_WAKE(pdesc))
 233                 status->wake_match = BIT(0);
 234         else
 235                 status->wake_match = 0;
 236         if (status->wake_match)
 237                 RT_TRACE(rtlpriv, COMP_RXDESC, DBG_LOUD,
 238                          "GGGGGGGGGGGGGet Wakeup Packet!! WakeMatch=%d\n",
 239                          status->wake_match);
 240         rx_status->freq = hw->conf.chandef.chan->center_freq;
 241         rx_status->band = hw->conf.chandef.chan->band;
 242
 243         if (phystatus)
 244                 p_phystrpt = (skb->data + status->rx_bufshift + 24);
 245
 246         hdr = (struct ieee80211_hdr *)(skb->data + status->rx_drvinfo_size +
 247                                        status->rx_bufshift + 24);
 248
 249         if (status->crc)
 250                 rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
 251
 252         if (status->is_ht)
 253                 rx_status->encoding = RX_ENC_HT;
 254         if (status->is_vht)
 255                 rx_status->encoding = RX_ENC_VHT;
 256
 257         rx_status->nss = status->vht_nss;
 258
 259         rx_status->flag |= RX_FLAG_MACTIME_START;
 260
 261         /* hw will set status->decrypted true, if it finds the
 262          * frame is open data frame or mgmt frame.
 263          */
 264         /* So hw will not decryption robust management frame
 265          * for IEEE80211w but still set status->decrypted
 266          * true, so here we should set it back to undecrypted
 267          * for IEEE80211w frame, and mac80211 sw will help
 268          * to decrypt it
 269          */
 270         if (status->decrypted) {
 271                 if ((!_ieee80211_is_robust_mgmt_frame(hdr)) &&
 272                     (ieee80211_has_protected(hdr->frame_control)))
 273                         rx_status->flag |= RX_FLAG_DECRYPTED;
 274                 else
 275                         rx_status->flag &= ~RX_FLAG_DECRYPTED;
 276         }
 277
 278         /* rate_idx: index of data rate into band's
 279          * supported rates or MCS index if HT rates
 280          * are use (RX_FLAG_HT)
 281          */
 282         /* Notice: this is diff with windows define */
 283         rx_status->rate_idx = rtlwifi_rate_mapping(
 284                 hw, status->is_ht, status->is_vht, status->rate);
 285
 286         rx_status->mactime = status->timestamp_low;
 287
 288         _rtl8822be_translate_rx_signal_stuff(hw, skb, status, p_phystrpt);
 289
 290         /* below info. are filled by _rtl8822be_translate_rx_signal_stuff() */
 291         if (!p_phystrpt)
 292                 goto label_no_physt;
 293
 294         rx_status->signal = status->recvsignalpower;
 295
 296         if (status->rx_packet_bw == HT_CHANNEL_WIDTH_20_40)
 297                 rx_status->bw = RATE_INFO_BW_40;
 298         else if (status->rx_packet_bw == HT_CHANNEL_WIDTH_80)
 299                 rx_status->bw = RATE_INFO_BW_80;
 300
 301 label_no_physt:
 302
 303         return true;
 304 }
 305
 306 void rtl8822be_rx_check_dma_ok(struct ieee80211_hw *hw, u8 *header_desc,
 307                                u8 queue_index)
 308 {
 309         struct rtl_priv *rtlpriv = rtl_priv(hw);
 310         u8 first_seg;
 311         u8 last_seg;
 312         u16 total_len;
 313         u16 read_cnt = 0;
 314
 315         if (!header_desc)
 316                 return;
 317
 318         do {
 319                 total_len = (u16)GET_RX_BUFFER_DESC_TOTAL_LENGTH(header_desc);
 320                 first_seg = (u8)GET_RX_BUFFER_DESC_FS(header_desc);
 321                 last_seg = (u8)GET_RX_BUFFER_DESC_LS(header_desc);
 322
 323                 if (read_cnt++ > 20) {
 324                         RT_TRACE(rtlpriv, COMP_RECV, DBG_DMESG,
 325                                  "RX chk DMA over %d times\n", read_cnt);
 326                         break;
 327                 }
 328
 329         } while (total_len == 0 && first_seg == 0 && last_seg == 0);
 330 }
 331
 332 u16 rtl8822be_rx_desc_buff_remained_cnt(struct ieee80211_hw *hw, u8 queue_index)
 333 {
 334         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 335         struct rtl_priv *rtlpriv = rtl_priv(hw);
 336         u16 desc_idx_hw = 0, desc_idx_host = 0, remind_cnt = 0;
 337         u32 tmp_4byte = 0;
 338
 339         u32 rw_mask = 0x1ff;
 340
 341         tmp_4byte = rtl_read_dword(rtlpriv, REG_RXQ_RXBD_IDX_8822B);
 342         desc_idx_hw = (u16)((tmp_4byte >> 16) & rw_mask);
 343         desc_idx_host = (u16)(tmp_4byte & rw_mask);
 344
 345         /* may be no data, donot rx */
 346         if (desc_idx_hw == desc_idx_host)
 347                 return 0;
 348
 349         remind_cnt =
 350                 (desc_idx_hw > desc_idx_host) ?
 351                         (desc_idx_hw - desc_idx_host) :
 352                         (RX_DESC_NUM_8822BE - (desc_idx_host - desc_idx_hw));
 353
 354         rtlpci->rx_ring[queue_index].next_rx_rp = desc_idx_host;
 355
 356         return remind_cnt;
 357 }
 358
 359 static u16 get_desc_address_from_queue_index(u16 queue_index)
 360 {
 361         /*
 362          * Note: Access these registers will take a lot of cost.
 363          */
 364         u16 desc_address = REG_BEQ_TXBD_IDX_8822B;
 365
 366         switch (queue_index) {
 367         case BK_QUEUE:
 368                 desc_address = REG_BKQ_TXBD_IDX_8822B;
 369                 break;
 370         case BE_QUEUE:
 371                 desc_address = REG_BEQ_TXBD_IDX_8822B;
 372                 break;
 373         case VI_QUEUE:
 374                 desc_address = REG_VIQ_TXBD_IDX_8822B;
 375                 break;
 376         case VO_QUEUE:
 377                 desc_address = REG_VOQ_TXBD_IDX_8822B;
 378                 break;
 379         case BEACON_QUEUE:
 380                 desc_address = REG_BEQ_TXBD_IDX_8822B;
 381                 break;
 382         case H2C_QUEUE:
 383                 desc_address = REG_H2CQ_TXBD_IDX_8822B;
 384                 break;
 385         case MGNT_QUEUE:
 386                 desc_address = REG_MGQ_TXBD_IDX_8822B;
 387                 break;
 388         case HIGH_QUEUE:
 389                 desc_address = REG_HI0Q_TXBD_IDX_8822B;
 390                 break;
 391         case HCCA_QUEUE:
 392                 desc_address = REG_BEQ_TXBD_IDX_8822B;
 393                 break;
 394         default:
 395                 break;
 396         }
 397         return desc_address;
 398 }
 399
 400 /*free  desc that can be used */
 401 u16 rtl8822be_get_available_desc(struct ieee80211_hw *hw, u8 q_idx)
 402 {
 403         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 404         struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[q_idx];
 405
 406         return calc_fifo_space(ring->cur_tx_rp, ring->cur_tx_wp,
 407                                TX_DESC_NUM_8822B);
 408 }
 409
 410 void rtl8822be_pre_fill_tx_bd_desc(struct ieee80211_hw *hw, u8 *tx_bd_desc,
 411                                    u8 *desc, u8 queue_index,
 412                                    struct sk_buff *skb, dma_addr_t data_addr)
 413 {
 414         struct rtl_priv *rtlpriv = rtl_priv(hw);
 415         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 416         u32 pkt_len = skb->len;
 417         u16 desc_size = 48; /*tx desc size*/
 418         u32 psblen = 0;
 419         u32 total_packet_size = 0;
 420         u16 current_bd_desc;
 421         u8 i = 0;
 422         /*u16 real_desc_size = 0x28;*/
 423         u16 append_early_mode_size = 0;
 424         u8 segmentnum = 1 << (RTL8822BE_SEG_NUM + 1);
 425         dma_addr_t desc_dma_addr;
 426         bool dma64 = rtlpriv->cfg->mod_params->dma64;
 427
 428         current_bd_desc = rtlpci->tx_ring[queue_index].cur_tx_wp;
 429
 430         total_packet_size = desc_size + pkt_len;
 431
 432         if (rtlpriv->rtlhal.earlymode_enable) {
 433                 if (queue_index < BEACON_QUEUE) {
 434                         append_early_mode_size = 8;
 435                         total_packet_size += append_early_mode_size;
 436                 }
 437         }
 438
 439         /* page number (round up) */
 440         psblen = (total_packet_size - 1) / 128 + 1;
 441
 442         /* tx desc addr */
 443         desc_dma_addr = rtlpci->tx_ring[queue_index].dma +
 444                         (current_bd_desc * TX_DESC_SIZE);
 445
 446         /* Reset */
 447         SET_TX_BUFF_DESC_LEN_0(tx_bd_desc, 0);
 448         SET_TX_BUFF_DESC_PSB(tx_bd_desc, 0);
 449         SET_TX_BUFF_DESC_OWN(tx_bd_desc, 0);
 450
 451         for (i = 1; i < segmentnum; i++) {
 452                 SET_TXBUFFER_DESC_LEN_WITH_OFFSET(tx_bd_desc, i, 0);
 453                 SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(tx_bd_desc, i, 0);
 454                 SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(tx_bd_desc, i, 0);
 455                 SET_TXBUFFER_DESC_ADD_HIGH_WITH_OFFSET(tx_bd_desc, i, 0, dma64);
 456         }
 457
 458         /* Clear all status */
 459         CLEAR_PCI_TX_DESC_CONTENT(desc, TX_DESC_SIZE);
 460
 461         if (rtlpriv->rtlhal.earlymode_enable) {
 462                 if (queue_index < BEACON_QUEUE)
 463                         SET_TX_BUFF_DESC_LEN_0(tx_bd_desc, desc_size + 8);
 464                 else
 465                         SET_TX_BUFF_DESC_LEN_0(tx_bd_desc, desc_size);
 466         } else {
 467                 SET_TX_BUFF_DESC_LEN_0(tx_bd_desc, desc_size);
 468         }
 469         SET_TX_BUFF_DESC_PSB(tx_bd_desc, psblen);
 470         SET_TX_BUFF_DESC_ADDR_LOW_0(tx_bd_desc, desc_dma_addr);
 471         SET_TX_BUFF_DESC_ADDR_HIGH_0(tx_bd_desc, ((u64)desc_dma_addr >> 32),
 472                                      dma64);
 473
 474         SET_TXBUFFER_DESC_LEN_WITH_OFFSET(tx_bd_desc, 1, pkt_len);
 475         SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(tx_bd_desc, 1, 0);
 476         SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(tx_bd_desc, 1, data_addr);
 477         SET_TXBUFFER_DESC_ADD_HIGH_WITH_OFFSET(tx_bd_desc, 1,
 478                                                ((u64)data_addr >> 32), dma64);
 479
 480         SET_TX_DESC_TXPKTSIZE(desc, (u16)(pkt_len));
 481 }
 482
 483 static u8 rtl8822be_bw_mapping(struct ieee80211_hw *hw,
 484                                struct rtl_tcb_desc *ptcb_desc)
 485 {
 486         struct rtl_priv *rtlpriv = rtl_priv(hw);
 487         struct rtl_phy *rtlphy = &rtlpriv->phy;
 488         u8 bw_setting_of_desc = 0;
 489
 490         RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 491                  "%s, current_chan_bw %d, packet_bw %d\n", __func__,
 492                  rtlphy->current_chan_bw, ptcb_desc->packet_bw);
 493
 494         if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_80) {
 495                 if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_80)
 496                         bw_setting_of_desc = 2;
 497                 else if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20_40)
 498                         bw_setting_of_desc = 1;
 499                 else
 500                         bw_setting_of_desc = 0;
 501         } else if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) {
 502                 if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20_40 ||
 503                     ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_80)
 504                         bw_setting_of_desc = 1;
 505                 else
 506                         bw_setting_of_desc = 0;
 507         } else {
 508                 bw_setting_of_desc = 0;
 509         }
 510
 511         return bw_setting_of_desc;
 512 }
 513
 514 static u8 rtl8822be_sc_mapping(struct ieee80211_hw *hw,
 515                                struct rtl_tcb_desc *ptcb_desc)
 516 {
 517         struct rtl_priv *rtlpriv = rtl_priv(hw);
 518         struct rtl_phy *rtlphy = &rtlpriv->phy;
 519         struct rtl_mac *mac = rtl_mac(rtlpriv);
 520         u8 sc_setting_of_desc = 0;
 521
 522         if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_80) {
 523                 if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_80) {
 524                         sc_setting_of_desc = VHT_DATA_SC_DONOT_CARE;
 525                 } else if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20_40) {
 526                         if (mac->cur_80_prime_sc == HAL_PRIME_CHNL_OFFSET_LOWER)
 527                                 sc_setting_of_desc =
 528                                         VHT_DATA_SC_40_LOWER_OF_80MHZ;
 529                         else if (mac->cur_80_prime_sc ==
 530                                  HAL_PRIME_CHNL_OFFSET_UPPER)
 531                                 sc_setting_of_desc =
 532                                         VHT_DATA_SC_40_UPPER_OF_80MHZ;
 533                         else
 534                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_LOUD,
 535                                          "%s: Not Correct Primary40MHz Setting\n",
 536                                          __func__);
 537                 } else {
 538                         if (mac->cur_40_prime_sc ==
 539                              HAL_PRIME_CHNL_OFFSET_LOWER &&
 540                             mac->cur_80_prime_sc ==
 541                              HAL_PRIME_CHNL_OFFSET_LOWER)
 542                                 sc_setting_of_desc =
 543                                         VHT_DATA_SC_20_LOWEST_OF_80MHZ;
 544                         else if ((mac->cur_40_prime_sc ==
 545                                   HAL_PRIME_CHNL_OFFSET_UPPER) &&
 546                                  (mac->cur_80_prime_sc ==
 547                                   HAL_PRIME_CHNL_OFFSET_LOWER))
 548                                 sc_setting_of_desc =
 549                                         VHT_DATA_SC_20_LOWER_OF_80MHZ;
 550                         else if ((mac->cur_40_prime_sc ==
 551                                   HAL_PRIME_CHNL_OFFSET_LOWER) &&
 552                                  (mac->cur_80_prime_sc ==
 553                                   HAL_PRIME_CHNL_OFFSET_UPPER))
 554                                 sc_setting_of_desc =
 555                                         VHT_DATA_SC_20_UPPER_OF_80MHZ;
 556                         else if ((mac->cur_40_prime_sc ==
 557                                   HAL_PRIME_CHNL_OFFSET_UPPER) &&
 558                                  (mac->cur_80_prime_sc ==
 559                                   HAL_PRIME_CHNL_OFFSET_UPPER))
 560                                 sc_setting_of_desc =
 561                                         VHT_DATA_SC_20_UPPERST_OF_80MHZ;
 562                         else
 563                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_LOUD,
 564                                          "%s: Not Correct Primary40MHz Setting\n",
 565                                          __func__);
 566                 }
 567         } else if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) {
 568                 if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20_40) {
 569                         sc_setting_of_desc = VHT_DATA_SC_DONOT_CARE;
 570                 } else if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20) {
 571                         if (mac->cur_40_prime_sc ==
 572                             HAL_PRIME_CHNL_OFFSET_UPPER) {
 573                                 sc_setting_of_desc =
 574                                         VHT_DATA_SC_20_UPPER_OF_80MHZ;
 575                         } else if (mac->cur_40_prime_sc ==
 576                                    HAL_PRIME_CHNL_OFFSET_LOWER) {
 577                                 sc_setting_of_desc =
 578                                         VHT_DATA_SC_20_LOWER_OF_80MHZ;
 579                         } else {
 580                                 sc_setting_of_desc = VHT_DATA_SC_DONOT_CARE;
 581                         }
 582                 }
 583         } else {
 584                 sc_setting_of_desc = VHT_DATA_SC_DONOT_CARE;
 585         }
 586
 587         return sc_setting_of_desc;
 588 }
 589
 590 void rtl8822be_tx_fill_desc(struct ieee80211_hw *hw, struct ieee80211_hdr *hdr,
 591                             u8 *pdesc_tx, u8 *pbd_desc_tx,
 592                             struct ieee80211_tx_info *info,
 593                             struct ieee80211_sta *sta, struct sk_buff *skb,
 594                             u8 hw_queue, struct rtl_tcb_desc *ptcb_desc)
 595 {
 596         struct rtl_priv *rtlpriv = rtl_priv(hw);
 597         struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 598         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 599         struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
 600         struct rtl_phy *rtlphy = &rtlpriv->phy;
 601         u8 *pdesc = (u8 *)pdesc_tx;
 602         u16 seq_number;
 603         __le16 fc = hdr->frame_control;
 604         u8 fw_qsel = _rtl8822be_map_hwqueue_to_fwqueue(skb, hw_queue);
 605         bool firstseg =
 606                 ((hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG)) == 0);
 607         bool lastseg = ((hdr->frame_control &
 608                          cpu_to_le16(IEEE80211_FCTL_MOREFRAGS)) == 0);
 609         dma_addr_t mapping;
 610         u8 short_gi = 0;
 611
 612         seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
 613         rtl_get_tcb_desc(hw, info, sta, skb, ptcb_desc);
 614         /* reserve 8 byte for AMPDU early mode */
 615         if (rtlhal->earlymode_enable) {
 616                 skb_push(skb, EM_HDR_LEN);
 617                 memset(skb->data, 0, EM_HDR_LEN);
 618         }
 619         mapping = pci_map_single(rtlpci->pdev, skb->data, skb->len,
 620                                  PCI_DMA_TODEVICE);
 621         if (pci_dma_mapping_error(rtlpci->pdev, mapping)) {
 622                 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "DMA mapping error");
 623                 return;
 624         }
 625
 626         if (pbd_desc_tx)
 627                 rtl8822be_pre_fill_tx_bd_desc(hw, pbd_desc_tx, pdesc, hw_queue,
 628                                               skb, mapping);
 629
 630         if (ieee80211_is_nullfunc(fc) || ieee80211_is_ctl(fc)) {
 631                 firstseg = true;
 632                 lastseg = true;
 633         }
 634         if (firstseg) {
 635                 if (rtlhal->earlymode_enable) {
 636                         SET_TX_DESC_PKT_OFFSET(pdesc, 1);
 637                         SET_TX_DESC_OFFSET(pdesc,
 638                                            USB_HWDESC_HEADER_LEN + EM_HDR_LEN);
 639                         if (ptcb_desc->empkt_num) {
 640                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 641                                          "Insert 8 byte.pTcb->EMPktNum:%d\n",
 642                                          ptcb_desc->empkt_num);
 643                                 _rtl8822be_insert_emcontent(ptcb_desc,
 644                                                             (u8 *)(skb->data));
 645                         }
 646                 } else {
 647                         SET_TX_DESC_OFFSET(pdesc, USB_HWDESC_HEADER_LEN);
 648                 }
 649
 650                 /* tx report */
 651                 rtl_get_tx_report(ptcb_desc, pdesc, hw);
 652
 653                 if (rtlpriv->rtlhal.current_bandtype == BAND_ON_5G &&
 654                     ptcb_desc->hw_rate < DESC_RATE6M) {
 655                         RT_TRACE(rtlpriv, COMP_SEND, DBG_WARNING,
 656                                  "hw_rate=0x%X is invalid in 5G\n",
 657                                  ptcb_desc->hw_rate);
 658                         ptcb_desc->hw_rate = DESC_RATE6M;
 659                 }
 660                 SET_TX_DESC_DATARATE(pdesc, ptcb_desc->hw_rate);
 661
 662                 if (ptcb_desc->hw_rate > DESC_RATEMCS0)
 663                         short_gi = (ptcb_desc->use_shortgi) ? 1 : 0;
 664                 else
 665                         short_gi = (ptcb_desc->use_shortpreamble) ? 1 : 0;
 666
 667                 if (info->flags & IEEE80211_TX_CTL_AMPDU) {
 668                         SET_TX_DESC_AGG_EN(pdesc, 1);
 669                         SET_TX_DESC_MAX_AGG_NUM(pdesc, 0x1F);
 670                 }
 671                 SET_TX_DESC_SW_SEQ(pdesc, seq_number);
 672                 SET_TX_DESC_RTSEN(pdesc, ((ptcb_desc->rts_enable &&
 673                                            !ptcb_desc->cts_enable) ?
 674                                                   1 :
 675                                                   0));
 676                 SET_TX_DESC_HW_RTS_EN(pdesc, 0);
 677                 SET_TX_DESC_CTS2SELF(pdesc, ((ptcb_desc->cts_enable) ? 1 : 0));
 678
 679                 SET_TX_DESC_RTSRATE(pdesc, ptcb_desc->rts_rate);
 680                 SET_TX_DESC_RTS_SC(pdesc, ptcb_desc->rts_sc);
 681                 SET_TX_DESC_RTS_SHORT(
 682                         pdesc,
 683                         ((ptcb_desc->rts_rate <= DESC_RATE54M) ?
 684                                  (ptcb_desc->rts_use_shortpreamble ? 1 : 0) :
 685                                  (ptcb_desc->rts_use_shortgi ? 1 : 0)));
 686
 687                 if (ptcb_desc->tx_enable_sw_calc_duration)
 688                         SET_TX_DESC_NAVUSEHDR(pdesc, 1);
 689
 690                 SET_TX_DESC_DATA_BW(pdesc, rtl8822be_bw_mapping(hw, ptcb_desc));
 691                 SET_TX_DESC_DATA_SC(pdesc, rtl8822be_sc_mapping(hw, ptcb_desc));
 692
 693                 if (sta) {
 694                         u8 ampdu_density = sta->ht_cap.ampdu_density;
 695
 696                         SET_TX_DESC_AMPDU_DENSITY(pdesc, ampdu_density);
 697                 }
 698                 if (info->control.hw_key) {
 699                         struct ieee80211_key_conf *key = info->control.hw_key;
 700
 701                         switch (key->cipher) {
 702                         case WLAN_CIPHER_SUITE_WEP40:
 703                         case WLAN_CIPHER_SUITE_WEP104:
 704                         case WLAN_CIPHER_SUITE_TKIP:
 705                                 SET_TX_DESC_SEC_TYPE(pdesc, 0x1);
 706                                 break;
 707                         case WLAN_CIPHER_SUITE_CCMP:
 708                                 SET_TX_DESC_SEC_TYPE(pdesc, 0x3);
 709                                 break;
 710                         default:
 711                                 SET_TX_DESC_SEC_TYPE(pdesc, 0x0);
 712                                 break;
 713                         }
 714                 }
 715
 716                 SET_TX_DESC_QSEL(pdesc, fw_qsel);
 717
 718                 if (rtlphy->current_channel > 14) {
 719                         /* OFDM 6M */
 720                         SET_TX_DESC_DATA_RTY_LOWEST_RATE(pdesc, 4);
 721                         SET_TX_DESC_RTS_RTY_LOWEST_RATE(pdesc, 4);
 722                 } else {
 723                         /* CCK 1M */
 724                         SET_TX_DESC_DATA_RTY_LOWEST_RATE(pdesc, 0);
 725                         SET_TX_DESC_RTS_RTY_LOWEST_RATE(pdesc, 0);
 726                 }
 727                 SET_TX_DESC_DISDATAFB(pdesc,
 728                                       ptcb_desc->disable_ratefallback ? 1 : 0);
 729                 SET_TX_DESC_USE_RATE(pdesc, ptcb_desc->use_driver_rate ? 1 : 0);
 730
 731                 /*SET_TX_DESC_PWR_STATUS(pdesc, pwr_status);*/
 732                 /* Set TxRate and RTSRate in TxDesc  */
 733                 /* This prevent Tx initial rate of new-coming packets */
 734                 /* from being overwritten by retried  packet rate.*/
 735                 if (!ptcb_desc->use_driver_rate) {
 736                         /*SET_TX_DESC_RTS_RATE(pdesc, 0x08); */
 737                         /* SET_TX_DESC_TX_RATE(pdesc, 0x0b); */
 738                 }
 739                 if (ieee80211_is_data_qos(fc)) {
 740                         if (mac->rdg_en) {
 741                                 RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
 742                                          "Enable RDG function.\n");
 743                                 SET_TX_DESC_RDG_EN(pdesc, 1);
 744                                 SET_TX_DESC_HTC(pdesc, 1);
 745                         }
 746                 }
 747
 748                 SET_TX_DESC_PORT_ID(pdesc, 0);
 749                 SET_TX_DESC_MULTIPLE_PORT(pdesc, 0);
 750         }
 751
 752         SET_TX_DESC_LS(pdesc, (lastseg ? 1 : 0));
 753         if (rtlpriv->dm.useramask) {
 754                 SET_TX_DESC_RATE_ID(pdesc, ptcb_desc->ratr_index);
 755                 SET_TX_DESC_MACID(pdesc, ptcb_desc->mac_id);
 756         } else {
 757                 SET_TX_DESC_RATE_ID(pdesc, 0xC + ptcb_desc->ratr_index);
 758                 SET_TX_DESC_MACID(pdesc, ptcb_desc->ratr_index);
 759         }
 760
 761         SET_TX_DESC_MOREFRAG(pdesc, (lastseg ? 0 : 1));
 762         if (ptcb_desc->multicast || ptcb_desc->broadcast) {
 763                 SET_TX_DESC_BMC(pdesc, 1);
 764                 /* BMC must be not AGG */
 765                 SET_TX_DESC_AGG_EN(pdesc, 0);
 766         }
 767         RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE, "\n");
 768
 769         /* debug purpose: used to check tx desc is correct or not */
 770         /*rtlpriv->halmac.ops->halmac_chk_txdesc(rtlpriv, pdesc,
 771          *                      skb->len + USB_HWDESC_HEADER_LEN);
 772          */
 773 }
 774
 775 void rtl8822be_tx_fill_special_desc(struct ieee80211_hw *hw, u8 *pdesc,
 776                                     u8 *pbd_desc, struct sk_buff *skb,
 777                                     u8 hw_queue)
 778 {
 779         struct rtl_priv *rtlpriv = rtl_priv(hw);
 780         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 781         u8 fw_queue;
 782         u8 txdesc_len = 48;
 783
 784         dma_addr_t mapping = pci_map_single(rtlpci->pdev, skb->data, skb->len,
 785                                             PCI_DMA_TODEVICE);
 786
 787         if (pci_dma_mapping_error(rtlpci->pdev, mapping)) {
 788                 RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "DMA mapping error");
 789                 return;
 790         }
 791
 792         rtl8822be_pre_fill_tx_bd_desc(hw, pbd_desc, pdesc, hw_queue, skb,
 793                                       mapping);
 794
 795         /* it should be BEACON_QUEUE or H2C_QUEUE,
 796          * so skb=NULL is safe to assert
 797          */
 798         fw_queue = _rtl8822be_map_hwqueue_to_fwqueue(NULL, hw_queue);
 799
 800         CLEAR_PCI_TX_DESC_CONTENT(pdesc, txdesc_len);
 801
 802         /* common part for BEACON and H2C */
 803         SET_TX_DESC_TXPKTSIZE((u8 *)pdesc, (u16)(skb->len));
 804
 805         SET_TX_DESC_QSEL(pdesc, fw_queue);
 806
 807         if (hw_queue == H2C_QUEUE) {
 808                 /* fill H2C */
 809                 SET_TX_DESC_OFFSET(pdesc, 0);
 810
 811         } else {
 812                 /* fill beacon */
 813                 SET_TX_DESC_OFFSET(pdesc, txdesc_len);
 814
 815                 SET_TX_DESC_DATARATE(pdesc, DESC_RATE1M);
 816
 817                 SET_TX_DESC_SW_SEQ(pdesc, 0);
 818
 819                 SET_TX_DESC_RATE_ID(pdesc, 7);
 820                 SET_TX_DESC_MACID(pdesc, 0);
 821
 822                 SET_TX_DESC_LS(pdesc, 1);
 823
 824                 SET_TX_DESC_OFFSET(pdesc, 48);
 825
 826                 SET_TX_DESC_USE_RATE(pdesc, 1);
 827         }
 828
 829         RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD, "H2C Tx Cmd Content\n",
 830                       pdesc, txdesc_len);
 831 }
 832
 833 void rtl8822be_set_desc(struct ieee80211_hw *hw, u8 *pdesc, bool istx,
 834                         u8 desc_name, u8 *val)
 835 {
 836         struct rtl_priv *rtlpriv = rtl_priv(hw);
 837         u8 q_idx = *val;
 838         bool dma64 = rtlpriv->cfg->mod_params->dma64;
 839
 840         if (istx) {
 841                 switch (desc_name) {
 842                 case HW_DESC_OWN: {
 843                         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 844                         struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[q_idx];
 845                         u16 max_tx_desc = ring->entries;
 846
 847                         if (q_idx == BEACON_QUEUE) {
 848                                 /* in case of beacon, pdesc is BD desc. */
 849                                 u8 *pbd_desc = pdesc;
 850
 851                                 ring->cur_tx_wp = 0;
 852                                 ring->cur_tx_rp = 0;
 853                                 SET_TX_BUFF_DESC_OWN(pbd_desc, 1);
 854                                 return;
 855                         }
 856
 857                         /* make sure tx desc is available by caller */
 858                         ring->cur_tx_wp = ((ring->cur_tx_wp + 1) % max_tx_desc);
 859
 860                         rtl_write_word(
 861                                 rtlpriv,
 862                                 get_desc_address_from_queue_index(
 863                                         q_idx),
 864                                 ring->cur_tx_wp);
 865                 } break;
 866                 }
 867         } else {
 868                 switch (desc_name) {
 869                 case HW_DESC_RX_PREPARE:
 870                         SET_RX_BUFFER_DESC_LS(pdesc, 0);
 871                         SET_RX_BUFFER_DESC_FS(pdesc, 0);
 872                         SET_RX_BUFFER_DESC_TOTAL_LENGTH(pdesc, 0);
 873
 874                         SET_RX_BUFFER_DESC_DATA_LENGTH(
 875                                 pdesc, MAX_RECEIVE_BUFFER_SIZE + RX_DESC_SIZE);
 876
 877                         SET_RX_BUFFER_PHYSICAL_LOW(
 878                                 pdesc, (*(dma_addr_t *)val) & DMA_BIT_MASK(32));
 879                         SET_RX_BUFFER_PHYSICAL_HIGH(
 880                                 pdesc, ((u64)(*(dma_addr_t *)val) >> 32),
 881                                 dma64);
 882                         break;
 883                 default:
 884                         WARN_ONCE(true, "ERR rxdesc :%d not process\n",
 885                                   desc_name);
 886                         break;
 887                 }
 888         }
 889 }
 890
 891 u64 rtl8822be_get_desc(struct ieee80211_hw *hw,
 892                        u8 *pdesc, bool istx, u8 desc_name)
 893 {
 894         struct rtl_priv *rtlpriv = rtl_priv(hw);
 895         u64 ret = 0;
 896         u8 *pbd_desc = pdesc;
 897         bool dma64 = rtlpriv->cfg->mod_params->dma64;
 898
 899         if (istx) {
 900                 switch (desc_name) {
 901                 case HW_DESC_TXBUFF_ADDR:
 902                         ret = GET_TXBUFFER_DESC_ADDR_LOW(pbd_desc, 1);
 903                         ret |= (u64)GET_TXBUFFER_DESC_ADDR_HIGH(pbd_desc, 1,
 904                                                                 dma64) << 32;
 905                         break;
 906                 default:
 907                         WARN_ONCE(true, "ERR txdesc :%d not process\n",
 908                                   desc_name);
 909                         break;
 910                 }
 911         } else {
 912                 switch (desc_name) {
 913                 case HW_DESC_RXPKT_LEN:
 914                         ret = GET_RX_DESC_PKT_LEN(pdesc);
 915                         break;
 916                 default:
 917                         WARN_ONCE(true, "ERR rxdesc :%d not process\n",
 918                                   desc_name);
 919                         break;
 920                 }
 921         }
 922         return ret;
 923 }
 924
 925 bool rtl8822be_is_tx_desc_closed(struct ieee80211_hw *hw, u8 hw_queue,
 926                                  u16 index)
 927 {
 928         struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
 929         struct rtl_priv *rtlpriv = rtl_priv(hw);
 930         bool ret = false;
 931         struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[hw_queue];
 932         u16 cur_tx_rp, cur_tx_wp;
 933         u16 tmp16;
 934
 935         /*
 936          * design rule:
 937          *     idx <= cur_tx_rp <= hw_rp <= cur_tx_wp = hw_wp
 938          */
 939
 940         if (index == ring->cur_tx_rp) {
 941                 /* update only if sw_rp reach hw_rp */
 942                 tmp16 = rtl_read_word(
 943                             rtlpriv,
 944                             get_desc_address_from_queue_index(hw_queue) + 2);
 945
 946                 cur_tx_rp = tmp16 & 0x01ff;
 947                 cur_tx_wp = ring->cur_tx_wp;
 948
 949                 /* don't need to update ring->cur_tx_wp */
 950                 ring->cur_tx_rp = cur_tx_rp;
 951         }
 952
 953         if (index == ring->cur_tx_rp)
 954                 ret = false;    /* no more */
 955         else
 956                 ret = true;     /* more */
 957
 958         if (hw_queue == BEACON_QUEUE)
 959                 ret = true;
 960
 961         if (rtlpriv->rtlhal.driver_is_goingto_unload ||
 962             rtlpriv->psc.rfoff_reason > RF_CHANGE_BY_PS)
 963                 ret = true;
 964
 965         return ret;
 966 }
 967
 968 void rtl8822be_tx_polling(struct ieee80211_hw *hw, u8 hw_queue)
 969 {
 970         struct rtl_priv *rtlpriv = rtl_priv(hw);
 971
 972         if (hw_queue == BEACON_QUEUE) {
 973                 /* kick start */
 974                 rtl_write_byte(
 975                         rtlpriv, REG_RX_RXBD_NUM_8822B + 1,
 976                         rtl_read_byte(rtlpriv, REG_RX_RXBD_NUM_8822B + 1) |
 977                                 BIT(4));
 978         }
 979 }
 980
 981 u32 rtl8822be_rx_command_packet(struct ieee80211_hw *hw,
 982                                 const struct rtl_stats *status,
 983                                 struct sk_buff *skb)
 984 {
 985         u32 result = 0;
 986         struct rtl_priv *rtlpriv = rtl_priv(hw);
 987
 988         switch (status->packet_report_type) {
 989         case NORMAL_RX:
 990                 result = 0;
 991                 break;
 992         case C2H_PACKET:
 993                 rtl8822be_c2h_packet_handler(hw, skb->data, (u8)skb->len);
 994                 result = 1;
 995                 break;
 996         default:
 997                 RT_TRACE(rtlpriv, COMP_RECV, DBG_TRACE,
 998                          "Unknown packet type %d\n",
 999                          status->packet_report_type);
1000                 break;
1001         }
1002
1003         return result;
1004 }