drivers/net/wireless/rockchip_wlan/rtl8822be/hal/rtl8822b/pci/rtl8822be_recv.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2015 - 2016 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 _RTL8822BE_RECV_C_
  21
  22 #include <drv_types.h>          /* PADAPTER and etc. */
  23 #include <hal_data.h>           /* HAL_DATA_TYPE */
  24 #include "../rtl8822b.h"
  25 #include "rtl8822be.h"
  26
  27 /* Debug Buffer Descriptor Ring */
  28
  29 /*#define BUF_DESC_DEBUG*/
  30 #ifdef BUF_DESC_DEBUG
  31 #define buf_desc_debug(...) do {\
  32                 RTW_INFO("BUF_DESC:" __VA_ARGS__);\
  33         } while (0)
  34 #else
  35 #define buf_desc_debug(...)  do {} while (0)
  36 #endif
  37
  38 /*
  39  * Wait until rx data is ready
  40  *      return value: _SUCCESS if Rx packet is ready, _FAIL if not ready
  41  */
  42
  43 static u32 rtl8822be_wait_rxrdy(_adapter *padapter,
  44                                 u8 *rx_bd, u16 rx_q_idx)
  45 {
  46         struct recv_priv *r_priv = &padapter->recvpriv;
  47         u8 first_seg = 0, last_seg = 0;
  48         u16 total_len = 0, read_cnt = 0;
  49
  50         static BOOLEAN start_rx = _FALSE;
  51         u16 status = _SUCCESS;
  52         HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
  53
  54         if (rx_bd == NULL)
  55                 return _FAIL;
  56
  57         total_len = (u2Byte)GET_RX_BD_TOTALRXPKTSIZE(rx_bd);
  58         first_seg = (u1Byte)GET_RX_BD_FS(rx_bd);
  59         last_seg = (u1Byte)GET_RX_BD_LS(rx_bd);
  60
  61         buf_desc_debug("RX:%s enter: rx_bd addr = %p, total_len=%d, first_seg=%d, last_seg=%d, read_cnt %d, index %d, address %p\n",
  62                        __func__,
  63                 (u8 *)&r_priv->rx_ring[rx_q_idx].desc[r_priv->rx_ring[rx_q_idx].idx],
  64                        total_len, first_seg, last_seg, read_cnt,
  65                        r_priv->rx_ring[rx_q_idx].idx, rx_bd);
  66
  67 #if defined(USING_RX_TAG)
  68         /* Rx Tag not ported */
  69         if (!start_rx) {
  70                 start_rx = _TRUE;
  71                 pHalData->RxTag = 1;
  72         } else {
  73                 while (total_len != (pHalData->RxTag + 1)) {
  74
  75                         read_cnt++;
  76
  77                         total_len = (u2Byte)GET_RX_BD_TOTALRXPKTSIZE(rx_bd);
  78                         first_seg = (u1Byte)GET_RX_BD_FS(rx_bd);
  79                         last_seg = (u1Byte)GET_RX_BD_LS(rx_bd);
  80
  81                         if (read_cnt > 10000) {
  82                                 pHalData->RxTag = total_len;
  83                                 break;
  84                         }
  85
  86                         if (total_len == 0 && pHalData->RxTag == 0x1fff)
  87                                 break;
  88                 }
  89                 pHalData->RxTag = total_len;
  90         }
  91 #else
  92         while (total_len == 0) {
  93                 read_cnt++;
  94
  95                 total_len = (u2Byte) GET_RX_BD_TOTALRXPKTSIZE(rx_bd);
  96                 first_seg = (u1Byte) GET_RX_BD_FS(rx_bd);
  97                 last_seg = (u1Byte) GET_RX_BD_LS(rx_bd);
  98
  99                 if (read_cnt > 20) {
 100                         status = _FAIL;
 101                         break;
 102                 }
 103         }
 104 #endif
 105
 106         buf_desc_debug("RX:%s exit total_len=%d, rx_tag = %d, first_seg=%d, last_seg=%d, read_cnt %d\n",
 107                        __func__, total_len, pHalData->RxTag,
 108                        first_seg, last_seg, read_cnt);
 109
 110         return status;
 111 }
 112
 113 /*
 114  * Check the number of rxdec to be handled between
 115  *   "index of RX queue descriptor maintained by host (write pointer)" and
 116  *   "index of RX queue descriptor maintained by hardware (read pointer)"
 117  */
 118 #ifdef CONFIG_NAPI
 119 u16 rtl8822be_check_rxdesc_remain(_adapter *padapter, int rx_queue_idx)
 120 #else
 121 static u16 rtl8822be_check_rxdesc_remain(_adapter *padapter, int rx_queue_idx)
 122 #endif
 123 {
 124         struct recv_priv *r_priv = &padapter->recvpriv;
 125         u16 desc_idx_hw = 0, desc_idx_host = 0, num_rxdesc_to_handle = 0;
 126         u32 tmp_4bytes = 0;
 127         static BOOLEAN  start_rx = FALSE;
 128
 129
 130         tmp_4bytes = rtw_read32(padapter, REG_RXQ_RXBD_IDX_8822B);
 131         desc_idx_hw = (u16)((tmp_4bytes >> 16) & 0x7ff);
 132         desc_idx_host = (u16)(tmp_4bytes & 0x7ff);
 133
 134         /*
 135          * make sure driver does not handle packet if hardware pointer
 136          * keeps in zero in initial state
 137          */
 138         buf_desc_debug("RX:%s(%d) reg_value %x\n", __func__, __LINE__,
 139                        tmp_4bytes);
 140
 141         if (desc_idx_hw > 0)
 142                 start_rx = TRUE;
 143
 144         if (!start_rx)
 145                 return 0;
 146
 147         if (desc_idx_hw < desc_idx_host)
 148                 /* hw idx is turn around */
 149                 num_rxdesc_to_handle = RX_BD_NUM_8822BE - desc_idx_host + desc_idx_hw;
 150         else
 151                 num_rxdesc_to_handle = desc_idx_hw - desc_idx_host;
 152
 153         if (num_rxdesc_to_handle == 0)
 154                 return 0;
 155
 156         r_priv->rx_ring[rx_queue_idx].idx = desc_idx_host;
 157
 158         buf_desc_debug("RX:%s reg_val %x, hw_idx %x, host_idx %x, desc to handle = %d\n",
 159                 __func__, tmp_4bytes, desc_idx_hw, desc_idx_host, num_rxdesc_to_handle);
 160
 161         return num_rxdesc_to_handle;
 162 }
 163
 164 static void rtl8822be_query_rx_desc_status(union recv_frame *precvframe,
 165                 u8 *pdesc)
 166 {
 167         struct rx_pkt_attrib    *pattrib = &precvframe->u.hdr.attrib;
 168
 169         _rtw_memset(pattrib, 0, sizeof(struct rx_pkt_attrib));
 170
 171         /* Offset 0 */
 172         pattrib->pkt_len = (u16)GET_RX_DESC_PKT_LEN_8822B(pdesc);
 173         pattrib->crc_err = (u8)GET_RX_DESC_CRC32_8822B(pdesc);
 174         pattrib->icv_err = (u8)GET_RX_DESC_ICV_ERR_8822B(pdesc);
 175         pattrib->drvinfo_sz = (u8)GET_RX_DESC_DRV_INFO_SIZE_8822B(pdesc) * 8;
 176         pattrib->encrypt = (u8)GET_RX_DESC_SECURITY_8822B(pdesc);
 177         pattrib->qos = (u8)GET_RX_DESC_QOS_8822B(pdesc);
 178         pattrib->shift_sz = (u8)GET_RX_DESC_SHIFT_8822B(pdesc);
 179         pattrib->physt = (u8)GET_RX_DESC_PHYST_8822B(pdesc);
 180         pattrib->bdecrypted = !GET_RX_DESC_SWDEC_8822B(pdesc);
 181
 182         /* Offset 1 */
 183         pattrib->priority = (u8)GET_RX_DESC_TID_8822B(pdesc);
 184         pattrib->mdata = (u8)GET_RX_DESC_MD_8822B(pdesc);
 185         pattrib->mfrag = (u8)GET_RX_DESC_MF_8822B(pdesc);
 186
 187         /* Offset 8 */
 188         pattrib->seq_num = (u16)GET_RX_DESC_SEQ_8822B(pdesc);
 189         pattrib->frag_num = (u8)GET_RX_DESC_FRAG_8822B(pdesc);
 190
 191         if (GET_RX_DESC_C2H_8822B(pdesc))
 192                 pattrib->pkt_rpt_type = C2H_PACKET;
 193         else
 194                 pattrib->pkt_rpt_type = NORMAL_RX;
 195
 196         /* Offset 12 */
 197         pattrib->data_rate = (u8)GET_RX_DESC_RX_RATE_8822B(pdesc);
 198
 199         /* Offset 16 */
 200         /* Offset 20 */
 201
 202 }
 203
 204 #ifdef CONFIG_NAPI
 205 int rtl8822be_rx_mpdu(_adapter *padapter, int remaing_rxdesc, int budget)
 206 #else
 207 static void rtl8822be_rx_mpdu(_adapter *padapter)
 208 #endif
 209 {
 210         struct recv_priv *r_priv = &padapter->recvpriv;
 211         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
 212         _queue *pfree_recv_queue = &r_priv->free_recv_queue;
 213         HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
 214         union recv_frame *precvframe = NULL;
 215         u8 *pphy_info = NULL;
 216         struct rx_pkt_attrib *pattrib = NULL;
 217         int rx_q_idx = RX_MPDU_QUEUE;
 218         u32 count = r_priv->rxringcount;
 219         u8 *rx_bd;
 220         struct sk_buff *skb;
 221 #ifdef CONFIG_NAPI
 222         int rx = 0;
 223         u32 status;
 224 #else
 225         u16 remaing_rxdesc = 0;
 226 #endif
 227
 228         /* RX NORMAL PKT */
 229
 230 #ifdef CONFIG_NAPI
 231         while ((rx < budget) && remaing_rxdesc) {
 232 #else
 233         remaing_rxdesc = rtl8822be_check_rxdesc_remain(padapter, rx_q_idx);
 234         while (remaing_rxdesc) {
 235 #endif
 236
 237                 /* rx descriptor */
 238                 rx_bd = (u8 *)&r_priv->rx_ring[rx_q_idx].buf_desc[r_priv->rx_ring[rx_q_idx].idx];
 239
 240                 /* rx packet */
 241                 skb = r_priv->rx_ring[rx_q_idx].rx_buf[r_priv->rx_ring[rx_q_idx].idx];
 242
 243                 buf_desc_debug("RX:%s(%d), rx_bd addr = %x, total_len = %d, ring idx = %d\n",
 244                                __func__, __LINE__, (u32)rx_bd,
 245                                GET_RX_BD_TOTALRXPKTSIZE(rx_bd),
 246                                r_priv->rx_ring[rx_q_idx].idx);
 247
 248                 buf_desc_debug("RX:%s(%d), skb(rx_buf)=%x, buf addr(virtual = %x, phisycal = %x)\n",
 249                                __func__, __LINE__, (u32)skb,
 250                                (u32)(skb_tail_pointer(skb)),
 251                                GET_RX_BD_PHYSICAL_ADDR_LOW(rx_bd));
 252
 253                 /* wait until packet is ready. this operation is similar to
 254                  * check own bit and should be called before pci_unmap_single
 255                  * which release memory mapping
 256                  */
 257
 258                 if (rtl8822be_wait_rxrdy(padapter, rx_bd, rx_q_idx) !=
 259                     _SUCCESS)
 260                         buf_desc_debug("RX:%s(%d) packet not ready\n",
 261                                        __func__, __LINE__);
 262
 263                 {
 264                         DBG_COUNTER(padapter->rx_logs.intf_rx);
 265                         precvframe = rtw_alloc_recvframe(pfree_recv_queue);
 266
 267                         if (precvframe == NULL) {
 268                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 269                                         ("recvbuf2recvframe: precvframe==NULL\n"));
 270                                 DBG_COUNTER(padapter->rx_logs.intf_rx_err_recvframe);
 271                                 goto done;
 272                         }
 273
 274                         _rtw_init_listhead(&precvframe->u.hdr.list);
 275                         precvframe->u.hdr.len = 0;
 276
 277                         pci_unmap_single(pdvobjpriv->ppcidev,
 278                                          *((dma_addr_t *)skb->cb),
 279                                          r_priv->rxbuffersize,
 280                                          PCI_DMA_FROMDEVICE);
 281
 282
 283                         rtl8822be_query_rx_desc_status(precvframe, skb->data);
 284                         pattrib = &precvframe->u.hdr.attrib;
 285
 286 #ifdef CONFIG_RX_PACKET_APPEND_FCS
 287                         {
 288                                 struct mlme_priv *mlmepriv =
 289                                                 &padapter->mlmepriv;
 290
 291                                 if (check_fwstate(mlmepriv,
 292                                                   WIFI_MONITOR_STATE) == _FALSE)
 293                                         if (pattrib->pkt_rpt_type == NORMAL_RX)
 294                                                 pattrib->pkt_len -=
 295                                                         IEEE80211_FCS_LEN;
 296                         }
 297 #endif
 298
 299                         buf_desc_debug("RX:%s(%d), pkt_len = %d, pattrib->drvinfo_sz = %d, pattrib->qos = %d, pattrib->shift_sz = %d\n",
 300                                        __func__, __LINE__, pattrib->pkt_len,
 301                                        pattrib->drvinfo_sz, pattrib->qos,
 302                                        pattrib->shift_sz);
 303
 304                         if (rtw_os_alloc_recvframe(padapter, precvframe,
 305                                    (skb->data + HALMAC_RX_DESC_SIZE_8822B +
 306                                     pattrib->drvinfo_sz + pattrib->shift_sz),
 307                                                    skb) == _FAIL) {
 308
 309                                 rtw_free_recvframe(precvframe,
 310                                                    &r_priv->free_recv_queue);
 311
 312                                 RTW_INFO("rtl8822be_rx_mpdu:can't allocate memory for skb copy\n");
 313                                 *((dma_addr_t *) skb->cb) =
 314                                         pci_map_single(pdvobjpriv->ppcidev,
 315                                                        skb_tail_pointer(skb),
 316                                                        r_priv->rxbuffersize,
 317                                                        PCI_DMA_FROMDEVICE);
 318                                 DBG_COUNTER(padapter->rx_logs.intf_rx_err_skb);
 319                                 goto done;
 320                         }
 321
 322                         recvframe_put(precvframe, pattrib->pkt_len);
 323
 324                         if (pattrib->pkt_rpt_type == NORMAL_RX) {
 325                                 /* Normal rx packet */
 326                                 if (pattrib->physt)
 327                                         pphy_info = (u8 *)(skb->data) +
 328                                                     HALMAC_RX_DESC_SIZE_8822B;
 329
 330 #ifdef CONFIG_CONCURRENT_MODE
 331                                 pre_recv_entry(precvframe, pphy_info);
 332 #endif
 333
 334                                 if (pattrib->physt && pphy_info)
 335                                         rx_query_phy_status(precvframe,
 336                                                             pphy_info);
 337
 338                                 if (rtw_recv_entry(precvframe) != _SUCCESS)
 339                                         RT_TRACE(_module_hci_ops_os_c_,
 340                                                  _drv_info_,
 341                                                 ("recvbuf2recvframe: rtw_recv_entry() Fail\n"));
 342                         } else {
 343                                 if (pattrib->pkt_rpt_type == C2H_PACKET) {
 344                                         rtl8822b_c2h_handler_no_io(padapter,
 345                                                              skb->data,
 346                                                      HALMAC_RX_DESC_SIZE_8822B +
 347                                                              pattrib->pkt_len);
 348                                 } else
 349                                         DBG_COUNTER(padapter->rx_logs.intf_rx_report);
 350
 351                                 rtw_free_recvframe(precvframe,
 352                                                    pfree_recv_queue);
 353                         }
 354                         *((dma_addr_t *) skb->cb) =
 355                                 pci_map_single(pdvobjpriv->ppcidev,
 356                                                skb_tail_pointer(skb),
 357                                                r_priv->rxbuffersize,
 358                                                PCI_DMA_FROMDEVICE);
 359                 }
 360 done:
 361
 362
 363                 SET_RX_BD_PHYSICAL_ADDR_LOW(rx_bd, *((dma_addr_t *)skb->cb));
 364                 SET_RX_BD_RXBUFFSIZE(rx_bd, r_priv->rxbuffersize);
 365
 366                 r_priv->rx_ring[rx_q_idx].idx =
 367                         (r_priv->rx_ring[rx_q_idx].idx + 1) %
 368                         r_priv->rxringcount;
 369
 370                 rtw_write16(padapter, REG_RXQ_RXBD_IDX,
 371                             r_priv->rx_ring[rx_q_idx].idx);
 372
 373                 buf_desc_debug("RX:%s(%d) reg_value %x\n", __func__, __LINE__,
 374                                rtw_read32(padapter, REG_RXQ_RXBD_IDX));
 375
 376                 remaing_rxdesc--;
 377 #ifdef CONFIG_NAPI
 378                 rx++;
 379 #endif
 380         }
 381 #ifdef CONFIG_NAPI
 382         return rx;
 383 #endif
 384 }
 385
 386 #ifndef CONFIG_NAPI
 387 static void rtl8822be_recv_tasklet(void *priv)
 388 {
 389         _irqL   irqL;
 390         _adapter        *padapter = (_adapter *)priv;
 391         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 392         struct dvobj_priv       *pdvobjpriv = adapter_to_dvobj(padapter);
 393
 394         rtl8822be_rx_mpdu(padapter);
 395         _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
 396         pHalData->IntrMask[0] |= (BIT_RXOK_MSK_8822B | BIT_RDU_MSK_8822B);
 397         pHalData->IntrMask[1] |= BIT_FOVW_MSK_8822B;
 398         rtw_write32(padapter, REG_HIMR0_8822B, pHalData->IntrMask[0]);
 399         rtw_write32(padapter, REG_HIMR1_8822B, pHalData->IntrMask[1]);
 400         _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
 401 }
 402 #endif
 403
 404 static void rtl8822be_xmit_beacon(PADAPTER Adapter)
 405 {
 406 #if defined(CONFIG_AP_MODE) && defined(CONFIG_NATIVEAP_MLME)
 407         struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
 408
 409         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 410                 /* send_beacon(Adapter); */
 411                 if (pmlmepriv->update_bcn == _TRUE)
 412                         tx_beacon_hdl(Adapter, NULL);
 413         }
 414 #endif
 415 }
 416
 417 static void rtl8822be_prepare_bcn_tasklet(void *priv)
 418 {
 419         _adapter *padapter = (_adapter *)priv;
 420
 421         rtl8822be_xmit_beacon(padapter);
 422 }
 423
 424 s32 rtl8822be_init_recv_priv(_adapter *padapter)
 425 {
 426         struct recv_priv        *precvpriv = &padapter->recvpriv;
 427         s32     ret = _SUCCESS;
 428
 429         _func_enter_;
 430
 431 #ifdef PLATFORM_LINUX
 432 #ifndef CONFIG_NAPI
 433         tasklet_init(&precvpriv->recv_tasklet,
 434                      (void(*)(unsigned long))rtl8822be_recv_tasklet,
 435                      (unsigned long)padapter);
 436 #endif
 437
 438         tasklet_init(&precvpriv->irq_prepare_beacon_tasklet,
 439                      (void(*)(unsigned long))rtl8822be_prepare_bcn_tasklet,
 440                      (unsigned long)padapter);
 441 #endif
 442
 443         _func_exit_;
 444
 445         return ret;
 446 }
 447
 448 void rtl8822be_free_recv_priv(_adapter *padapter)
 449 {
 450         _func_enter_;
 451
 452         _func_exit_;
 453 }
 454
 455 int rtl8822be_init_rxbd_ring(_adapter *padapter)
 456 {
 457         struct recv_priv        *r_priv = &padapter->recvpriv;
 458         struct dvobj_priv       *pdvobjpriv = adapter_to_dvobj(padapter);
 459         struct pci_dev  *pdev = pdvobjpriv->ppcidev;
 460         struct net_device       *dev = padapter->pnetdev;
 461         dma_addr_t *mapping = NULL;
 462         struct sk_buff *skb = NULL;
 463         u8      *rx_desc = NULL;
 464         int     i, rx_queue_idx;
 465
 466         _func_enter_;
 467
 468         /* rx_queue_idx 0:RX_MPDU_QUEUE */
 469         /* rx_queue_idx 1:RX_CMD_QUEUE */
 470         for (rx_queue_idx = 0; rx_queue_idx < 1; rx_queue_idx++) {
 471                 r_priv->rx_ring[rx_queue_idx].buf_desc =
 472                         pci_alloc_consistent(pdev,
 473                              sizeof(*r_priv->rx_ring[rx_queue_idx].buf_desc) *
 474                                              r_priv->rxringcount,
 475                                      &r_priv->rx_ring[rx_queue_idx].dma);
 476
 477                 if (!r_priv->rx_ring[rx_queue_idx].buf_desc ||
 478                     (unsigned long)r_priv->rx_ring[rx_queue_idx].buf_desc &
 479                     0xFF) {
 480                         RTW_INFO("Cannot allocate RX ring\n");
 481                         return _FAIL;
 482                 }
 483
 484                 _rtw_memset(r_priv->rx_ring[rx_queue_idx].buf_desc, 0,
 485                             sizeof(*r_priv->rx_ring[rx_queue_idx].buf_desc) *
 486                             r_priv->rxringcount);
 487                 r_priv->rx_ring[rx_queue_idx].idx = 0;
 488
 489                 for (i = 0; i < r_priv->rxringcount; i++) {
 490                         skb = dev_alloc_skb(r_priv->rxbuffersize);
 491                         if (!skb) {
 492                                 RTW_INFO("Cannot allocate skb for RX ring\n");
 493                                 return _FAIL;
 494                         }
 495
 496                         rx_desc =
 497                                 (u8 *)(&r_priv->rx_ring[rx_queue_idx].buf_desc[i]);
 498                         r_priv->rx_ring[rx_queue_idx].rx_buf[i] = skb;
 499                         mapping = (dma_addr_t *)skb->cb;
 500
 501                         /* just set skb->cb to mapping addr
 502                          * for pci_unmap_single use */
 503                         *mapping = pci_map_single(pdev, skb_tail_pointer(skb),
 504                                                   r_priv->rxbuffersize,
 505                                                   PCI_DMA_FROMDEVICE);
 506
 507                         /* Reset FS, LS, Total len */
 508                         SET_RX_BD_LS(rx_desc, 0);
 509                         SET_RX_BD_FS(rx_desc, 0);
 510                         SET_RX_BD_TOTALRXPKTSIZE(rx_desc, 0);
 511                         SET_RX_BD_RXBUFFSIZE(rx_desc, r_priv->rxbuffersize);
 512                         SET_RX_BD_PHYSICAL_ADDR_LOW(rx_desc, *mapping);
 513
 514                         buf_desc_debug("RX:rx buffer desc addr[%d] = %x, skb(rx_buf) = %x, buffer addr (virtual = %x, physical = %x)\n",
 515                                 i, (u32)&r_priv->rx_ring[rx_queue_idx].buf_desc[i],
 516                                 (u32)r_priv->rx_ring[rx_queue_idx].rx_buf[i],
 517                                 (u32)(skb_tail_pointer(skb)), (u32)(*mapping));
 518                 }
 519         }
 520
 521         _func_exit_;
 522
 523         return _SUCCESS;
 524 }
 525
 526 void rtl8822be_free_rxbd_ring(_adapter *padapter)
 527 {
 528         struct recv_priv *r_priv = &padapter->recvpriv;
 529         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
 530         struct pci_dev *pdev = pdvobjpriv->ppcidev;
 531         int i, rx_queue_idx;
 532
 533         _func_enter_;
 534
 535         /* rx_queue_idx 0:RX_MPDU_QUEUE */
 536         /* rx_queue_idx 1:RX_CMD_QUEUE */
 537         for (rx_queue_idx = 0; rx_queue_idx < 1; rx_queue_idx++) {
 538                 for (i = 0; i < r_priv->rxringcount; i++) {
 539                         struct sk_buff *skb;
 540
 541                         skb = r_priv->rx_ring[rx_queue_idx].rx_buf[i];
 542
 543                         if (!skb)
 544                                 continue;
 545
 546                         pci_unmap_single(pdev,
 547                                          *((dma_addr_t *) skb->cb),
 548                                          r_priv->rxbuffersize,
 549                                          PCI_DMA_FROMDEVICE);
 550                         kfree_skb(skb);
 551                 }
 552
 553                 pci_free_consistent(pdev,
 554                             sizeof(*r_priv->rx_ring[rx_queue_idx].buf_desc) *
 555                                     r_priv->rxringcount,
 556                                     r_priv->rx_ring[rx_queue_idx].buf_desc,
 557                                     r_priv->rx_ring[rx_queue_idx].dma);
 558                 r_priv->rx_ring[rx_queue_idx].buf_desc = NULL;
 559         }
 560
 561         _func_exit_;
 562 }
 563