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
rtl8822be_wait_rxrdy(_adapter * padapter,u8 * rx_bd,u16 rx_q_idx)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
rtl8822be_check_rxdesc_remain(_adapter * padapter,int rx_queue_idx)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
rtl8822be_query_rx_desc_status(union recv_frame * precvframe,u8 * pdesc)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
rtl8822be_rx_mpdu(_adapter * padapter,int remaing_rxdesc,int budget)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
564