1 /* 2 * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include "hal_hw_headers.h" 20 #include "dp_types.h" 21 #include "dp_rx.h" 22 #include "dp_peer.h" 23 #include "hal_rx.h" 24 #include "hal_api.h" 25 #include "qdf_nbuf.h" 26 #ifdef MESH_MODE_SUPPORT 27 #include "if_meta_hdr.h" 28 #endif 29 #include "dp_internal.h" 30 #include "dp_rx_mon.h" 31 #ifdef RX_DESC_DEBUG_CHECK 32 static inline void dp_rx_desc_prep(struct dp_rx_desc *rx_desc, qdf_nbuf_t nbuf) 33 { 34 rx_desc->magic = DP_RX_DESC_MAGIC; 35 rx_desc->nbuf = nbuf; 36 } 37 #else 38 static inline void dp_rx_desc_prep(struct dp_rx_desc *rx_desc, qdf_nbuf_t nbuf) 39 { 40 rx_desc->nbuf = nbuf; 41 } 42 #endif 43 44 #ifdef CONFIG_WIN 45 static inline bool dp_rx_check_ap_bridge(struct dp_vdev *vdev) 46 { 47 return vdev->ap_bridge_enabled; 48 } 49 #else 50 static inline bool dp_rx_check_ap_bridge(struct dp_vdev *vdev) 51 { 52 if (vdev->opmode != wlan_op_mode_sta) 53 return true; 54 else 55 return false; 56 } 57 #endif 58 /* 59 * dp_rx_buffers_replenish() - replenish rxdma ring with rx nbufs 60 * called during dp rx initialization 61 * and at the end of dp_rx_process. 62 * 63 * @soc: core txrx main context 64 * @mac_id: mac_id which is one of 3 mac_ids 65 * @dp_rxdma_srng: dp rxdma circular ring 66 * @rx_desc_pool: Pointer to free Rx descriptor pool 67 * @num_req_buffers: number of buffer to be replenished 68 * @desc_list: list of descs if called from dp_rx_process 69 * or NULL during dp rx initialization or out of buffer 70 * interrupt. 71 * @tail: tail of descs list 72 * Return: return success or failure 73 */ 74 QDF_STATUS dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id, 75 struct dp_srng *dp_rxdma_srng, 76 struct rx_desc_pool *rx_desc_pool, 77 uint32_t num_req_buffers, 78 union dp_rx_desc_list_elem_t **desc_list, 79 union dp_rx_desc_list_elem_t **tail) 80 { 81 uint32_t num_alloc_desc; 82 uint16_t num_desc_to_free = 0; 83 struct dp_pdev *dp_pdev = dp_get_pdev_for_mac_id(dp_soc, mac_id); 84 uint32_t num_entries_avail; 85 uint32_t count; 86 int sync_hw_ptr = 1; 87 qdf_dma_addr_t paddr; 88 qdf_nbuf_t rx_netbuf; 89 void *rxdma_ring_entry; 90 union dp_rx_desc_list_elem_t *next; 91 QDF_STATUS ret; 92 93 void *rxdma_srng; 94 95 rxdma_srng = dp_rxdma_srng->hal_srng; 96 97 if (!rxdma_srng) { 98 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 99 "rxdma srng not initialized"); 100 DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers); 101 return QDF_STATUS_E_FAILURE; 102 } 103 104 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 105 "requested %d buffers for replenish", num_req_buffers); 106 107 hal_srng_access_start(dp_soc->hal_soc, rxdma_srng); 108 num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc, 109 rxdma_srng, 110 sync_hw_ptr); 111 112 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 113 "no of available entries in rxdma ring: %d", 114 num_entries_avail); 115 116 if (!(*desc_list) && (num_entries_avail > 117 ((dp_rxdma_srng->num_entries * 3) / 4))) { 118 num_req_buffers = num_entries_avail; 119 } else if (num_entries_avail < num_req_buffers) { 120 num_desc_to_free = num_req_buffers - num_entries_avail; 121 num_req_buffers = num_entries_avail; 122 } 123 124 if (qdf_unlikely(!num_req_buffers)) { 125 num_desc_to_free = num_req_buffers; 126 hal_srng_access_end(dp_soc->hal_soc, rxdma_srng); 127 goto free_descs; 128 } 129 130 /* 131 * if desc_list is NULL, allocate the descs from freelist 132 */ 133 if (!(*desc_list)) { 134 num_alloc_desc = dp_rx_get_free_desc_list(dp_soc, mac_id, 135 rx_desc_pool, 136 num_req_buffers, 137 desc_list, 138 tail); 139 140 if (!num_alloc_desc) { 141 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 142 "no free rx_descs in freelist"); 143 DP_STATS_INC(dp_pdev, err.desc_alloc_fail, 144 num_req_buffers); 145 hal_srng_access_end(dp_soc->hal_soc, rxdma_srng); 146 return QDF_STATUS_E_NOMEM; 147 } 148 149 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 150 "%d rx desc allocated", num_alloc_desc); 151 num_req_buffers = num_alloc_desc; 152 } 153 154 155 count = 0; 156 157 while (count < num_req_buffers) { 158 rx_netbuf = qdf_nbuf_alloc(dp_soc->osdev, 159 RX_BUFFER_SIZE, 160 RX_BUFFER_RESERVATION, 161 RX_BUFFER_ALIGNMENT, 162 FALSE); 163 164 if (rx_netbuf == NULL) { 165 DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1); 166 continue; 167 } 168 169 ret = qdf_nbuf_map_single(dp_soc->osdev, rx_netbuf, 170 QDF_DMA_BIDIRECTIONAL); 171 if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) { 172 qdf_nbuf_free(rx_netbuf); 173 DP_STATS_INC(dp_pdev, replenish.map_err, 1); 174 continue; 175 } 176 177 paddr = qdf_nbuf_get_frag_paddr(rx_netbuf, 0); 178 179 /* 180 * check if the physical address of nbuf->data is 181 * less then 0x50000000 then free the nbuf and try 182 * allocating new nbuf. We can try for 100 times. 183 * this is a temp WAR till we fix it properly. 184 */ 185 ret = check_x86_paddr(dp_soc, &rx_netbuf, &paddr, dp_pdev); 186 if (ret == QDF_STATUS_E_FAILURE) { 187 DP_STATS_INC(dp_pdev, replenish.x86_fail, 1); 188 break; 189 } 190 191 count++; 192 193 rxdma_ring_entry = hal_srng_src_get_next(dp_soc->hal_soc, 194 rxdma_srng); 195 qdf_assert_always(rxdma_ring_entry); 196 197 next = (*desc_list)->next; 198 199 dp_rx_desc_prep(&((*desc_list)->rx_desc), rx_netbuf); 200 (*desc_list)->rx_desc.in_use = 1; 201 202 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 203 "rx_netbuf=%pK, buf=%pK, paddr=0x%llx, cookie=%d", 204 rx_netbuf, qdf_nbuf_data(rx_netbuf), 205 (unsigned long long)paddr, (*desc_list)->rx_desc.cookie); 206 207 hal_rxdma_buff_addr_info_set(rxdma_ring_entry, paddr, 208 (*desc_list)->rx_desc.cookie, 209 rx_desc_pool->owner); 210 211 *desc_list = next; 212 } 213 214 hal_srng_access_end(dp_soc->hal_soc, rxdma_srng); 215 216 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 217 "successfully replenished %d buffers", num_req_buffers); 218 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 219 "%d rx desc added back to free list", num_desc_to_free); 220 221 DP_STATS_INC_PKT(dp_pdev, replenish.pkts, num_req_buffers, 222 (RX_BUFFER_SIZE * num_req_buffers)); 223 224 free_descs: 225 DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free); 226 /* 227 * add any available free desc back to the free list 228 */ 229 if (*desc_list) 230 dp_rx_add_desc_list_to_free_list(dp_soc, desc_list, tail, 231 mac_id, rx_desc_pool); 232 233 return QDF_STATUS_SUCCESS; 234 } 235 236 /* 237 * dp_rx_deliver_raw() - process RAW mode pkts and hand over the 238 * pkts to RAW mode simulation to 239 * decapsulate the pkt. 240 * 241 * @vdev: vdev on which RAW mode is enabled 242 * @nbuf_list: list of RAW pkts to process 243 * @peer: peer object from which the pkt is rx 244 * 245 * Return: void 246 */ 247 void 248 dp_rx_deliver_raw(struct dp_vdev *vdev, qdf_nbuf_t nbuf_list, 249 struct dp_peer *peer) 250 { 251 qdf_nbuf_t deliver_list_head = NULL; 252 qdf_nbuf_t deliver_list_tail = NULL; 253 qdf_nbuf_t nbuf; 254 255 nbuf = nbuf_list; 256 while (nbuf) { 257 qdf_nbuf_t next = qdf_nbuf_next(nbuf); 258 259 DP_RX_LIST_APPEND(deliver_list_head, deliver_list_tail, nbuf); 260 261 DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1); 262 DP_STATS_INC_PKT(peer, rx.raw, 1, qdf_nbuf_len(nbuf)); 263 /* 264 * reset the chfrag_start and chfrag_end bits in nbuf cb 265 * as this is a non-amsdu pkt and RAW mode simulation expects 266 * these bit s to be 0 for non-amsdu pkt. 267 */ 268 if (qdf_nbuf_is_rx_chfrag_start(nbuf) && 269 qdf_nbuf_is_rx_chfrag_end(nbuf)) { 270 qdf_nbuf_set_rx_chfrag_start(nbuf, 0); 271 qdf_nbuf_set_rx_chfrag_end(nbuf, 0); 272 } 273 274 nbuf = next; 275 } 276 277 vdev->osif_rsim_rx_decap(vdev->osif_vdev, &deliver_list_head, 278 &deliver_list_tail, (struct cdp_peer*) peer); 279 280 vdev->osif_rx(vdev->osif_vdev, deliver_list_head); 281 } 282 283 284 #ifdef DP_LFR 285 /* 286 * In case of LFR, data of a new peer might be sent up 287 * even before peer is added. 288 */ 289 static inline struct dp_vdev * 290 dp_get_vdev_from_peer(struct dp_soc *soc, 291 uint16_t peer_id, 292 struct dp_peer *peer, 293 struct hal_rx_mpdu_desc_info mpdu_desc_info) 294 { 295 struct dp_vdev *vdev; 296 uint8_t vdev_id; 297 298 if (unlikely(!peer)) { 299 if (peer_id != HTT_INVALID_PEER) { 300 vdev_id = DP_PEER_METADATA_ID_GET( 301 mpdu_desc_info.peer_meta_data); 302 QDF_TRACE(QDF_MODULE_ID_DP, 303 QDF_TRACE_LEVEL_DEBUG, 304 FL("PeerID %d not found use vdevID %d"), 305 peer_id, vdev_id); 306 vdev = dp_get_vdev_from_soc_vdev_id_wifi3(soc, 307 vdev_id); 308 } else { 309 QDF_TRACE(QDF_MODULE_ID_DP, 310 QDF_TRACE_LEVEL_DEBUG, 311 FL("Invalid PeerID %d"), 312 peer_id); 313 return NULL; 314 } 315 } else { 316 vdev = peer->vdev; 317 } 318 return vdev; 319 } 320 #else 321 static inline struct dp_vdev * 322 dp_get_vdev_from_peer(struct dp_soc *soc, 323 uint16_t peer_id, 324 struct dp_peer *peer, 325 struct hal_rx_mpdu_desc_info mpdu_desc_info) 326 { 327 if (unlikely(!peer)) { 328 QDF_TRACE(QDF_MODULE_ID_DP, 329 QDF_TRACE_LEVEL_DEBUG, 330 FL("Peer not found for peerID %d"), 331 peer_id); 332 return NULL; 333 } else { 334 return peer->vdev; 335 } 336 } 337 #endif 338 339 /** 340 * dp_rx_intrabss_fwd() - Implements the Intra-BSS forwarding logic 341 * 342 * @soc: core txrx main context 343 * @sa_peer : source peer entry 344 * @rx_tlv_hdr : start address of rx tlvs 345 * @nbuf : nbuf that has to be intrabss forwarded 346 * 347 * Return: bool: true if it is forwarded else false 348 */ 349 static bool 350 dp_rx_intrabss_fwd(struct dp_soc *soc, 351 struct dp_peer *sa_peer, 352 uint8_t *rx_tlv_hdr, 353 qdf_nbuf_t nbuf) 354 { 355 uint16_t da_idx; 356 uint16_t len; 357 struct dp_peer *da_peer; 358 struct dp_ast_entry *ast_entry; 359 qdf_nbuf_t nbuf_copy; 360 361 /* check if the destination peer is available in peer table 362 * and also check if the source peer and destination peer 363 * belong to the same vap and destination peer is not bss peer. 364 */ 365 366 if ((hal_rx_msdu_end_da_is_valid_get(rx_tlv_hdr) && 367 !hal_rx_msdu_end_da_is_mcbc_get(rx_tlv_hdr))) { 368 da_idx = hal_rx_msdu_end_da_idx_get(soc->hal_soc, rx_tlv_hdr); 369 370 ast_entry = soc->ast_table[da_idx]; 371 if (!ast_entry) 372 return false; 373 374 da_peer = ast_entry->peer; 375 376 if (!da_peer) 377 return false; 378 379 if (da_peer->vdev == sa_peer->vdev && !da_peer->bss_peer) { 380 memset(nbuf->cb, 0x0, sizeof(nbuf->cb)); 381 len = qdf_nbuf_len(nbuf); 382 383 /* linearize the nbuf just before we send to 384 * dp_tx_send() 385 */ 386 if (qdf_unlikely(qdf_nbuf_get_ext_list(nbuf))) { 387 if (qdf_nbuf_linearize(nbuf) == -ENOMEM) 388 return false; 389 390 nbuf = qdf_nbuf_unshare(nbuf); 391 if (!nbuf) { 392 DP_STATS_INC_PKT(sa_peer, 393 rx.intra_bss.fail, 394 1, 395 len); 396 /* return true even though the pkt is 397 * not forwarded. Basically skb_unshare 398 * failed and we want to continue with 399 * next nbuf. 400 */ 401 return true; 402 } 403 } 404 405 if (!dp_tx_send(sa_peer->vdev, nbuf)) { 406 DP_STATS_INC_PKT(sa_peer, rx.intra_bss.pkts, 407 1, len); 408 return true; 409 } else { 410 DP_STATS_INC_PKT(sa_peer, rx.intra_bss.fail, 1, 411 len); 412 return false; 413 } 414 } 415 } 416 /* if it is a broadcast pkt (eg: ARP) and it is not its own 417 * source, then clone the pkt and send the cloned pkt for 418 * intra BSS forwarding and original pkt up the network stack 419 * Note: how do we handle multicast pkts. do we forward 420 * all multicast pkts as is or let a higher layer module 421 * like igmpsnoop decide whether to forward or not with 422 * Mcast enhancement. 423 */ 424 else if (qdf_unlikely((hal_rx_msdu_end_da_is_mcbc_get(rx_tlv_hdr) && 425 !sa_peer->bss_peer))) { 426 nbuf_copy = qdf_nbuf_copy(nbuf); 427 if (!nbuf_copy) 428 return false; 429 memset(nbuf_copy->cb, 0x0, sizeof(nbuf_copy->cb)); 430 len = qdf_nbuf_len(nbuf_copy); 431 432 if (dp_tx_send(sa_peer->vdev, nbuf_copy)) { 433 DP_STATS_INC_PKT(sa_peer, rx.intra_bss.fail, 1, len); 434 qdf_nbuf_free(nbuf_copy); 435 } else 436 DP_STATS_INC_PKT(sa_peer, rx.intra_bss.pkts, 1, len); 437 } 438 /* return false as we have to still send the original pkt 439 * up the stack 440 */ 441 return false; 442 } 443 444 #ifdef MESH_MODE_SUPPORT 445 446 /** 447 * dp_rx_fill_mesh_stats() - Fills the mesh per packet receive stats 448 * 449 * @vdev: DP Virtual device handle 450 * @nbuf: Buffer pointer 451 * @rx_tlv_hdr: start of rx tlv header 452 * @peer: pointer to peer 453 * 454 * This function allocated memory for mesh receive stats and fill the 455 * required stats. Stores the memory address in skb cb. 456 * 457 * Return: void 458 */ 459 460 void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf, 461 uint8_t *rx_tlv_hdr, struct dp_peer *peer) 462 { 463 struct mesh_recv_hdr_s *rx_info = NULL; 464 uint32_t pkt_type; 465 uint32_t nss; 466 uint32_t rate_mcs; 467 uint32_t bw; 468 469 /* fill recv mesh stats */ 470 rx_info = qdf_mem_malloc(sizeof(struct mesh_recv_hdr_s)); 471 472 /* upper layers are resposible to free this memory */ 473 474 if (rx_info == NULL) { 475 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 476 "Memory allocation failed for mesh rx stats"); 477 DP_STATS_INC(vdev->pdev, mesh_mem_alloc, 1); 478 return; 479 } 480 481 rx_info->rs_flags = MESH_RXHDR_VER1; 482 if (qdf_nbuf_is_rx_chfrag_start(nbuf)) 483 rx_info->rs_flags |= MESH_RX_FIRST_MSDU; 484 485 if (qdf_nbuf_is_rx_chfrag_end(nbuf)) 486 rx_info->rs_flags |= MESH_RX_LAST_MSDU; 487 488 if (hal_rx_attn_msdu_get_is_decrypted(rx_tlv_hdr)) { 489 rx_info->rs_flags |= MESH_RX_DECRYPTED; 490 rx_info->rs_keyix = hal_rx_msdu_get_keyid(rx_tlv_hdr); 491 if (vdev->osif_get_key) 492 vdev->osif_get_key(vdev->osif_vdev, 493 &rx_info->rs_decryptkey[0], 494 &peer->mac_addr.raw[0], 495 rx_info->rs_keyix); 496 } 497 498 rx_info->rs_rssi = hal_rx_msdu_start_get_rssi(rx_tlv_hdr); 499 rx_info->rs_channel = hal_rx_msdu_start_get_freq(rx_tlv_hdr); 500 pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr); 501 rate_mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr); 502 bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr); 503 nss = hal_rx_msdu_start_nss_get(vdev->pdev->soc->hal_soc, rx_tlv_hdr); 504 rx_info->rs_ratephy1 = rate_mcs | (nss << 0x8) | (pkt_type << 16) | 505 (bw << 24); 506 507 qdf_nbuf_set_rx_fctx_type(nbuf, (void *)rx_info, CB_FTYPE_MESH_RX_INFO); 508 509 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_MED, 510 FL("Mesh rx stats: flags %x, rssi %x, chn %x, rate %x, kix %x"), 511 rx_info->rs_flags, 512 rx_info->rs_rssi, 513 rx_info->rs_channel, 514 rx_info->rs_ratephy1, 515 rx_info->rs_keyix); 516 517 } 518 519 /** 520 * dp_rx_filter_mesh_packets() - Filters mesh unwanted packets 521 * 522 * @vdev: DP Virtual device handle 523 * @nbuf: Buffer pointer 524 * @rx_tlv_hdr: start of rx tlv header 525 * 526 * This checks if the received packet is matching any filter out 527 * catogery and and drop the packet if it matches. 528 * 529 * Return: status(0 indicates drop, 1 indicate to no drop) 530 */ 531 532 QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf, 533 uint8_t *rx_tlv_hdr) 534 { 535 union dp_align_mac_addr mac_addr; 536 537 if (qdf_unlikely(vdev->mesh_rx_filter)) { 538 if (vdev->mesh_rx_filter & MESH_FILTER_OUT_FROMDS) 539 if (hal_rx_mpdu_get_fr_ds(rx_tlv_hdr)) 540 return QDF_STATUS_SUCCESS; 541 542 if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TODS) 543 if (hal_rx_mpdu_get_to_ds(rx_tlv_hdr)) 544 return QDF_STATUS_SUCCESS; 545 546 if (vdev->mesh_rx_filter & MESH_FILTER_OUT_NODS) 547 if (!hal_rx_mpdu_get_fr_ds(rx_tlv_hdr) 548 && !hal_rx_mpdu_get_to_ds(rx_tlv_hdr)) 549 return QDF_STATUS_SUCCESS; 550 551 if (vdev->mesh_rx_filter & MESH_FILTER_OUT_RA) { 552 if (hal_rx_mpdu_get_addr1(rx_tlv_hdr, 553 &mac_addr.raw[0])) 554 return QDF_STATUS_E_FAILURE; 555 556 if (!qdf_mem_cmp(&mac_addr.raw[0], 557 &vdev->mac_addr.raw[0], 558 DP_MAC_ADDR_LEN)) 559 return QDF_STATUS_SUCCESS; 560 } 561 562 if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TA) { 563 if (hal_rx_mpdu_get_addr2(rx_tlv_hdr, 564 &mac_addr.raw[0])) 565 return QDF_STATUS_E_FAILURE; 566 567 if (!qdf_mem_cmp(&mac_addr.raw[0], 568 &vdev->mac_addr.raw[0], 569 DP_MAC_ADDR_LEN)) 570 return QDF_STATUS_SUCCESS; 571 } 572 } 573 574 return QDF_STATUS_E_FAILURE; 575 } 576 577 #else 578 void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf, 579 uint8_t *rx_tlv_hdr, struct dp_peer *peer) 580 { 581 } 582 583 QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf, 584 uint8_t *rx_tlv_hdr) 585 { 586 return QDF_STATUS_E_FAILURE; 587 } 588 589 #endif 590 591 #ifdef CONFIG_WIN 592 /** 593 * dp_rx_nac_filter(): Function to perform filtering of non-associated 594 * clients 595 * @pdev: DP pdev handle 596 * @rx_pkt_hdr: Rx packet Header 597 * 598 * return: dp_vdev* 599 */ 600 static 601 struct dp_vdev *dp_rx_nac_filter(struct dp_pdev *pdev, 602 uint8_t *rx_pkt_hdr) 603 { 604 struct ieee80211_frame *wh; 605 struct dp_neighbour_peer *peer = NULL; 606 607 wh = (struct ieee80211_frame *)rx_pkt_hdr; 608 609 if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_TODS) 610 return NULL; 611 612 qdf_spin_lock_bh(&pdev->neighbour_peer_mutex); 613 TAILQ_FOREACH(peer, &pdev->neighbour_peers_list, 614 neighbour_peer_list_elem) { 615 if (qdf_mem_cmp(&peer->neighbour_peers_macaddr.raw[0], 616 wh->i_addr2, DP_MAC_ADDR_LEN) == 0) { 617 QDF_TRACE( 618 QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 619 FL("NAC configuration matched for mac-%2x:%2x:%2x:%2x:%2x:%2x"), 620 peer->neighbour_peers_macaddr.raw[0], 621 peer->neighbour_peers_macaddr.raw[1], 622 peer->neighbour_peers_macaddr.raw[2], 623 peer->neighbour_peers_macaddr.raw[3], 624 peer->neighbour_peers_macaddr.raw[4], 625 peer->neighbour_peers_macaddr.raw[5]); 626 627 qdf_spin_unlock_bh(&pdev->neighbour_peer_mutex); 628 629 return pdev->monitor_vdev; 630 } 631 } 632 qdf_spin_unlock_bh(&pdev->neighbour_peer_mutex); 633 634 return NULL; 635 } 636 637 /** 638 * dp_rx_process_invalid_peer(): Function to pass invalid peer list to umac 639 * @soc: DP SOC handle 640 * @mpdu: mpdu for which peer is invalid 641 * 642 * return: integer type 643 */ 644 uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu) 645 { 646 struct dp_invalid_peer_msg msg; 647 struct dp_vdev *vdev = NULL; 648 struct dp_pdev *pdev = NULL; 649 struct ieee80211_frame *wh; 650 uint8_t i; 651 qdf_nbuf_t curr_nbuf, next_nbuf; 652 uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu); 653 uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr); 654 655 wh = (struct ieee80211_frame *)rx_pkt_hdr; 656 657 if (!DP_FRAME_IS_DATA(wh)) { 658 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 659 "NAWDS valid only for data frames"); 660 goto free; 661 } 662 663 if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) { 664 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 665 "Invalid nbuf length"); 666 goto free; 667 } 668 669 670 for (i = 0; i < MAX_PDEV_CNT; i++) { 671 pdev = soc->pdev_list[i]; 672 if (!pdev) { 673 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 674 "PDEV not found"); 675 continue; 676 } 677 678 if (pdev->filter_neighbour_peers) { 679 /* Next Hop scenario not yet handle */ 680 vdev = dp_rx_nac_filter(pdev, rx_pkt_hdr); 681 if (vdev) { 682 dp_rx_mon_deliver(soc, i, 683 pdev->invalid_peer_head_msdu, 684 pdev->invalid_peer_tail_msdu); 685 686 pdev->invalid_peer_head_msdu = NULL; 687 pdev->invalid_peer_tail_msdu = NULL; 688 689 return 0; 690 } 691 } 692 693 694 TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) { 695 696 if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw, 697 DP_MAC_ADDR_LEN) == 0) { 698 goto out; 699 } 700 } 701 } 702 703 if (!vdev) { 704 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 705 "VDEV not found"); 706 goto free; 707 } 708 709 out: 710 msg.wh = wh; 711 qdf_nbuf_pull_head(mpdu, RX_PKT_TLVS_LEN); 712 msg.nbuf = mpdu; 713 msg.vdev_id = vdev->vdev_id; 714 if (pdev->soc->cdp_soc.ol_ops->rx_invalid_peer) 715 pdev->soc->cdp_soc.ol_ops->rx_invalid_peer(pdev->ctrl_pdev, 716 &msg); 717 718 free: 719 /* Drop and free packet */ 720 curr_nbuf = mpdu; 721 while (curr_nbuf) { 722 next_nbuf = qdf_nbuf_next(curr_nbuf); 723 qdf_nbuf_free(curr_nbuf); 724 curr_nbuf = next_nbuf; 725 } 726 727 return 0; 728 } 729 730 /** 731 * dp_rx_process_invalid_peer_wrapper(): Function to wrap invalid peer handler 732 * @soc: DP SOC handle 733 * @mpdu: mpdu for which peer is invalid 734 * @mpdu_done: if an mpdu is completed 735 * 736 * return: integer type 737 */ 738 void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc, 739 qdf_nbuf_t mpdu, bool mpdu_done) 740 { 741 /* Only trigger the process when mpdu is completed */ 742 if (mpdu_done) 743 dp_rx_process_invalid_peer(soc, mpdu); 744 } 745 #else 746 uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu) 747 { 748 qdf_nbuf_t curr_nbuf, next_nbuf; 749 struct dp_pdev *pdev; 750 uint8_t i; 751 struct dp_vdev *vdev = NULL; 752 struct ieee80211_frame *wh; 753 uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu); 754 uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr); 755 756 wh = (struct ieee80211_frame *)rx_pkt_hdr; 757 758 if (!DP_FRAME_IS_DATA(wh)) { 759 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 760 "only for data frames"); 761 goto free; 762 } 763 764 if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) { 765 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 766 "Invalid nbuf length"); 767 goto free; 768 } 769 /* reset the head and tail pointers */ 770 for (i = 0; i < MAX_PDEV_CNT; i++) { 771 pdev = soc->pdev_list[i]; 772 if (!pdev) { 773 QDF_TRACE(QDF_MODULE_ID_DP, 774 QDF_TRACE_LEVEL_ERROR, 775 "PDEV not found"); 776 continue; 777 } 778 779 pdev->invalid_peer_head_msdu = NULL; 780 pdev->invalid_peer_tail_msdu = NULL; 781 782 qdf_spin_lock_bh(&pdev->vdev_list_lock); 783 DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) { 784 if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw, 785 DP_MAC_ADDR_LEN) == 0) { 786 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 787 goto out; 788 } 789 } 790 qdf_spin_unlock_bh(&pdev->vdev_list_lock); 791 } 792 793 if (NULL == vdev) { 794 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 795 "VDEV not found"); 796 goto free; 797 } 798 799 out: 800 if (soc->cdp_soc.ol_ops->rx_invalid_peer) 801 soc->cdp_soc.ol_ops->rx_invalid_peer(vdev->vdev_id, wh); 802 free: 803 /* Drop and free packet */ 804 curr_nbuf = mpdu; 805 while (curr_nbuf) { 806 next_nbuf = qdf_nbuf_next(curr_nbuf); 807 DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1, 808 qdf_nbuf_len(curr_nbuf)); 809 qdf_nbuf_free(curr_nbuf); 810 curr_nbuf = next_nbuf; 811 } 812 813 return 0; 814 } 815 816 void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc, 817 qdf_nbuf_t mpdu, bool mpdu_done) 818 { 819 /* To avoid compiler warning */ 820 mpdu_done = mpdu_done; 821 822 /* Process the nbuf */ 823 dp_rx_process_invalid_peer(soc, mpdu); 824 } 825 #endif 826 827 #if defined(FEATURE_LRO) 828 static void dp_rx_print_lro_info(uint8_t *rx_tlv) 829 { 830 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 831 FL("----------------------RX DESC LRO----------------------")); 832 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 833 FL("lro_eligible 0x%x"), HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv)); 834 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 835 FL("pure_ack 0x%x"), HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv)); 836 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 837 FL("chksum 0x%x"), HAL_RX_TLV_GET_TCP_CHKSUM(rx_tlv)); 838 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 839 FL("TCP seq num 0x%x"), HAL_RX_TLV_GET_TCP_SEQ(rx_tlv)); 840 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 841 FL("TCP ack num 0x%x"), HAL_RX_TLV_GET_TCP_ACK(rx_tlv)); 842 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 843 FL("TCP window 0x%x"), HAL_RX_TLV_GET_TCP_WIN(rx_tlv)); 844 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 845 FL("TCP protocol 0x%x"), HAL_RX_TLV_GET_TCP_PROTO(rx_tlv)); 846 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 847 FL("TCP offset 0x%x"), HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv)); 848 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 849 FL("toeplitz 0x%x"), HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv)); 850 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 851 FL("---------------------------------------------------------")); 852 } 853 854 /** 855 * dp_rx_lro() - LRO related processing 856 * @rx_tlv: TLV data extracted from the rx packet 857 * @peer: destination peer of the msdu 858 * @msdu: network buffer 859 * @ctx: LRO context 860 * 861 * This function performs the LRO related processing of the msdu 862 * 863 * Return: true: LRO enabled false: LRO is not enabled 864 */ 865 static void dp_rx_lro(uint8_t *rx_tlv, struct dp_peer *peer, 866 qdf_nbuf_t msdu, qdf_lro_ctx_t ctx) 867 { 868 if (!peer || !peer->vdev || !peer->vdev->lro_enable) { 869 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 870 FL("no peer, no vdev or LRO disabled")); 871 QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = 0; 872 return; 873 } 874 qdf_assert(rx_tlv); 875 dp_rx_print_lro_info(rx_tlv); 876 877 QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = 878 HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv); 879 880 QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) = 881 HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv); 882 883 QDF_NBUF_CB_RX_TCP_CHKSUM(msdu) = 884 HAL_RX_TLV_GET_TCP_CHKSUM(rx_tlv); 885 QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu) = 886 HAL_RX_TLV_GET_TCP_SEQ(rx_tlv); 887 QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu) = 888 HAL_RX_TLV_GET_TCP_ACK(rx_tlv); 889 QDF_NBUF_CB_RX_TCP_WIN(msdu) = 890 HAL_RX_TLV_GET_TCP_WIN(rx_tlv); 891 QDF_NBUF_CB_RX_TCP_PROTO(msdu) = 892 HAL_RX_TLV_GET_TCP_PROTO(rx_tlv); 893 QDF_NBUF_CB_RX_IPV6_PROTO(msdu) = 894 HAL_RX_TLV_GET_IPV6(rx_tlv); 895 QDF_NBUF_CB_RX_TCP_OFFSET(msdu) = 896 HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv); 897 QDF_NBUF_CB_RX_FLOW_ID(msdu) = 898 HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv); 899 QDF_NBUF_CB_RX_LRO_CTX(msdu) = (unsigned char *)ctx; 900 901 } 902 #else 903 static void dp_rx_lro(uint8_t *rx_tlv, struct dp_peer *peer, 904 qdf_nbuf_t msdu, qdf_lro_ctx_t ctx) 905 { 906 } 907 #endif 908 909 /** 910 * dp_rx_adjust_nbuf_len() - set appropriate msdu length in nbuf. 911 * 912 * @nbuf: pointer to msdu. 913 * @mpdu_len: mpdu length 914 * 915 * Return: returns true if nbuf is last msdu of mpdu else retuns false. 916 */ 917 static inline bool dp_rx_adjust_nbuf_len(qdf_nbuf_t nbuf, uint16_t *mpdu_len) 918 { 919 bool last_nbuf; 920 921 if (*mpdu_len >= (RX_BUFFER_SIZE - RX_PKT_TLVS_LEN)) { 922 qdf_nbuf_set_pktlen(nbuf, RX_BUFFER_SIZE); 923 last_nbuf = false; 924 } else { 925 qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + RX_PKT_TLVS_LEN)); 926 last_nbuf = true; 927 } 928 929 *mpdu_len -= (RX_BUFFER_SIZE - RX_PKT_TLVS_LEN); 930 931 return last_nbuf; 932 } 933 934 /** 935 * dp_rx_sg_create() - create a frag_list for MSDUs which are spread across 936 * multiple nbufs. 937 * @nbuf: pointer to the first msdu of an amsdu. 938 * @rx_tlv_hdr: pointer to the start of RX TLV headers. 939 * 940 * 941 * This function implements the creation of RX frag_list for cases 942 * where an MSDU is spread across multiple nbufs. 943 * 944 * Return: returns the head nbuf which contains complete frag_list. 945 */ 946 qdf_nbuf_t dp_rx_sg_create(qdf_nbuf_t nbuf, uint8_t *rx_tlv_hdr) 947 { 948 qdf_nbuf_t parent, next, frag_list; 949 uint16_t frag_list_len = 0; 950 uint16_t mpdu_len; 951 bool last_nbuf; 952 953 mpdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr); 954 /* 955 * this is a case where the complete msdu fits in one single nbuf. 956 * in this case HW sets both start and end bit and we only need to 957 * reset these bits for RAW mode simulator to decap the pkt 958 */ 959 if (qdf_nbuf_is_rx_chfrag_start(nbuf) && 960 qdf_nbuf_is_rx_chfrag_end(nbuf)) { 961 qdf_nbuf_set_pktlen(nbuf, mpdu_len + RX_PKT_TLVS_LEN); 962 qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN); 963 return nbuf; 964 } 965 966 /* 967 * This is a case where we have multiple msdus (A-MSDU) spread across 968 * multiple nbufs. here we create a fraglist out of these nbufs. 969 * 970 * the moment we encounter a nbuf with continuation bit set we 971 * know for sure we have an MSDU which is spread across multiple 972 * nbufs. We loop through and reap nbufs till we reach last nbuf. 973 */ 974 parent = nbuf; 975 frag_list = nbuf->next; 976 nbuf = nbuf->next; 977 978 /* 979 * set the start bit in the first nbuf we encounter with continuation 980 * bit set. This has the proper mpdu length set as it is the first 981 * msdu of the mpdu. this becomes the parent nbuf and the subsequent 982 * nbufs will form the frag_list of the parent nbuf. 983 */ 984 qdf_nbuf_set_rx_chfrag_start(parent, 1); 985 last_nbuf = dp_rx_adjust_nbuf_len(parent, &mpdu_len); 986 987 /* 988 * this is where we set the length of the fragments which are 989 * associated to the parent nbuf. We iterate through the frag_list 990 * till we hit the last_nbuf of the list. 991 */ 992 do { 993 last_nbuf = dp_rx_adjust_nbuf_len(nbuf, &mpdu_len); 994 qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN); 995 frag_list_len += qdf_nbuf_len(nbuf); 996 997 if (last_nbuf) { 998 next = nbuf->next; 999 nbuf->next = NULL; 1000 break; 1001 } 1002 1003 nbuf = nbuf->next; 1004 } while (!last_nbuf); 1005 1006 qdf_nbuf_set_rx_chfrag_start(nbuf, 0); 1007 qdf_nbuf_append_ext_list(parent, frag_list, frag_list_len); 1008 parent->next = next; 1009 1010 qdf_nbuf_pull_head(parent, RX_PKT_TLVS_LEN); 1011 return parent; 1012 } 1013 1014 static inline void dp_rx_deliver_to_stack(struct dp_vdev *vdev, 1015 struct dp_peer *peer, 1016 qdf_nbuf_t nbuf_head, 1017 qdf_nbuf_t nbuf_tail) 1018 { 1019 /* 1020 * highly unlikely to have a vdev without a registered rx 1021 * callback function. if so let us free the nbuf_list. 1022 */ 1023 if (qdf_unlikely(!vdev->osif_rx)) { 1024 qdf_nbuf_t nbuf; 1025 do { 1026 nbuf = nbuf_head; 1027 nbuf_head = nbuf_head->next; 1028 qdf_nbuf_free(nbuf); 1029 } while (nbuf_head); 1030 1031 return; 1032 } 1033 1034 if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw) || 1035 (vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)) { 1036 vdev->osif_rsim_rx_decap(vdev->osif_vdev, &nbuf_head, 1037 &nbuf_tail, (struct cdp_peer *) peer); 1038 } 1039 1040 vdev->osif_rx(vdev->osif_vdev, nbuf_head); 1041 1042 } 1043 1044 /** 1045 * dp_rx_cksum_offload() - set the nbuf checksum as defined by hardware. 1046 * @nbuf: pointer to the first msdu of an amsdu. 1047 * @rx_tlv_hdr: pointer to the start of RX TLV headers. 1048 * 1049 * The ipsumed field of the skb is set based on whether HW validated the 1050 * IP/TCP/UDP checksum. 1051 * 1052 * Return: void 1053 */ 1054 static inline void dp_rx_cksum_offload(struct dp_pdev *pdev, 1055 qdf_nbuf_t nbuf, 1056 uint8_t *rx_tlv_hdr) 1057 { 1058 qdf_nbuf_rx_cksum_t cksum = {0}; 1059 bool ip_csum_err = hal_rx_attn_ip_cksum_fail_get(rx_tlv_hdr); 1060 bool tcp_udp_csum_er = hal_rx_attn_tcp_udp_cksum_fail_get(rx_tlv_hdr); 1061 1062 if (qdf_likely(!ip_csum_err && !tcp_udp_csum_er)) { 1063 cksum.l4_result = QDF_NBUF_RX_CKSUM_TCP_UDP_UNNECESSARY; 1064 qdf_nbuf_set_rx_cksum(nbuf, &cksum); 1065 } else { 1066 DP_STATS_INCC(pdev, err.ip_csum_err, 1, ip_csum_err); 1067 DP_STATS_INCC(pdev, err.tcp_udp_csum_err, 1, tcp_udp_csum_er); 1068 } 1069 } 1070 1071 /** 1072 * dp_rx_msdu_stats_update() - update per msdu stats. 1073 * @soc: core txrx main context 1074 * @nbuf: pointer to the first msdu of an amsdu. 1075 * @rx_tlv_hdr: pointer to the start of RX TLV headers. 1076 * @peer: pointer to the peer object. 1077 * @ring_id: reo dest ring number on which pkt is reaped. 1078 * 1079 * update all the per msdu stats for that nbuf. 1080 * Return: void 1081 */ 1082 static void dp_rx_msdu_stats_update(struct dp_soc *soc, 1083 qdf_nbuf_t nbuf, 1084 uint8_t *rx_tlv_hdr, 1085 struct dp_peer *peer, 1086 uint8_t ring_id) 1087 { 1088 bool is_ampdu, is_not_amsdu; 1089 uint16_t peer_id; 1090 uint32_t sgi, mcs, tid, nss, bw, reception_type, pkt_type; 1091 struct dp_vdev *vdev = peer->vdev; 1092 struct ether_header *eh; 1093 uint16_t msdu_len = qdf_nbuf_len(nbuf); 1094 1095 peer_id = DP_PEER_METADATA_PEER_ID_GET( 1096 hal_rx_mpdu_peer_meta_data_get(rx_tlv_hdr)); 1097 1098 is_not_amsdu = qdf_nbuf_is_rx_chfrag_start(nbuf) & 1099 qdf_nbuf_is_rx_chfrag_end(nbuf); 1100 1101 DP_STATS_INC_PKT(peer, rx.rcvd_reo[ring_id], 1, msdu_len); 1102 DP_STATS_INCC(peer, rx.non_amsdu_cnt, 1, is_not_amsdu); 1103 DP_STATS_INCC(peer, rx.amsdu_cnt, 1, !is_not_amsdu); 1104 1105 if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(rx_tlv_hdr) && 1106 (vdev->rx_decap_type == htt_cmn_pkt_type_ethernet))) { 1107 eh = (struct ether_header *)qdf_nbuf_data(nbuf); 1108 DP_STATS_INC_PKT(peer, rx.multicast, 1, msdu_len); 1109 if (IEEE80211_IS_BROADCAST(eh->ether_dhost)) { 1110 DP_STATS_INC_PKT(peer, rx.bcast, 1, msdu_len); 1111 1112 } 1113 } 1114 1115 /* 1116 * currently we can return from here as we have similar stats 1117 * updated at per ppdu level instead of msdu level 1118 */ 1119 if (!soc->process_rx_status) 1120 return; 1121 1122 is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(rx_tlv_hdr); 1123 DP_STATS_INCC(peer, rx.ampdu_cnt, 1, is_ampdu); 1124 DP_STATS_INCC(peer, rx.non_ampdu_cnt, 1, !(is_ampdu)); 1125 1126 sgi = hal_rx_msdu_start_sgi_get(rx_tlv_hdr); 1127 mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr); 1128 tid = hal_rx_mpdu_start_tid_get(soc->hal_soc, rx_tlv_hdr); 1129 bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr); 1130 reception_type = hal_rx_msdu_start_reception_type_get(soc->hal_soc, 1131 rx_tlv_hdr); 1132 nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr); 1133 pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr); 1134 1135 /* Save tid to skb->priority */ 1136 DP_RX_TID_SAVE(nbuf, tid); 1137 1138 DP_STATS_INC(peer, rx.bw[bw], 1); 1139 DP_STATS_INC(peer, rx.nss[nss], 1); 1140 DP_STATS_INC(peer, rx.sgi_count[sgi], 1); 1141 DP_STATS_INCC(peer, rx.err.mic_err, 1, 1142 hal_rx_mpdu_end_mic_err_get(rx_tlv_hdr)); 1143 DP_STATS_INCC(peer, rx.err.decrypt_err, 1, 1144 hal_rx_mpdu_end_decrypt_err_get(rx_tlv_hdr)); 1145 1146 DP_STATS_INC(peer, rx.wme_ac_type[TID_TO_WME_AC(tid)], 1); 1147 DP_STATS_INC(peer, rx.reception_type[reception_type], 1); 1148 1149 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS], 1, 1150 ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_A))); 1151 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1, 1152 ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_A))); 1153 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS], 1, 1154 ((mcs >= MAX_MCS_11B) && (pkt_type == DOT11_B))); 1155 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1, 1156 ((mcs <= MAX_MCS_11B) && (pkt_type == DOT11_B))); 1157 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS], 1, 1158 ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_N))); 1159 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1, 1160 ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_N))); 1161 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS], 1, 1162 ((mcs >= MAX_MCS_11AC) && (pkt_type == DOT11_AC))); 1163 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1, 1164 ((mcs <= MAX_MCS_11AC) && (pkt_type == DOT11_AC))); 1165 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS], 1, 1166 ((mcs >= MAX_MCS) && (pkt_type == DOT11_AX))); 1167 DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1, 1168 ((mcs <= MAX_MCS) && (pkt_type == DOT11_AX))); 1169 1170 if ((soc->process_rx_status) && 1171 hal_rx_attn_first_mpdu_get(rx_tlv_hdr)) { 1172 if (soc->cdp_soc.ol_ops->update_dp_stats) { 1173 soc->cdp_soc.ol_ops->update_dp_stats( 1174 vdev->pdev->ctrl_pdev, 1175 &peer->stats, 1176 peer_id, 1177 UPDATE_PEER_STATS); 1178 } 1179 } 1180 } 1181 1182 #ifdef WDS_VENDOR_EXTENSION 1183 int dp_wds_rx_policy_check( 1184 uint8_t *rx_tlv_hdr, 1185 struct dp_vdev *vdev, 1186 struct dp_peer *peer, 1187 int rx_mcast 1188 ) 1189 { 1190 struct dp_peer *bss_peer; 1191 int fr_ds, to_ds, rx_3addr, rx_4addr; 1192 int rx_policy_ucast, rx_policy_mcast; 1193 1194 if (vdev->opmode == wlan_op_mode_ap) { 1195 TAILQ_FOREACH(bss_peer, &vdev->peer_list, peer_list_elem) { 1196 if (bss_peer->bss_peer) { 1197 /* if wds policy check is not enabled on this vdev, accept all frames */ 1198 if (!bss_peer->wds_ecm.wds_rx_filter) { 1199 return 1; 1200 } 1201 break; 1202 } 1203 } 1204 rx_policy_ucast = bss_peer->wds_ecm.wds_rx_ucast_4addr; 1205 rx_policy_mcast = bss_peer->wds_ecm.wds_rx_mcast_4addr; 1206 } else { /* sta mode */ 1207 if (!peer->wds_ecm.wds_rx_filter) { 1208 return 1; 1209 } 1210 rx_policy_ucast = peer->wds_ecm.wds_rx_ucast_4addr; 1211 rx_policy_mcast = peer->wds_ecm.wds_rx_mcast_4addr; 1212 } 1213 1214 /* ------------------------------------------------ 1215 * self 1216 * peer- rx rx- 1217 * wds ucast mcast dir policy accept note 1218 * ------------------------------------------------ 1219 * 1 1 0 11 x1 1 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint met; so, accept 1220 * 1 1 0 01 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop 1221 * 1 1 0 10 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop 1222 * 1 1 0 00 x1 0 bad frame, won't see it 1223 * 1 0 1 11 1x 1 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint met; so, accept 1224 * 1 0 1 01 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop 1225 * 1 0 1 10 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop 1226 * 1 0 1 00 1x 0 bad frame, won't see it 1227 * 1 1 0 11 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop 1228 * 1 1 0 01 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop 1229 * 1 1 0 10 x0 1 AP configured to accept from-ds Rx ucast from wds peers, constraint met; so, accept 1230 * 1 1 0 00 x0 0 bad frame, won't see it 1231 * 1 0 1 11 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop 1232 * 1 0 1 01 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop 1233 * 1 0 1 10 0x 1 AP configured to accept from-ds Rx mcast from wds peers, constraint met; so, accept 1234 * 1 0 1 00 0x 0 bad frame, won't see it 1235 * 1236 * 0 x x 11 xx 0 we only accept td-ds Rx frames from non-wds peers in mode. 1237 * 0 x x 01 xx 1 1238 * 0 x x 10 xx 0 1239 * 0 x x 00 xx 0 bad frame, won't see it 1240 * ------------------------------------------------ 1241 */ 1242 1243 fr_ds = hal_rx_mpdu_get_fr_ds(rx_tlv_hdr); 1244 to_ds = hal_rx_mpdu_get_to_ds(rx_tlv_hdr); 1245 rx_3addr = fr_ds ^ to_ds; 1246 rx_4addr = fr_ds & to_ds; 1247 1248 if (vdev->opmode == wlan_op_mode_ap) { 1249 if ((!peer->wds_enabled && rx_3addr && to_ds) || 1250 (peer->wds_enabled && !rx_mcast && (rx_4addr == rx_policy_ucast)) || 1251 (peer->wds_enabled && rx_mcast && (rx_4addr == rx_policy_mcast))) { 1252 return 1; 1253 } 1254 } else { /* sta mode */ 1255 if ((!rx_mcast && (rx_4addr == rx_policy_ucast)) || 1256 (rx_mcast && (rx_4addr == rx_policy_mcast))) { 1257 return 1; 1258 } 1259 } 1260 return 0; 1261 } 1262 #else 1263 int dp_wds_rx_policy_check( 1264 uint8_t *rx_tlv_hdr, 1265 struct dp_vdev *vdev, 1266 struct dp_peer *peer, 1267 int rx_mcast 1268 ) 1269 { 1270 return 1; 1271 } 1272 #endif 1273 1274 /** 1275 * dp_rx_process() - Brain of the Rx processing functionality 1276 * Called from the bottom half (tasklet/NET_RX_SOFTIRQ) 1277 * @soc: core txrx main context 1278 * @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced 1279 * @reo_ring_num: ring number (0, 1, 2 or 3) of the reo ring. 1280 * @quota: No. of units (packets) that can be serviced in one shot. 1281 * 1282 * This function implements the core of Rx functionality. This is 1283 * expected to handle only non-error frames. 1284 * 1285 * Return: uint32_t: No. of elements processed 1286 */ 1287 uint32_t dp_rx_process(struct dp_intr *int_ctx, void *hal_ring, 1288 uint8_t reo_ring_num, uint32_t quota) 1289 { 1290 void *hal_soc; 1291 void *ring_desc; 1292 struct dp_rx_desc *rx_desc = NULL; 1293 qdf_nbuf_t nbuf, next; 1294 union dp_rx_desc_list_elem_t *head[MAX_PDEV_CNT] = { NULL }; 1295 union dp_rx_desc_list_elem_t *tail[MAX_PDEV_CNT] = { NULL }; 1296 uint32_t rx_bufs_used = 0, rx_buf_cookie; 1297 uint32_t l2_hdr_offset = 0; 1298 uint16_t msdu_len = 0; 1299 uint16_t peer_id; 1300 struct dp_peer *peer = NULL; 1301 struct dp_vdev *vdev = NULL; 1302 uint32_t pkt_len = 0; 1303 struct hal_rx_mpdu_desc_info mpdu_desc_info = { 0 }; 1304 struct hal_rx_msdu_desc_info msdu_desc_info = { 0 }; 1305 enum hal_reo_error_status error; 1306 uint32_t peer_mdata; 1307 uint8_t *rx_tlv_hdr; 1308 uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 }; 1309 uint8_t mac_id = 0; 1310 struct dp_pdev *pdev; 1311 struct dp_srng *dp_rxdma_srng; 1312 struct rx_desc_pool *rx_desc_pool; 1313 struct dp_soc *soc = int_ctx->soc; 1314 uint8_t ring_id = 0; 1315 uint8_t core_id = 0; 1316 qdf_nbuf_t nbuf_head = NULL; 1317 qdf_nbuf_t nbuf_tail = NULL; 1318 qdf_nbuf_t deliver_list_head = NULL; 1319 qdf_nbuf_t deliver_list_tail = NULL; 1320 1321 DP_HIST_INIT(); 1322 /* Debug -- Remove later */ 1323 qdf_assert(soc && hal_ring); 1324 1325 hal_soc = soc->hal_soc; 1326 1327 /* Debug -- Remove later */ 1328 qdf_assert(hal_soc); 1329 1330 hif_pm_runtime_mark_last_busy(soc->osdev->dev); 1331 1332 if (qdf_unlikely(hal_srng_access_start(hal_soc, hal_ring))) { 1333 1334 /* 1335 * Need API to convert from hal_ring pointer to 1336 * Ring Type / Ring Id combo 1337 */ 1338 DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1); 1339 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 1340 FL("HAL RING Access Failed -- %pK"), hal_ring); 1341 hal_srng_access_end(hal_soc, hal_ring); 1342 goto done; 1343 } 1344 1345 /* 1346 * start reaping the buffers from reo ring and queue 1347 * them in per vdev queue. 1348 * Process the received pkts in a different per vdev loop. 1349 */ 1350 while (qdf_likely(quota)) { 1351 ring_desc = hal_srng_dst_get_next(hal_soc, hal_ring); 1352 1353 /* 1354 * in case HW has updated hp after we cached the hp 1355 * ring_desc can be NULL even there are entries 1356 * available in the ring. Update the cached_hp 1357 * and reap the buffers available to read complete 1358 * mpdu in one reap 1359 * 1360 * This is needed for RAW mode we have to read all 1361 * msdus corresponding to amsdu in one reap to create 1362 * SG list properly but due to mismatch in cached_hp 1363 * and actual hp sometimes we are unable to read 1364 * complete mpdu in one reap. 1365 */ 1366 if (qdf_unlikely(!ring_desc)) { 1367 hal_srng_access_start_unlocked(hal_soc, hal_ring); 1368 ring_desc = hal_srng_dst_get_next(hal_soc, hal_ring); 1369 if (!ring_desc) 1370 break; 1371 } 1372 1373 error = HAL_RX_ERROR_STATUS_GET(ring_desc); 1374 ring_id = hal_srng_ring_id_get(hal_ring); 1375 1376 if (qdf_unlikely(error == HAL_REO_ERROR_DETECTED)) { 1377 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1378 FL("HAL RING 0x%pK:error %d"), hal_ring, error); 1379 DP_STATS_INC(soc, rx.err.hal_reo_error[ring_id], 1); 1380 /* Don't know how to deal with this -- assert */ 1381 qdf_assert(0); 1382 } 1383 1384 rx_buf_cookie = HAL_RX_REO_BUF_COOKIE_GET(ring_desc); 1385 1386 rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie); 1387 1388 1389 qdf_assert(rx_desc); 1390 rx_bufs_reaped[rx_desc->pool_id]++; 1391 1392 /* TODO */ 1393 /* 1394 * Need a separate API for unmapping based on 1395 * phyiscal address 1396 */ 1397 qdf_nbuf_unmap_single(soc->osdev, rx_desc->nbuf, 1398 QDF_DMA_BIDIRECTIONAL); 1399 1400 core_id = smp_processor_id(); 1401 DP_STATS_INC(soc, rx.ring_packets[core_id][ring_id], 1); 1402 1403 /* Get MPDU DESC info */ 1404 hal_rx_mpdu_desc_info_get(ring_desc, &mpdu_desc_info); 1405 1406 hal_rx_mpdu_peer_meta_data_set(qdf_nbuf_data(rx_desc->nbuf), 1407 mpdu_desc_info.peer_meta_data); 1408 1409 /* Get MSDU DESC info */ 1410 hal_rx_msdu_desc_info_get(ring_desc, &msdu_desc_info); 1411 1412 /* 1413 * save msdu flags first, last and continuation msdu in 1414 * nbuf->cb 1415 */ 1416 if (msdu_desc_info.msdu_flags & HAL_MSDU_F_FIRST_MSDU_IN_MPDU) 1417 qdf_nbuf_set_rx_chfrag_start(rx_desc->nbuf, 1); 1418 1419 if (msdu_desc_info.msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION) 1420 qdf_nbuf_set_rx_chfrag_cont(rx_desc->nbuf, 1); 1421 1422 if (msdu_desc_info.msdu_flags & HAL_MSDU_F_LAST_MSDU_IN_MPDU) 1423 qdf_nbuf_set_rx_chfrag_end(rx_desc->nbuf, 1); 1424 1425 QDF_NBUF_CB_RX_CTX_ID(rx_desc->nbuf) = reo_ring_num; 1426 DP_RX_LIST_APPEND(nbuf_head, nbuf_tail, rx_desc->nbuf); 1427 1428 /* 1429 * if continuation bit is set then we have MSDU spread 1430 * across multiple buffers, let us not decrement quota 1431 * till we reap all buffers of that MSDU. 1432 */ 1433 if (qdf_likely(!qdf_nbuf_is_rx_chfrag_cont(rx_desc->nbuf))) 1434 quota -= 1; 1435 1436 1437 dp_rx_add_to_free_desc_list(&head[rx_desc->pool_id], 1438 &tail[rx_desc->pool_id], 1439 rx_desc); 1440 } 1441 done: 1442 hal_srng_access_end(hal_soc, hal_ring); 1443 1444 if (nbuf_tail) 1445 QDF_NBUF_CB_RX_FLUSH_IND(nbuf_tail) = 1; 1446 1447 /* Update histogram statistics by looping through pdev's */ 1448 DP_RX_HIST_STATS_PER_PDEV(); 1449 1450 for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) { 1451 /* 1452 * continue with next mac_id if no pkts were reaped 1453 * from that pool 1454 */ 1455 if (!rx_bufs_reaped[mac_id]) 1456 continue; 1457 1458 pdev = soc->pdev_list[mac_id]; 1459 dp_rxdma_srng = &pdev->rx_refill_buf_ring; 1460 rx_desc_pool = &soc->rx_desc_buf[mac_id]; 1461 1462 dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng, 1463 rx_desc_pool, rx_bufs_reaped[mac_id], 1464 &head[mac_id], &tail[mac_id]); 1465 } 1466 1467 /* Peer can be NULL is case of LFR */ 1468 if (qdf_likely(peer != NULL)) 1469 vdev = NULL; 1470 1471 /* 1472 * BIG loop where each nbuf is dequeued from global queue, 1473 * processed and queued back on a per vdev basis. These nbufs 1474 * are sent to stack as and when we run out of nbufs 1475 * or a new nbuf dequeued from global queue has a different 1476 * vdev when compared to previous nbuf. 1477 */ 1478 nbuf = nbuf_head; 1479 while (nbuf) { 1480 next = nbuf->next; 1481 rx_tlv_hdr = qdf_nbuf_data(nbuf); 1482 1483 /* 1484 * Check if DMA completed -- msdu_done is the last bit 1485 * to be written 1486 */ 1487 if (qdf_unlikely(!hal_rx_attn_msdu_done_get(rx_tlv_hdr))) { 1488 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1489 FL("MSDU DONE failure")); 1490 hal_rx_dump_pkt_tlvs(hal_soc, rx_tlv_hdr, 1491 QDF_TRACE_LEVEL_INFO); 1492 qdf_assert(0); 1493 } 1494 1495 peer_mdata = hal_rx_mpdu_peer_meta_data_get(rx_tlv_hdr); 1496 peer_id = DP_PEER_METADATA_PEER_ID_GET(peer_mdata); 1497 peer = dp_peer_find_by_id(soc, peer_id); 1498 1499 if (peer) { 1500 QDF_NBUF_CB_DP_TRACE_PRINT(nbuf) = false; 1501 qdf_dp_trace_set_track(nbuf, QDF_RX); 1502 QDF_NBUF_CB_RX_DP_TRACE(nbuf) = 1; 1503 QDF_NBUF_CB_RX_PACKET_TRACK(nbuf) = 1504 QDF_NBUF_RX_PKT_DATA_TRACK; 1505 } 1506 1507 rx_bufs_used++; 1508 1509 if (deliver_list_head && peer && (vdev != peer->vdev)) { 1510 dp_rx_deliver_to_stack(vdev, peer, deliver_list_head, 1511 deliver_list_tail); 1512 deliver_list_head = NULL; 1513 deliver_list_tail = NULL; 1514 } 1515 1516 if (qdf_likely(peer != NULL)) { 1517 vdev = peer->vdev; 1518 } else { 1519 DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1, 1520 qdf_nbuf_len(nbuf)); 1521 qdf_nbuf_free(nbuf); 1522 nbuf = next; 1523 continue; 1524 } 1525 1526 if (qdf_unlikely(vdev == NULL)) { 1527 qdf_nbuf_free(nbuf); 1528 nbuf = next; 1529 DP_STATS_INC(soc, rx.err.invalid_vdev, 1); 1530 dp_peer_unref_del_find_by_id(peer); 1531 continue; 1532 } 1533 1534 DP_HIST_PACKET_COUNT_INC(vdev->pdev->pdev_id); 1535 /* 1536 * First IF condition: 1537 * 802.11 Fragmented pkts are reinjected to REO 1538 * HW block as SG pkts and for these pkts we only 1539 * need to pull the RX TLVS header length. 1540 * Second IF condition: 1541 * The below condition happens when an MSDU is spread 1542 * across multiple buffers. This can happen in two cases 1543 * 1. The nbuf size is smaller then the received msdu. 1544 * ex: we have set the nbuf size to 2048 during 1545 * nbuf_alloc. but we received an msdu which is 1546 * 2304 bytes in size then this msdu is spread 1547 * across 2 nbufs. 1548 * 1549 * 2. AMSDUs when RAW mode is enabled. 1550 * ex: 1st MSDU is in 1st nbuf and 2nd MSDU is spread 1551 * across 1st nbuf and 2nd nbuf and last MSDU is 1552 * spread across 2nd nbuf and 3rd nbuf. 1553 * 1554 * for these scenarios let us create a skb frag_list and 1555 * append these buffers till the last MSDU of the AMSDU 1556 * Third condition: 1557 * This is the most likely case, we receive 802.3 pkts 1558 * decapsulated by HW, here we need to set the pkt length. 1559 */ 1560 if (qdf_unlikely(qdf_nbuf_get_ext_list(nbuf))) 1561 qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN); 1562 else if (qdf_unlikely(vdev->rx_decap_type == 1563 htt_cmn_pkt_type_raw)) { 1564 msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr); 1565 nbuf = dp_rx_sg_create(nbuf, rx_tlv_hdr); 1566 1567 DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1); 1568 DP_STATS_INC_PKT(peer, rx.raw, 1, 1569 msdu_len); 1570 1571 next = nbuf->next; 1572 } else { 1573 l2_hdr_offset = 1574 hal_rx_msdu_end_l3_hdr_padding_get(rx_tlv_hdr); 1575 1576 msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr); 1577 pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN; 1578 1579 qdf_nbuf_set_pktlen(nbuf, pkt_len); 1580 qdf_nbuf_pull_head(nbuf, 1581 RX_PKT_TLVS_LEN + 1582 l2_hdr_offset); 1583 } 1584 1585 if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer, 1586 hal_rx_msdu_end_da_is_mcbc_get(rx_tlv_hdr))) { 1587 QDF_TRACE(QDF_MODULE_ID_DP, 1588 QDF_TRACE_LEVEL_ERROR, 1589 FL("Policy Check Drop pkt")); 1590 /* Drop & free packet */ 1591 qdf_nbuf_free(nbuf); 1592 /* Statistics */ 1593 nbuf = next; 1594 dp_peer_unref_del_find_by_id(peer); 1595 continue; 1596 } 1597 1598 if (qdf_unlikely(peer && peer->bss_peer)) { 1599 QDF_TRACE(QDF_MODULE_ID_DP, 1600 QDF_TRACE_LEVEL_ERROR, 1601 FL("received pkt with same src MAC")); 1602 DP_STATS_INC(vdev->pdev, dropped.mec, 1); 1603 1604 /* Drop & free packet */ 1605 qdf_nbuf_free(nbuf); 1606 /* Statistics */ 1607 nbuf = next; 1608 dp_peer_unref_del_find_by_id(peer); 1609 continue; 1610 } 1611 1612 if (qdf_unlikely(peer && (peer->nawds_enabled == true) && 1613 (hal_rx_msdu_end_da_is_mcbc_get(rx_tlv_hdr)) && 1614 (hal_rx_get_mpdu_mac_ad4_valid(rx_tlv_hdr) == false))) { 1615 DP_STATS_INC(peer, rx.nawds_mcast_drop, 1); 1616 qdf_nbuf_free(nbuf); 1617 nbuf = next; 1618 dp_peer_unref_del_find_by_id(peer); 1619 continue; 1620 } 1621 1622 dp_rx_cksum_offload(vdev->pdev, nbuf, rx_tlv_hdr); 1623 1624 dp_set_rx_queue(nbuf, ring_id); 1625 1626 /* 1627 * HW structures call this L3 header padding -- 1628 * even though this is actually the offset from 1629 * the buffer beginning where the L2 header 1630 * begins. 1631 */ 1632 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, 1633 FL("rxhash: flow id toeplitz: 0x%x"), 1634 hal_rx_msdu_start_toeplitz_get(rx_tlv_hdr)); 1635 1636 dp_rx_msdu_stats_update(soc, nbuf, rx_tlv_hdr, peer, ring_id); 1637 1638 if (qdf_unlikely(vdev->mesh_vdev)) { 1639 if (dp_rx_filter_mesh_packets(vdev, nbuf, 1640 rx_tlv_hdr) 1641 == QDF_STATUS_SUCCESS) { 1642 QDF_TRACE(QDF_MODULE_ID_DP, 1643 QDF_TRACE_LEVEL_INFO_MED, 1644 FL("mesh pkt filtered")); 1645 DP_STATS_INC(vdev->pdev, dropped.mesh_filter, 1646 1); 1647 1648 qdf_nbuf_free(nbuf); 1649 nbuf = next; 1650 dp_peer_unref_del_find_by_id(peer); 1651 continue; 1652 } 1653 dp_rx_fill_mesh_stats(vdev, nbuf, rx_tlv_hdr, peer); 1654 } 1655 1656 #ifdef QCA_WIFI_NAPIER_EMULATION_DBG /* Debug code, remove later */ 1657 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1658 "p_id %d msdu_len %d hdr_off %d", 1659 peer_id, msdu_len, l2_hdr_offset); 1660 1661 print_hex_dump(KERN_ERR, 1662 "\t Pkt Data:", DUMP_PREFIX_NONE, 32, 4, 1663 qdf_nbuf_data(nbuf), 128, false); 1664 #endif /* NAPIER_EMULATION */ 1665 1666 if (qdf_likely(vdev->rx_decap_type == 1667 htt_cmn_pkt_type_ethernet) && 1668 qdf_likely(!vdev->mesh_vdev)) { 1669 /* WDS Source Port Learning */ 1670 if (vdev->wds_enabled) 1671 dp_rx_wds_srcport_learn(soc, rx_tlv_hdr, 1672 peer, nbuf); 1673 1674 /* Intrabss-fwd */ 1675 if (dp_rx_check_ap_bridge(vdev)) 1676 if (dp_rx_intrabss_fwd(soc, 1677 peer, 1678 rx_tlv_hdr, 1679 nbuf)) { 1680 nbuf = next; 1681 dp_peer_unref_del_find_by_id(peer); 1682 continue; /* Get next desc */ 1683 } 1684 } 1685 1686 dp_rx_lro(rx_tlv_hdr, peer, nbuf, int_ctx->lro_ctx); 1687 qdf_nbuf_cb_update_peer_local_id(nbuf, peer->local_id); 1688 DP_RX_LIST_APPEND(deliver_list_head, 1689 deliver_list_tail, 1690 nbuf); 1691 DP_STATS_INC_PKT(peer, rx.to_stack, 1, 1692 qdf_nbuf_len(nbuf)); 1693 1694 nbuf = next; 1695 dp_peer_unref_del_find_by_id(peer); 1696 } 1697 1698 if (deliver_list_head) 1699 dp_rx_deliver_to_stack(vdev, peer, deliver_list_head, 1700 deliver_list_tail); 1701 1702 return rx_bufs_used; /* Assume no scale factor for now */ 1703 } 1704 1705 /** 1706 * dp_rx_detach() - detach dp rx 1707 * @pdev: core txrx pdev context 1708 * 1709 * This function will detach DP RX into main device context 1710 * will free DP Rx resources. 1711 * 1712 * Return: void 1713 */ 1714 void 1715 dp_rx_pdev_detach(struct dp_pdev *pdev) 1716 { 1717 uint8_t pdev_id = pdev->pdev_id; 1718 struct dp_soc *soc = pdev->soc; 1719 struct rx_desc_pool *rx_desc_pool; 1720 1721 rx_desc_pool = &soc->rx_desc_buf[pdev_id]; 1722 1723 if (rx_desc_pool->pool_size != 0) { 1724 dp_rx_desc_pool_free(soc, pdev_id, rx_desc_pool); 1725 } 1726 1727 return; 1728 } 1729 1730 /** 1731 * dp_rx_attach() - attach DP RX 1732 * @pdev: core txrx pdev context 1733 * 1734 * This function will attach a DP RX instance into the main 1735 * device (SOC) context. Will allocate dp rx resource and 1736 * initialize resources. 1737 * 1738 * Return: QDF_STATUS_SUCCESS: success 1739 * QDF_STATUS_E_RESOURCES: Error return 1740 */ 1741 QDF_STATUS 1742 dp_rx_pdev_attach(struct dp_pdev *pdev) 1743 { 1744 uint8_t pdev_id = pdev->pdev_id; 1745 struct dp_soc *soc = pdev->soc; 1746 struct dp_srng rxdma_srng; 1747 uint32_t rxdma_entries; 1748 union dp_rx_desc_list_elem_t *desc_list = NULL; 1749 union dp_rx_desc_list_elem_t *tail = NULL; 1750 struct dp_srng *dp_rxdma_srng; 1751 struct rx_desc_pool *rx_desc_pool; 1752 1753 if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) { 1754 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, 1755 "nss-wifi<4> skip Rx refil %d", pdev_id); 1756 return QDF_STATUS_SUCCESS; 1757 } 1758 1759 pdev = soc->pdev_list[pdev_id]; 1760 rxdma_srng = pdev->rx_refill_buf_ring; 1761 soc->process_rx_status = CONFIG_PROCESS_RX_STATUS; 1762 rxdma_entries = rxdma_srng.alloc_size/hal_srng_get_entrysize( 1763 soc->hal_soc, RXDMA_BUF); 1764 1765 rx_desc_pool = &soc->rx_desc_buf[pdev_id]; 1766 1767 dp_rx_desc_pool_alloc(soc, pdev_id, rxdma_entries*3, rx_desc_pool); 1768 1769 rx_desc_pool->owner = DP_WBM2SW_RBM; 1770 /* For Rx buffers, WBM release ring is SW RING 3,for all pdev's */ 1771 dp_rxdma_srng = &pdev->rx_refill_buf_ring; 1772 dp_rx_buffers_replenish(soc, pdev_id, dp_rxdma_srng, rx_desc_pool, 1773 0, &desc_list, &tail); 1774 1775 return QDF_STATUS_SUCCESS; 1776 } 1777 1778 /* 1779 * dp_rx_nbuf_prepare() - prepare RX nbuf 1780 * @soc: core txrx main context 1781 * @pdev: core txrx pdev context 1782 * 1783 * This function alloc & map nbuf for RX dma usage, retry it if failed 1784 * until retry times reaches max threshold or succeeded. 1785 * 1786 * Return: qdf_nbuf_t pointer if succeeded, NULL if failed. 1787 */ 1788 qdf_nbuf_t 1789 dp_rx_nbuf_prepare(struct dp_soc *soc, struct dp_pdev *pdev) 1790 { 1791 uint8_t *buf; 1792 int32_t nbuf_retry_count; 1793 QDF_STATUS ret; 1794 qdf_nbuf_t nbuf = NULL; 1795 1796 for (nbuf_retry_count = 0; nbuf_retry_count < 1797 QDF_NBUF_ALLOC_MAP_RETRY_THRESHOLD; 1798 nbuf_retry_count++) { 1799 /* Allocate a new skb */ 1800 nbuf = qdf_nbuf_alloc(soc->osdev, 1801 RX_BUFFER_SIZE, 1802 RX_BUFFER_RESERVATION, 1803 RX_BUFFER_ALIGNMENT, 1804 FALSE); 1805 1806 if (nbuf == NULL) { 1807 DP_STATS_INC(pdev, 1808 replenish.nbuf_alloc_fail, 1); 1809 continue; 1810 } 1811 1812 buf = qdf_nbuf_data(nbuf); 1813 1814 memset(buf, 0, RX_BUFFER_SIZE); 1815 1816 ret = qdf_nbuf_map_single(soc->osdev, nbuf, 1817 QDF_DMA_BIDIRECTIONAL); 1818 1819 /* nbuf map failed */ 1820 if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) { 1821 qdf_nbuf_free(nbuf); 1822 DP_STATS_INC(pdev, replenish.map_err, 1); 1823 continue; 1824 } 1825 /* qdf_nbuf alloc and map succeeded */ 1826 break; 1827 } 1828 1829 /* qdf_nbuf still alloc or map failed */ 1830 if (qdf_unlikely(nbuf_retry_count >= 1831 QDF_NBUF_ALLOC_MAP_RETRY_THRESHOLD)) 1832 return NULL; 1833 1834 return nbuf; 1835 } 1836