samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: use txrx_peer in defrag and rx error paths

Browse Source 
Use txrx_peer in defragmentation and rx error paths instead of
main dp peer.

Change-Id: I95bb2f672e49d0f6ddb94a093688b0fbce5e373d
CRs-Fixed: 3095637
This commit is contained in:
Pavankumar Nandeshwar
2021-12-15 03:13:50 -08:00
committed by Madan Koyyalamudi
parent 9c6800383c
commit 04bb406179
3 changed files with 291 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

353
dp/wifi3.0/dp_rx_defrag.c
View File

@@ -88,7 +88,7 @@ static void dp_rx_defrag_frames_free(qdf_nbuf_t frames)
/*
* dp_rx_clear_saved_desc_info(): Clears descriptor info
* @peer: Pointer to the peer data structure
* @txrx peer: Pointer to the peer data structure
* @tid: Transmit ID (TID)
*
* Saves MPDU descriptor info and MSDU link pointer from REO
@@ -96,16 +96,17 @@ static void dp_rx_defrag_frames_free(qdf_nbuf_t frames)
*
* Returns: None
*/
static void dp_rx_clear_saved_desc_info(struct dp_peer *peer, unsigned tid)
static void dp_rx_clear_saved_desc_info(struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
if (peer->rx_tid[tid].dst_ring_desc)
qdf_mem_free(peer->rx_tid[tid].dst_ring_desc);
if (txrx_peer->rx_tid[tid].dst_ring_desc)
qdf_mem_free(txrx_peer->rx_tid[tid].dst_ring_desc);
peer->rx_tid[tid].dst_ring_desc = NULL;
peer->rx_tid[tid].head_frag_desc = NULL;
txrx_peer->rx_tid[tid].dst_ring_desc = NULL;
txrx_peer->rx_tid[tid].head_frag_desc = NULL;
}
static void dp_rx_return_head_frag_desc(struct dp_peer *peer,
static void dp_rx_return_head_frag_desc(struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
struct dp_soc *soc;
@@ -116,23 +117,23 @@ static void dp_rx_return_head_frag_desc(struct dp_peer *peer,
union dp_rx_desc_list_elem_t *tail = NULL;
uint8_t pool_id;
pdev = peer->vdev->pdev;
pdev = txrx_peer->vdev->pdev;
soc = pdev->soc;
if (peer->rx_tid[tid].head_frag_desc) {
pool_id = peer->rx_tid[tid].head_frag_desc->pool_id;
if (txrx_peer->rx_tid[tid].head_frag_desc) {
pool_id = txrx_peer->rx_tid[tid].head_frag_desc->pool_id;
dp_rxdma_srng = &soc->rx_refill_buf_ring[pool_id];
rx_desc_pool = &soc->rx_desc_buf[pool_id];
dp_rx_add_to_free_desc_list(&head, &tail,
peer->rx_tid[tid].head_frag_desc);
txrx_peer->rx_tid[tid].head_frag_desc);
dp_rx_buffers_replenish(soc, 0, dp_rxdma_srng, rx_desc_pool,
1, &head, &tail);
}
if (peer->rx_tid[tid].dst_ring_desc) {
if (txrx_peer->rx_tid[tid].dst_ring_desc) {
if (dp_rx_link_desc_return(soc,
peer->rx_tid[tid].dst_ring_desc,
txrx_peer->rx_tid[tid].dst_ring_desc,
HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
QDF_STATUS_SUCCESS)
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
@@ -142,26 +143,26 @@ static void dp_rx_return_head_frag_desc(struct dp_peer *peer,
/*
* dp_rx_reorder_flush_frag(): Flush the frag list
* @peer: Pointer to the peer data structure
* @txrx_peer: Pointer to the peer data structure
* @tid: Transmit ID (TID)
*
* Flush the per-TID frag list
*
* Returns: None
*/
void dp_rx_reorder_flush_frag(struct dp_peer *peer,
unsigned int tid)
void dp_rx_reorder_flush_frag(struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
dp_info_rl("Flushing TID %d", tid);
if (!peer) {
if (!txrx_peer) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: NULL peer", __func__);
return;
}
dp_rx_return_head_frag_desc(peer, tid);
dp_rx_defrag_cleanup(peer, tid);
dp_rx_return_head_frag_desc(txrx_peer, tid);
dp_rx_defrag_cleanup(txrx_peer, tid);
}
/*
@@ -174,40 +175,41 @@ void dp_rx_reorder_flush_frag(struct dp_peer *peer,
*/
void dp_rx_defrag_waitlist_flush(struct dp_soc *soc)
{
struct dp_rx_tid *rx_reorder = NULL;
struct dp_rx_tid *tmp;
struct dp_rx_tid_defrag *waitlist_elem = NULL;
struct dp_rx_tid_defrag *tmp;
uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
TAILQ_HEAD(, dp_rx_tid) temp_list;
TAILQ_HEAD(, dp_rx_tid_defrag) temp_list;
dp_txrx_ref_handle txrx_ref_handle;
TAILQ_INIT(&temp_list);
dp_debug("Current time %u", now_ms);
qdf_spin_lock_bh(&soc->rx.defrag.defrag_lock);
TAILQ_FOREACH_SAFE(rx_reorder, &soc->rx.defrag.waitlist,
TAILQ_FOREACH_SAFE(waitlist_elem, &soc->rx.defrag.waitlist,
defrag_waitlist_elem, tmp) {
uint32_t tid;
if (rx_reorder->defrag_timeout_ms > now_ms)
if (waitlist_elem->defrag_timeout_ms > now_ms)
break;
tid = rx_reorder->tid;
tid = waitlist_elem->tid;
if (tid >= DP_MAX_TIDS) {
qdf_assert(0);
continue;
}
TAILQ_REMOVE(&soc->rx.defrag.waitlist, rx_reorder,
TAILQ_REMOVE(&soc->rx.defrag.waitlist, waitlist_elem,
defrag_waitlist_elem);
DP_STATS_DEC(soc, rx.rx_frag_wait, 1);
/* Move to temp list and clean-up later */
TAILQ_INSERT_TAIL(&temp_list, rx_reorder,
TAILQ_INSERT_TAIL(&temp_list, waitlist_elem,
defrag_waitlist_elem);
}
if (rx_reorder) {
if (waitlist_elem) {
soc->rx.defrag.next_flush_ms =
rx_reorder->defrag_timeout_ms;
waitlist_elem->defrag_timeout_ms;
} else {
soc->rx.defrag.next_flush_ms =
now_ms + soc->rx.defrag.timeout_ms;
@@ -215,76 +217,82 @@ void dp_rx_defrag_waitlist_flush(struct dp_soc *soc)
qdf_spin_unlock_bh(&soc->rx.defrag.defrag_lock);
TAILQ_FOREACH_SAFE(rx_reorder, &temp_list,
TAILQ_FOREACH_SAFE(waitlist_elem, &temp_list,
defrag_waitlist_elem, tmp) {
struct dp_peer *peer, *temp_peer = NULL;
struct dp_txrx_peer *txrx_peer, *temp_peer = NULL;
qdf_spin_lock_bh(&rx_reorder->tid_lock);
TAILQ_REMOVE(&temp_list, rx_reorder,
qdf_spin_lock_bh(&waitlist_elem->defrag_tid_lock);
TAILQ_REMOVE(&temp_list, waitlist_elem,
defrag_waitlist_elem);
/* get address of current peer */
peer = rx_reorder->defrag_peer;
qdf_spin_unlock_bh(&rx_reorder->tid_lock);
txrx_peer = waitlist_elem->defrag_peer;
qdf_spin_unlock_bh(&waitlist_elem->defrag_tid_lock);
temp_peer = dp_peer_get_ref_by_id(soc, peer->peer_id,
DP_MOD_ID_RX_ERR);
if (temp_peer == peer) {
qdf_spin_lock_bh(&rx_reorder->tid_lock);
dp_rx_reorder_flush_frag(peer, rx_reorder->tid);
qdf_spin_unlock_bh(&rx_reorder->tid_lock);
temp_peer = dp_txrx_peer_get_ref_by_id(soc, txrx_peer->peer_id,
&txrx_ref_handle,
DP_MOD_ID_RX_ERR);
if (temp_peer == txrx_peer) {
qdf_spin_lock_bh(&waitlist_elem->defrag_tid_lock);
dp_rx_reorder_flush_frag(txrx_peer, waitlist_elem->tid);
qdf_spin_unlock_bh(&waitlist_elem->defrag_tid_lock);
}
if (temp_peer)
dp_peer_unref_delete(temp_peer, DP_MOD_ID_RX_ERR);
dp_txrx_peer_unref_delete(txrx_ref_handle,
DP_MOD_ID_RX_ERR);
}
}
/*
* dp_rx_defrag_waitlist_add(): Update per-PDEV defrag wait list
* @peer: Pointer to the peer data structure
* @txrx_peer: Pointer to the peer data structure
* @tid: Transmit ID (TID)
*
* Appends per-tid fragments to global fragment wait list
*
* Returns: None
*/
static void dp_rx_defrag_waitlist_add(struct dp_peer *peer, unsigned tid)
static void dp_rx_defrag_waitlist_add(struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
struct dp_soc *psoc = peer->vdev->pdev->soc;
struct dp_rx_tid *rx_reorder = &peer->rx_tid[tid];
struct dp_soc *psoc = txrx_peer->vdev->pdev->soc;
struct dp_rx_tid_defrag *waitlist_elem = &txrx_peer->rx_tid[tid];
dp_debug("Adding TID %u to waitlist for peer %pK at MAC address "QDF_MAC_ADDR_FMT,
tid, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
dp_debug("Adding TID %u to waitlist for peer %pK with peer_id = %d ",
tid, txrx_peer, txrx_peer->peer_id);
/* TODO: use LIST macros instead of TAIL macros */
qdf_spin_lock_bh(&psoc->rx.defrag.defrag_lock);
if (TAILQ_EMPTY(&psoc->rx.defrag.waitlist))
psoc->rx.defrag.next_flush_ms = rx_reorder->defrag_timeout_ms;
TAILQ_INSERT_TAIL(&psoc->rx.defrag.waitlist, rx_reorder,
defrag_waitlist_elem);
psoc->rx.defrag.next_flush_ms =
waitlist_elem->defrag_timeout_ms;
TAILQ_INSERT_TAIL(&psoc->rx.defrag.waitlist, waitlist_elem,
defrag_waitlist_elem);
DP_STATS_INC(psoc, rx.rx_frag_wait, 1);
qdf_spin_unlock_bh(&psoc->rx.defrag.defrag_lock);
}
/*
* dp_rx_defrag_waitlist_remove(): Remove fragments from waitlist
* @peer: Pointer to the peer data structure
* @txrx peer: Pointer to the peer data structure
* @tid: Transmit ID (TID)
*
* Remove fragments from waitlist
*
* Returns: None
*/
void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid)
void dp_rx_defrag_waitlist_remove(struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
struct dp_pdev *pdev = peer->vdev->pdev;
struct dp_pdev *pdev = txrx_peer->vdev->pdev;
struct dp_soc *soc = pdev->soc;
struct dp_rx_tid *rx_reorder;
struct dp_rx_tid *tmp;
struct dp_rx_tid_defrag *waitlist_elm;
struct dp_rx_tid_defrag *tmp;
dp_debug("Removing TID %u to waitlist for peer %pK at MAC address "QDF_MAC_ADDR_FMT,
tid, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
dp_debug("Removing TID %u to waitlist for peer %pK peer_id = %d ",
tid, txrx_peer, txrx_peer->peer_id);
if (tid >= DP_MAX_TIDS) {
dp_err("TID out of bounds: %d", tid);
@@ -292,17 +300,17 @@ void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid)
}
qdf_spin_lock_bh(&soc->rx.defrag.defrag_lock);
TAILQ_FOREACH_SAFE(rx_reorder, &soc->rx.defrag.waitlist,
TAILQ_FOREACH_SAFE(waitlist_elm, &soc->rx.defrag.waitlist,
defrag_waitlist_elem, tmp) {
struct dp_peer *peer_on_waitlist;
struct dp_txrx_peer *peer_on_waitlist;
/* get address of current peer */
peer_on_waitlist = rx_reorder->defrag_peer;
peer_on_waitlist = waitlist_elm->defrag_peer;
/* Ensure it is TID for same peer */
if (peer_on_waitlist == peer && rx_reorder->tid == tid) {
if (peer_on_waitlist == txrx_peer && waitlist_elm->tid == tid) {
TAILQ_REMOVE(&soc->rx.defrag.waitlist,
rx_reorder, defrag_waitlist_elem);
waitlist_elm, defrag_waitlist_elem);
DP_STATS_DEC(soc, rx.rx_frag_wait, 1);
}
}
@@ -311,7 +319,7 @@ void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid)
/*
* dp_rx_defrag_fraglist_insert(): Create a per-sequence fragment list
* @peer: Pointer to the peer data structure
* @txrx_peer: Pointer to the peer data structure
* @tid: Transmit ID (TID)
* @head_addr: Pointer to head list
* @tail_addr: Pointer to tail list
@@ -322,17 +330,18 @@ void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid)
*
* Returns: Success, if inserted
*/
static QDF_STATUS dp_rx_defrag_fraglist_insert(struct dp_peer *peer, unsigned tid,
qdf_nbuf_t *head_addr, qdf_nbuf_t *tail_addr, qdf_nbuf_t frag,
uint8_t *all_frag_present)
static QDF_STATUS
dp_rx_defrag_fraglist_insert(struct dp_txrx_peer *txrx_peer, unsigned int tid,
qdf_nbuf_t *head_addr, qdf_nbuf_t *tail_addr,
qdf_nbuf_t frag, uint8_t *all_frag_present)
{
struct dp_soc *soc = peer->vdev->pdev->soc;
struct dp_soc *soc = txrx_peer->vdev->pdev->soc;
qdf_nbuf_t next;
qdf_nbuf_t prev = NULL;
qdf_nbuf_t cur;
uint16_t head_fragno, cur_fragno, next_fragno;
uint8_t last_morefrag = 1, count = 0;
struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
struct dp_rx_tid_defrag *rx_tid = &txrx_peer->rx_tid[tid];
uint8_t *rx_desc_info;
qdf_assert(frag);
@@ -893,7 +902,7 @@ static int dp_rx_defrag_pn_check(struct dp_soc *soc, qdf_nbuf_t msdu,
/*
* dp_rx_construct_fraglist(): Construct a nbuf fraglist
* @peer: Pointer to the peer
* @txrx peer: Pointer to the txrx peer
* @head: Pointer to list of fragments
* @hdrsize: Size of the header to be pulled
*
@@ -902,13 +911,14 @@ static int dp_rx_defrag_pn_check(struct dp_soc *soc, qdf_nbuf_t msdu,
* Returns: None
*/
static int
dp_rx_construct_fraglist(struct dp_peer *peer, int tid, qdf_nbuf_t head,
dp_rx_construct_fraglist(struct dp_txrx_peer *txrx_peer, int tid,
qdf_nbuf_t head,
uint16_t hdrsize)
{
struct dp_soc *soc = peer->vdev->pdev->soc;
struct dp_soc *soc = txrx_peer->vdev->pdev->soc;
qdf_nbuf_t msdu = qdf_nbuf_next(head);
qdf_nbuf_t rx_nbuf = msdu;
struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
struct dp_rx_tid_defrag *rx_tid = &txrx_peer->rx_tid[tid];
uint32_t len = 0;
uint64_t cur_pn128[2] = {0, 0}, prev_pn128[2];
int out_of_order = 0;
@@ -921,7 +931,7 @@ dp_rx_construct_fraglist(struct dp_peer *peer, int tid, qdf_nbuf_t head,
index = hal_rx_msdu_is_wlan_mcast(soc->hal_soc, msdu) ? dp_sec_mcast :
dp_sec_ucast;
sec_type = peer->security[index].sec_type;
sec_type = txrx_peer->security[index].sec_type;
if (!(sec_type == cdp_sec_type_none || sec_type == cdp_sec_type_wep128 ||
sec_type == cdp_sec_type_wep104 || sec_type == cdp_sec_type_wep40))
@@ -1021,6 +1031,7 @@ static void dp_rx_defrag_err(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
/*
* dp_rx_defrag_nwifi_to_8023(): Transcap 802.11 to 802.3
* @soc: dp soc handle
* @txrx_peer: txrx_peer handle
* @nbuf: Pointer to the fragment buffer
* @hdrsize: Size of headers
*
@@ -1029,8 +1040,8 @@ static void dp_rx_defrag_err(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
* Returns: None
*/
static void
dp_rx_defrag_nwifi_to_8023(struct dp_soc *soc, struct dp_peer *peer, int tid,
qdf_nbuf_t nbuf, uint16_t hdrsize)
dp_rx_defrag_nwifi_to_8023(struct dp_soc *soc, struct dp_txrx_peer *txrx_peer,
int tid, qdf_nbuf_t nbuf, uint16_t hdrsize)
{
struct llc_snap_hdr_t *llchdr;
struct ethernet_hdr_t *eth_hdr;
@@ -1038,7 +1049,7 @@ dp_rx_defrag_nwifi_to_8023(struct dp_soc *soc, struct dp_peer *peer, int tid,
uint16_t fc = 0;
union dp_align_mac_addr mac_addr;
uint8_t *rx_desc_info = qdf_mem_malloc(soc->rx_pkt_tlv_size);
struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
struct dp_rx_tid_defrag *rx_tid = &txrx_peer->rx_tid[tid];
hal_rx_tlv_get_pn_num(soc->hal_soc, qdf_nbuf_data(nbuf), rx_tid->pn128);
@@ -1134,11 +1145,11 @@ dp_rx_defrag_nwifi_to_8023(struct dp_soc *soc, struct dp_peer *peer, int tid,
*
* Returns: None
*/
static inline void dp_rx_defrag_deliver(struct dp_peer *peer,
static inline void dp_rx_defrag_deliver(struct dp_txrx_peer *txrx_peer,
unsigned int tid,
qdf_nbuf_t head)
{
struct dp_vdev *vdev = peer->vdev;
struct dp_vdev *vdev = txrx_peer->vdev;
struct dp_soc *soc = vdev->pdev->soc;
qdf_nbuf_t deliver_list_head = NULL;
qdf_nbuf_t deliver_list_tail = NULL;
@@ -1152,13 +1163,13 @@ static inline void dp_rx_defrag_deliver(struct dp_peer *peer,
DP_RX_LIST_APPEND(deliver_list_head, deliver_list_tail,
head);
dp_rx_deliver_to_stack(soc, vdev, peer, deliver_list_head,
dp_rx_deliver_to_stack(soc, vdev, txrx_peer, deliver_list_head,
deliver_list_tail);
}
/*
* dp_rx_defrag_reo_reinject(): Reinject the fragment chain back into REO
* @peer: Pointer to the peer
* @txrx peer: Pointer to the peer
* @tid: Transmit Identifier
* @head: Buffer to be reinjected back
*
@@ -1166,17 +1177,17 @@ static inline void dp_rx_defrag_deliver(struct dp_peer *peer,
*
* Returns: QDF_STATUS
*/
static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_peer *peer,
static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_txrx_peer *txrx_peer,
unsigned int tid, qdf_nbuf_t head)
{
struct dp_rx_reorder_array_elem *rx_reorder_array_elem;
rx_reorder_array_elem = peer->rx_tid[tid].array;
rx_reorder_array_elem = txrx_peer->rx_tid[tid].array;
dp_rx_defrag_deliver(peer, tid, head);
dp_rx_defrag_deliver(txrx_peer, tid, head);
rx_reorder_array_elem->head = NULL;
rx_reorder_array_elem->tail = NULL;
dp_rx_return_head_frag_desc(peer, tid);
dp_rx_return_head_frag_desc(txrx_peer, tid);
return QDF_STATUS_SUCCESS;
}
@@ -1222,7 +1233,7 @@ dp_rx_reinject_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
/*
* dp_rx_defrag_reo_reinject(): Reinject the fragment chain back into REO
* @peer: Pointer to the peer
* @txrx_peer: Pointer to the txrx_peer
* @tid: Transmit Identifier
* @head: Buffer to be reinjected back
*
@@ -1230,10 +1241,10 @@ dp_rx_reinject_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
*
* Returns: QDF_STATUS
*/
static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_peer *peer,
static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_txrx_peer *txrx_peer,
unsigned int tid, qdf_nbuf_t head)
{
struct dp_pdev *pdev = peer->vdev->pdev;
struct dp_pdev *pdev = txrx_peer->vdev->pdev;
struct dp_soc *soc = pdev->soc;
struct hal_buf_info buf_info;
struct hal_buf_info temp_buf_info;
@@ -1247,11 +1258,11 @@ static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_peer *peer,
uint32_t *mpdu_wrd;
uint32_t ret, cookie;
hal_ring_desc_t dst_ring_desc =
peer->rx_tid[tid].dst_ring_desc;
txrx_peer->rx_tid[tid].dst_ring_desc;
hal_ring_handle_t hal_srng = soc->reo_reinject_ring.hal_srng;
struct dp_rx_desc *rx_desc = peer->rx_tid[tid].head_frag_desc;
struct dp_rx_desc *rx_desc = txrx_peer->rx_tid[tid].head_frag_desc;
struct dp_rx_reorder_array_elem *rx_reorder_array_elem =
peer->rx_tid[tid].array;
txrx_peer->rx_tid[tid].array;
qdf_nbuf_t nbuf_head;
struct rx_desc_pool *rx_desc_pool = NULL;
void *buf_addr_info = HAL_RX_REO_BUF_ADDR_INFO_GET(dst_ring_desc);
@@ -1436,7 +1447,7 @@ static QDF_STATUS dp_rx_defrag_gcmp_demic(struct dp_soc *soc, qdf_nbuf_t nbuf,
/*
* dp_rx_defrag(): Defragment the fragment chain
* @peer: Pointer to the peer
* @txrx peer: Pointer to the peer
* @tid: Transmit Identifier
* @frag_list_head: Pointer to head list
* @frag_list_tail: Pointer to tail list
@@ -1445,15 +1456,16 @@ static QDF_STATUS dp_rx_defrag_gcmp_demic(struct dp_soc *soc, qdf_nbuf_t nbuf,
*
* Returns: QDF_STATUS
*/
static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
qdf_nbuf_t frag_list_head, qdf_nbuf_t frag_list_tail)
static QDF_STATUS dp_rx_defrag(struct dp_txrx_peer *txrx_peer, unsigned int tid,
qdf_nbuf_t frag_list_head,
qdf_nbuf_t frag_list_tail)
{
qdf_nbuf_t tmp_next, prev;
qdf_nbuf_t cur = frag_list_head, msdu;
uint32_t index, tkip_demic = 0;
uint16_t hdr_space;
uint8_t key[DEFRAG_IEEE80211_KEY_LEN];
struct dp_vdev *vdev = peer->vdev;
struct dp_vdev *vdev = txrx_peer->vdev;
struct dp_soc *soc = vdev->pdev->soc;
uint8_t status = 0;
@@ -1477,9 +1489,9 @@ static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
"%s: index %d Security type: %d", __func__,
index, peer->security[index].sec_type);
index, txrx_peer->security[index].sec_type);
switch (peer->security[index].sec_type) {
switch (txrx_peer->security[index].sec_type) {
case cdp_sec_type_tkip:
tkip_demic = 1;
@@ -1569,7 +1581,7 @@ static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
if (tkip_demic) {
msdu = frag_list_head;
qdf_mem_copy(key,
&peer->security[index].michael_key[0],
&txrx_peer->security[index].michael_key[0],
IEEE80211_WEP_MICLEN);
status = dp_rx_defrag_tkip_demic(soc, key, msdu,
soc->rx_pkt_tlv_size +
@@ -1588,9 +1600,11 @@ static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
}
/* Convert the header to 802.3 header */
dp_rx_defrag_nwifi_to_8023(soc, peer, tid, frag_list_head, hdr_space);
dp_rx_defrag_nwifi_to_8023(soc, txrx_peer, tid, frag_list_head,
hdr_space);
if (qdf_nbuf_next(frag_list_head)) {
if (dp_rx_construct_fraglist(peer, tid, frag_list_head, hdr_space))
if (dp_rx_construct_fraglist(txrx_peer, tid, frag_list_head,
hdr_space))
return QDF_STATUS_E_DEFRAG_ERROR;
}
@@ -1599,15 +1613,15 @@ static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
/*
* dp_rx_defrag_cleanup(): Clean up activities
* @peer: Pointer to the peer
* @txrx_peer: Pointer to the peer
* @tid: Transmit Identifier
*
* Returns: None
*/
void dp_rx_defrag_cleanup(struct dp_peer *peer, unsigned tid)
void dp_rx_defrag_cleanup(struct dp_txrx_peer *txrx_peer, unsigned int tid)
{
struct dp_rx_reorder_array_elem *rx_reorder_array_elem =
peer->rx_tid[tid].array;
txrx_peer->rx_tid[tid].array;
if (rx_reorder_array_elem) {
/* Free up nbufs */
@@ -1615,22 +1629,22 @@ void dp_rx_defrag_cleanup(struct dp_peer *peer, unsigned tid)
rx_reorder_array_elem->head = NULL;
rx_reorder_array_elem->tail = NULL;
} else {
dp_info("Cleanup self peer %pK and TID %u at MAC address "QDF_MAC_ADDR_FMT,
peer, tid, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
dp_info("Cleanup self peer %pK and TID %u",
txrx_peer, tid);
}
/* Free up saved ring descriptors */
dp_rx_clear_saved_desc_info(peer, tid);
dp_rx_clear_saved_desc_info(txrx_peer, tid);
peer->rx_tid[tid].defrag_timeout_ms = 0;
peer->rx_tid[tid].curr_frag_num = 0;
peer->rx_tid[tid].curr_seq_num = 0;
txrx_peer->rx_tid[tid].defrag_timeout_ms = 0;
txrx_peer->rx_tid[tid].curr_frag_num = 0;
txrx_peer->rx_tid[tid].curr_seq_num = 0;
}
/*
* dp_rx_defrag_save_info_from_ring_desc(): Save info from REO ring descriptor
* @ring_desc: Pointer to the dst ring descriptor
* @peer: Pointer to the peer
* @txrx_peer: Pointer to the peer
* @tid: Transmit Identifier
*
* Returns: None
@@ -1638,7 +1652,7 @@ void dp_rx_defrag_cleanup(struct dp_peer *peer, unsigned tid)
static QDF_STATUS
dp_rx_defrag_save_info_from_ring_desc(hal_ring_desc_t ring_desc,
struct dp_rx_desc *rx_desc,
struct dp_peer *peer,
struct dp_txrx_peer *txrx_peer,
unsigned int tid)
{
void *dst_ring_desc = qdf_mem_malloc(
@@ -1654,8 +1668,8 @@ dp_rx_defrag_save_info_from_ring_desc(hal_ring_desc_t ring_desc,
qdf_mem_copy(dst_ring_desc, ring_desc,
sizeof(struct reo_destination_ring));
peer->rx_tid[tid].dst_ring_desc = dst_ring_desc;
peer->rx_tid[tid].head_frag_desc = rx_desc;
txrx_peer->rx_tid[tid].dst_ring_desc = dst_ring_desc;
txrx_peer->rx_tid[tid].head_frag_desc = rx_desc;
return QDF_STATUS_SUCCESS;
}
@@ -1682,12 +1696,13 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
{
struct dp_rx_reorder_array_elem *rx_reorder_array_elem;
struct dp_pdev *pdev;
struct dp_peer *peer = NULL;
struct dp_txrx_peer *txrx_peer = NULL;
dp_txrx_ref_handle txrx_ref_handle;
uint16_t peer_id;
uint8_t fragno, more_frag, all_frag_present = 0;
uint16_t rxseq = mpdu_desc_info->mpdu_seq;
QDF_STATUS status;
struct dp_rx_tid *rx_tid;
struct dp_rx_tid_defrag *rx_tid;
uint8_t mpdu_sequence_control_valid;
uint8_t mpdu_frame_control_valid;
qdf_nbuf_t frag = rx_desc->nbuf;
@@ -1716,9 +1731,10 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
/* Check if the packet is from a valid peer */
peer_id = dp_rx_peer_metadata_peer_id_get(soc,
mpdu_desc_info->peer_meta_data);
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
txrx_peer = dp_txrx_peer_get_ref_by_id(soc, peer_id, &txrx_ref_handle,
DP_MOD_ID_RX_ERR);
if (!peer) {
if (!txrx_peer) {
/* We should not receive anything from unknown peer
* however, that might happen while we are in the monitor mode.
* We don't need to handle that here
@@ -1769,15 +1785,15 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
*/
fragno = dp_rx_frag_get_mpdu_frag_number(soc, rx_desc->rx_buf_start);
pdev = peer->vdev->pdev;
rx_tid = &peer->rx_tid[tid];
pdev = txrx_peer->vdev->pdev;
rx_tid = &txrx_peer->rx_tid[tid];
qdf_spin_lock_bh(&rx_tid->tid_lock);
rx_reorder_array_elem = peer->rx_tid[tid].array;
qdf_spin_lock_bh(&rx_tid->defrag_tid_lock);
rx_reorder_array_elem = txrx_peer->rx_tid[tid].array;
if (!rx_reorder_array_elem) {
dp_err_rl("Rcvd Fragmented pkt before tid setup for peer %pK",
peer);
qdf_spin_unlock_bh(&rx_tid->tid_lock);
txrx_peer);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
goto discard_frag;
}
@@ -1795,7 +1811,7 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"Rcvd unfragmented pkt on REO Err srng, dropping");
qdf_spin_unlock_bh(&rx_tid->tid_lock);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
qdf_assert(0);
goto discard_frag;
}
@@ -1811,7 +1827,7 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
/* Drop stored fragments if out of sequence
* fragment is received
*/
dp_rx_reorder_flush_frag(peer, tid);
dp_rx_reorder_flush_frag(txrx_peer, tid);
DP_STATS_INC(soc, rx.rx_frag_oor, 1);
@@ -1827,12 +1843,12 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
* not first fragment discard fragment.
*/
if (fragno) {
qdf_spin_unlock_bh(&rx_tid->tid_lock);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
goto discard_frag;
}
dp_debug("cur rxseq %d\n", rxseq);
/* Start of a new sequence */
dp_rx_defrag_cleanup(peer, tid);
dp_rx_defrag_cleanup(txrx_peer, tid);
rx_tid->curr_seq_num = rxseq;
/* store PN number also */
}
@@ -1841,9 +1857,10 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
* If the earlier sequence was dropped, this will be the fresh start.
* Else, continue with next fragment in a given sequence
*/
status = dp_rx_defrag_fraglist_insert(peer, tid, &rx_reorder_array_elem->head,
&rx_reorder_array_elem->tail, frag,
&all_frag_present);
status = dp_rx_defrag_fraglist_insert(txrx_peer, tid,
&rx_reorder_array_elem->head,
&rx_reorder_array_elem->tail,
frag, &all_frag_present);
/*
* Currently, we can have only 6 MSDUs per-MPDU, if the current
@@ -1856,12 +1873,12 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
(rx_reorder_array_elem->head == frag)) {
status = dp_rx_defrag_save_info_from_ring_desc(ring_desc,
rx_desc, peer, tid);
rx_desc, txrx_peer, tid);
if (status != QDF_STATUS_SUCCESS) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: Unable to store ring desc !", __func__);
qdf_spin_unlock_bh(&rx_tid->tid_lock);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
goto discard_frag;
}
} else {
@@ -1878,19 +1895,19 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
}
if (pdev->soc->rx.flags.defrag_timeout_check)
dp_rx_defrag_waitlist_remove(peer, tid);
dp_rx_defrag_waitlist_remove(txrx_peer, tid);
/* Yet to receive more fragments for this sequence number */
if (!all_frag_present) {
uint32_t now_ms =
qdf_system_ticks_to_msecs(qdf_system_ticks());
peer->rx_tid[tid].defrag_timeout_ms =
txrx_peer->rx_tid[tid].defrag_timeout_ms =
now_ms + pdev->soc->rx.defrag.timeout_ms;
dp_rx_defrag_waitlist_add(peer, tid);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
qdf_spin_unlock_bh(&rx_tid->tid_lock);
dp_rx_defrag_waitlist_add(txrx_peer, tid);
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
return QDF_STATUS_SUCCESS;
}
@@ -1899,31 +1916,31 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
"All fragments received for sequence: %d", rxseq);
/* Process the fragments */
status = dp_rx_defrag(peer, tid, rx_reorder_array_elem->head,
rx_reorder_array_elem->tail);
status = dp_rx_defrag(txrx_peer, tid, rx_reorder_array_elem->head,
rx_reorder_array_elem->tail);
if (QDF_IS_STATUS_ERROR(status)) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"Fragment processing failed");
dp_rx_add_to_free_desc_list(head, tail,
peer->rx_tid[tid].head_frag_desc);
txrx_peer->rx_tid[tid].head_frag_desc);
(*rx_bfs)++;
if (dp_rx_link_desc_return(soc,
peer->rx_tid[tid].dst_ring_desc,
txrx_peer->rx_tid[tid].dst_ring_desc,
HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
QDF_STATUS_SUCCESS)
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: Failed to return link desc",
__func__);
dp_rx_defrag_cleanup(peer, tid);
qdf_spin_unlock_bh(&rx_tid->tid_lock);
dp_rx_defrag_cleanup(txrx_peer, tid);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
goto end;
}
/* Re-inject the fragments back to REO for further processing */
status = dp_rx_defrag_reo_reinject(peer, tid,
rx_reorder_array_elem->head);
status = dp_rx_defrag_reo_reinject(txrx_peer, tid,
rx_reorder_array_elem->head);
if (QDF_IS_STATUS_SUCCESS(status)) {
rx_reorder_array_elem->head = NULL;
rx_reorder_array_elem->tail = NULL;
@@ -1932,13 +1949,13 @@ dp_rx_defrag_store_fragment(struct dp_soc *soc,
} else {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"Fragmented sequence reinjection failed");
dp_rx_return_head_frag_desc(peer, tid);
dp_rx_return_head_frag_desc(txrx_peer, tid);
}
dp_rx_defrag_cleanup(peer, tid);
qdf_spin_unlock_bh(&rx_tid->tid_lock);
dp_rx_defrag_cleanup(txrx_peer, tid);
qdf_spin_unlock_bh(&rx_tid->defrag_tid_lock);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
return QDF_STATUS_SUCCESS;
@@ -1954,8 +1971,8 @@ err_free_desc:
(*rx_bfs)++;
end:
if (peer)
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
if (txrx_peer)
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
DP_STATS_INC(soc, rx.rx_frag_err, 1);
return QDF_STATUS_E_DEFRAG_ERROR;
@@ -2054,16 +2071,17 @@ uint32_t dp_rx_frag_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
}
QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
struct dp_peer *peer, uint16_t tid,
struct dp_txrx_peer *txrx_peer,
uint16_t tid,
uint16_t rxseq, qdf_nbuf_t nbuf)
{
struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
struct dp_rx_tid_defrag *rx_tid = &txrx_peer->rx_tid[tid];
struct dp_rx_reorder_array_elem *rx_reorder_array_elem;
uint8_t all_frag_present;
uint32_t msdu_len;
QDF_STATUS status;
rx_reorder_array_elem = peer->rx_tid[tid].array;
rx_reorder_array_elem = txrx_peer->rx_tid[tid].array;
/*
* HW may fill in unexpected peer_id in RX PKT TLV,
@@ -2073,9 +2091,8 @@ QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
*/
if (!rx_reorder_array_elem) {
dp_verbose_debug(
"peer id:%d mac: "QDF_MAC_ADDR_FMT" drop rx frame!",
peer->peer_id,
QDF_MAC_ADDR_REF(peer->mac_addr.raw));
"peer id:%d drop rx frame!",
txrx_peer->peer_id);
DP_STATS_INC(soc, rx.err.defrag_peer_uninit, 1);
dp_rx_nbuf_free(nbuf);
goto fail;
@@ -2086,7 +2103,7 @@ QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
/* Drop stored fragments if out of sequence
* fragment is received
*/
dp_rx_reorder_flush_frag(peer, tid);
dp_rx_reorder_flush_frag(txrx_peer, tid);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: No list found for TID %d Seq# %d",
@@ -2100,7 +2117,7 @@ QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
qdf_nbuf_set_pktlen(nbuf, (msdu_len + soc->rx_pkt_tlv_size));
status = dp_rx_defrag_fraglist_insert(peer, tid,
status = dp_rx_defrag_fraglist_insert(txrx_peer, tid,
&rx_reorder_array_elem->head,
&rx_reorder_array_elem->tail, nbuf,
&all_frag_present);
@@ -2113,35 +2130,35 @@ QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
}
if (soc->rx.flags.defrag_timeout_check)
dp_rx_defrag_waitlist_remove(peer, tid);
dp_rx_defrag_waitlist_remove(txrx_peer, tid);
if (!all_frag_present) {
uint32_t now_ms =
qdf_system_ticks_to_msecs(qdf_system_ticks());
peer->rx_tid[tid].defrag_timeout_ms =
txrx_peer->rx_tid[tid].defrag_timeout_ms =
now_ms + soc->rx.defrag.timeout_ms;
dp_rx_defrag_waitlist_add(peer, tid);
dp_rx_defrag_waitlist_add(txrx_peer, tid);
return QDF_STATUS_SUCCESS;
}
status = dp_rx_defrag(peer, tid, rx_reorder_array_elem->head,
status = dp_rx_defrag(txrx_peer, tid, rx_reorder_array_elem->head,
rx_reorder_array_elem->tail);
if (QDF_IS_STATUS_ERROR(status)) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s Fragment processing failed", __func__);
dp_rx_return_head_frag_desc(peer, tid);
dp_rx_defrag_cleanup(peer, tid);
dp_rx_return_head_frag_desc(txrx_peer, tid);
dp_rx_defrag_cleanup(txrx_peer, tid);
goto fail;
}
/* Re-inject the fragments back to REO for further processing */
status = dp_rx_defrag_reo_reinject(peer, tid,
status = dp_rx_defrag_reo_reinject(txrx_peer, tid,
rx_reorder_array_elem->head);
if (QDF_IS_STATUS_SUCCESS(status)) {
rx_reorder_array_elem->head = NULL;
@@ -2152,10 +2169,10 @@ QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
} else {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: Frag seq reinjection failed", __func__);
dp_rx_return_head_frag_desc(peer, tid);
dp_rx_return_head_frag_desc(txrx_peer, tid);
}
dp_rx_defrag_cleanup(peer, tid);
dp_rx_defrag_cleanup(txrx_peer, tid);
return QDF_STATUS_SUCCESS;
fail:

13
dp/wifi3.0/dp_rx_defrag.h
View File

@@ -1,5 +1,6 @@
/*
* Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@@ -133,12 +134,12 @@ uint8_t dp_rx_get_pkt_dir(struct dp_soc *soc, uint8_t *rx_desc_info)
}
void dp_rx_defrag_waitlist_flush(struct dp_soc *soc);
void dp_rx_reorder_flush_frag(struct dp_peer *peer,
unsigned int tid);
void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid);
void dp_rx_defrag_cleanup(struct dp_peer *peer, unsigned tid);
void dp_rx_reorder_flush_frag(struct dp_txrx_peer *txrx_peer,
unsigned int tid);
void dp_rx_defrag_waitlist_remove(struct dp_txrx_peer *peer, unsigned int tid);
void dp_rx_defrag_cleanup(struct dp_txrx_peer *peer, unsigned int tid);
QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
struct dp_peer *peer, uint16_t tid,
uint16_t rxseq, qdf_nbuf_t nbuf);
struct dp_txrx_peer *peer, uint16_t tid,
uint16_t rxseq, qdf_nbuf_t nbuf);
#endif /* _DP_RX_DEFRAG_H */

178
dp/wifi3.0/dp_rx_err.c
View File

@@ -60,11 +60,11 @@
#ifdef FEATURE_MEC
bool dp_rx_mcast_echo_check(struct dp_soc *soc,
struct dp_peer *peer,
struct dp_txrx_peer *txrx_peer,
uint8_t *rx_tlv_hdr,
qdf_nbuf_t nbuf)
{
struct dp_vdev *vdev = peer->vdev;
struct dp_vdev *vdev = txrx_peer->vdev;
struct dp_pdev *pdev = vdev->pdev;
struct dp_mec_entry *mecentry = NULL;
struct dp_ast_entry *ase = NULL;
@@ -128,7 +128,7 @@ bool dp_rx_mcast_echo_check(struct dp_soc *soc,
* On receiving in 2G STA vap, we assume that client has roamed
* and kickout the client.
*/
if (ase && (ase->peer_id != peer->peer_id)) {
if (ase && (ase->peer_id != txrx_peer->peer_id)) {
qdf_spin_unlock_bh(&soc->ast_lock);
goto drop;
}
@@ -442,24 +442,27 @@ dp_rx_pn_error_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
{
uint16_t peer_id;
uint32_t rx_bufs_used = 0;
struct dp_peer *peer;
struct dp_txrx_peer *txrx_peer;
bool peer_pn_policy = false;
dp_txrx_ref_handle txrx_ref_handle;
peer_id = dp_rx_peer_metadata_peer_id_get(soc,
mpdu_desc_info->peer_meta_data);
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
&txrx_ref_handle,
DP_MOD_ID_RX_ERR);
if (qdf_likely(peer)) {
if (qdf_likely(txrx_peer)) {
/*
* TODO: Check for peer specific policies & set peer_pn_policy
*/
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"discard rx due to PN error for peer %pK "QDF_MAC_ADDR_FMT,
peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
"discard rx due to PN error for peer %pK",
txrx_peer);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
}
dp_rx_err_err("%pK: Packet received with PN error", soc);
@@ -493,24 +496,27 @@ dp_rx_oor_handle(struct dp_soc *soc,
{
uint32_t frame_mask = FRAME_MASK_IPV4_ARP | FRAME_MASK_IPV4_DHCP |
FRAME_MASK_IPV4_EAPOL | FRAME_MASK_IPV6_DHCP;
struct dp_peer *peer = NULL;
struct dp_txrx_peer *txrx_peer = NULL;
dp_txrx_ref_handle txrx_ref_handle;
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
if (!peer) {
txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
&txrx_ref_handle,
DP_MOD_ID_RX_ERR);
if (!txrx_peer) {
dp_info_rl("peer not found");
goto free_nbuf;
}
if (dp_rx_deliver_special_frame(soc, peer, nbuf, frame_mask,
if (dp_rx_deliver_special_frame(soc, txrx_peer, nbuf, frame_mask,
rx_tlv_hdr)) {
DP_STATS_INC(soc, rx.err.reo_err_oor_to_stack, 1);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
return;
}
free_nbuf:
if (peer)
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
if (txrx_peer)
dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
DP_STATS_INC(soc, rx.err.reo_err_oor_drop, 1);
dp_rx_nbuf_free(nbuf);
@@ -629,12 +635,11 @@ _dp_rx_bar_frame_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
if (!peer)
return;
dp_info("BAR frame: peer = " QDF_MAC_ADDR_FMT
dp_info("BAR frame: "
" peer_id = %d"
" tid = %u"
" SSN = %d"
" error status = %d",
QDF_MAC_ADDR_REF(peer->mac_addr.raw),
peer->peer_id,
tid,
mpdu_desc_info->mpdu_seq,
@@ -1074,7 +1079,7 @@ dp_2k_jump_handle(struct dp_soc *soc,
}
nbuf_deliver:
if (dp_rx_deliver_special_frame(soc, peer, nbuf, frame_mask,
if (dp_rx_deliver_special_frame(soc, peer->txrx_peer, nbuf, frame_mask,
rx_tlv_hdr)) {
DP_STATS_INC(soc, rx.err.rx_2k_jump_to_stack, 1);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
@@ -1184,7 +1189,7 @@ bool dp_rx_check_pkt_len(struct dp_soc *soc, uint32_t pkt_len)
* dp_rx_deliver_to_osif_stack() - function to deliver rx pkts to stack
* @soc: DP soc
* @vdv: DP vdev handle
* @peer: pointer to the peer object
* @txrx_peer: pointer to the txrx_peer object
* @nbuf: skb list head
* @tail: skb list tail
* @is_eapol: eapol pkt check
@@ -1195,26 +1200,26 @@ bool dp_rx_check_pkt_len(struct dp_soc *soc, uint32_t pkt_len)
static inline void
dp_rx_deliver_to_osif_stack(struct dp_soc *soc,
struct dp_vdev *vdev,
struct dp_peer *peer,
struct dp_txrx_peer *txrx_peer,
qdf_nbuf_t nbuf,
qdf_nbuf_t tail,
bool is_eapol)
{
if (is_eapol && soc->eapol_over_control_port)
dp_rx_eapol_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
dp_rx_eapol_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
else
dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
dp_rx_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
}
#else
static inline void
dp_rx_deliver_to_osif_stack(struct dp_soc *soc,
struct dp_vdev *vdev,
struct dp_peer *peer,
struct dp_txrx_peer *txrx_peer,
qdf_nbuf_t nbuf,
qdf_nbuf_t tail,
bool is_eapol)
{
dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
dp_rx_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
}
#endif
@@ -1254,7 +1259,7 @@ int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev)
* @nbuf: buffer pointer
* @rx_tlv_hdr: start of rx tlv header
* @pool_id: mac id
* @peer: peer handle
* @txrx_peer: txrx peer handle
*
* This function handles NULL queue descriptor violations arising out
* a missing REO queue for a given peer or a given TID. This typically
@@ -1270,7 +1275,7 @@ int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev)
static QDF_STATUS
dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
uint8_t *rx_tlv_hdr, uint8_t pool_id,
struct dp_peer *peer)
struct dp_txrx_peer *txrx_peer)
{
uint32_t pkt_len;
uint16_t msdu_len;
@@ -1323,12 +1328,12 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
qdf_assert(0);
}
if (!peer &&
if (!txrx_peer &&
dp_rx_null_q_handle_invalid_peer_id_exception(soc, pool_id,
rx_tlv_hdr, nbuf))
return QDF_STATUS_E_FAILURE;
if (!peer) {
if (!txrx_peer) {
bool mpdu_done = false;
struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
@@ -1337,7 +1342,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
return QDF_STATUS_E_FAILURE;
}
dp_err_rl("peer is NULL");
dp_err_rl("txrx_peer is NULL");
DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
qdf_nbuf_len(nbuf));
@@ -1364,7 +1369,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
return QDF_STATUS_E_FAILURE;
}
vdev = peer->vdev;
vdev = txrx_peer->vdev;
if (!vdev) {
dp_err_rl("Null vdev!");
DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
@@ -1396,7 +1401,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
}
if ((!soc->mec_fw_offload) &&
dp_rx_mcast_echo_check(soc, peer, rx_tlv_hdr, nbuf)) {
dp_rx_mcast_echo_check(soc, txrx_peer, rx_tlv_hdr, nbuf)) {
/* this is a looped back MCBC pkt, drop it */
DP_STATS_INC_PKT(peer, rx.mec_drop, 1,
qdf_nbuf_len(nbuf));
@@ -1414,15 +1419,15 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
}
if (qdf_unlikely((peer->nawds_enabled == true) &&
hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
rx_tlv_hdr))) {
if (qdf_unlikely(txrx_peer->nawds_enabled &&
hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
rx_tlv_hdr))) {
dp_err_rl("free buffer for multicast packet");
DP_STATS_INC(peer, rx.nawds_mcast_drop, 1);
goto drop_nbuf;
}
if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, txrx_peer)) {
dp_err_rl("mcast Policy Check Drop pkt");
DP_STATS_INC(peer, rx.policy_check_drop, 1);
goto drop_nbuf;
@@ -1430,20 +1435,26 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
/* WDS Source Port Learning */
if (!soc->ast_offload_support &&
qdf_likely(vdev->rx_decap_type == htt_cmn_pkt_type_ethernet &&
vdev->wds_enabled))
dp_rx_wds_srcport_learn(soc, rx_tlv_hdr, peer, nbuf,
vdev->wds_enabled))
dp_rx_wds_srcport_learn(soc, rx_tlv_hdr, txrx_peer, nbuf,
msdu_metadata);
if (hal_rx_is_unicast(soc->hal_soc, rx_tlv_hdr)) {
tid = hal_rx_tid_get(soc->hal_soc, rx_tlv_hdr);
if (!peer->rx_tid[tid].hw_qdesc_vaddr_unaligned)
dp_rx_tid_setup_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX);
peer = dp_peer_get_ref_by_id(soc, txrx_peer->peer_id,
DP_MOD_ID_RX_ERR);
if (peer) {
if (!peer->rx_tid[tid].hw_qdesc_vaddr_unaligned)
dp_rx_tid_setup_wifi3(peer, tid, 1,
IEEE80211_SEQ_MAX);
/* IEEE80211_SEQ_MAX indicates invalid start_seq */
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
}
}
eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
if (!peer->authorize) {
if (!txrx_peer->authorize) {
is_eapol = qdf_nbuf_is_ipv4_eapol_pkt(nbuf) ||
qdf_nbuf_is_ipv4_wapi_pkt(nbuf);
@@ -1473,7 +1484,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
qdf_nbuf_set_next(nbuf, NULL);
dp_rx_deliver_raw(vdev, nbuf, peer);
dp_rx_deliver_raw(vdev, nbuf, txrx_peer);
} else {
enh_flag = vdev->pdev->enhanced_stats_en;
qdf_nbuf_set_next(nbuf, NULL);
@@ -1504,7 +1515,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
}
qdf_nbuf_set_exc_frame(nbuf, 1);
dp_rx_deliver_to_osif_stack(soc, vdev, peer, nbuf, NULL,
dp_rx_deliver_to_osif_stack(soc, vdev, txrx_peer, nbuf, NULL,
is_eapol);
}
return QDF_STATUS_SUCCESS;
@@ -1522,7 +1533,7 @@ drop_nbuf:
* @soc: core DP main context
* @nbuf: buffer pointer
* @rx_tlv_hdr: start of rx tlv header
* @peer: peer reference
* @txrx_peer: peer reference
* @err_code: rxdma err code
* @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
* pool_id has same mapping)
@@ -1531,7 +1542,7 @@ drop_nbuf:
*/
void
dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
uint8_t *rx_tlv_hdr, struct dp_peer *peer,
uint8_t *rx_tlv_hdr, struct dp_txrx_peer *txrx_peer,
uint8_t err_code, uint8_t mac_id)
{
uint32_t pkt_len, l2_hdr_offset;
@@ -1571,8 +1582,8 @@ dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
if (!peer) {
QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, "peer is NULL");
if (!txrx_peer) {
QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, "txrx_peer is NULL");
DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
qdf_nbuf_len(nbuf));
/* Trigger invalid peer handler wrapper */
@@ -1580,7 +1591,7 @@ dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
return;
}
vdev = peer->vdev;
vdev = txrx_peer->vdev;
if (!vdev) {
dp_rx_err_info_rl("%pK: INVALID vdev %pK OR osif_rx", soc,
vdev);
@@ -1666,7 +1677,7 @@ process_rx:
}
if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
dp_rx_deliver_raw(vdev, nbuf, peer);
dp_rx_deliver_raw(vdev, nbuf, txrx_peer);
} else {
/* Update the protocol tag in SKB based on CCE metadata */
dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
@@ -1675,7 +1686,7 @@ process_rx:
dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr, true);
DP_STATS_INC(peer, rx.to_stack.num, 1);
qdf_nbuf_set_exc_frame(nbuf, 1);
dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
dp_rx_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
}
return;
@@ -1686,12 +1697,13 @@ process_rx:
* @soc: core DP main context
* @nbuf: buffer pointer
* @rx_tlv_hdr: start of rx tlv header
* @peer: peer handle
* @txrx_peer: txrx peer handle
*
* return: void
*/
void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
uint8_t *rx_tlv_hdr, struct dp_peer *peer)
uint8_t *rx_tlv_hdr,
struct dp_txrx_peer *txrx_peer)
{
struct dp_vdev *vdev = NULL;
struct dp_pdev *pdev = NULL;
@@ -1706,12 +1718,12 @@ void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
rx_tlv_hdr))
return;
if (!peer) {
dp_info_rl("peer not found");
if (!txrx_peer) {
dp_info_rl("txrx_peer not found");
goto fail;
}
vdev = peer->vdev;
vdev = txrx_peer->vdev;
if (!vdev) {
dp_info_rl("VDEV not found");
goto fail;
@@ -1734,7 +1746,7 @@ void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
rx_seq = hal_rx_get_rx_sequence(soc->hal_soc,
qdf_nbuf_data(nbuf));
status = dp_rx_defrag_add_last_frag(soc, peer,
status = dp_rx_defrag_add_last_frag(soc, txrx_peer,
tid, rx_seq, nbuf);
dp_info_rl("Frag pkt seq# %d frag# %d consumed "
"status %d !", rx_seq, fragno, status);
@@ -1772,7 +1784,6 @@ fail:
return;
}
#if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) && \
defined(WLAN_MCAST_MLO)
static bool dp_rx_igmp_handler(struct dp_soc *soc,
@@ -1803,7 +1814,7 @@ static bool dp_rx_igmp_handler(struct dp_soc *soc,
*
* @soc: core DP main context
* @nbuf: buffer pointer
* @peer: peer handle
* @txrx_peer: txrx peer handle
* @rx_tlv_hdr: start of rx tlv header
* @err_src: rxdma/reo
*
@@ -1814,7 +1825,7 @@ static bool dp_rx_igmp_handler(struct dp_soc *soc,
*/
static void
dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
struct dp_peer *peer, uint8_t *rx_tlv_hdr,
struct dp_txrx_peer *txrx_peer, uint8_t *rx_tlv_hdr,
enum hal_rx_wbm_error_source err_src)
{
uint32_t pkt_len;
@@ -1848,10 +1859,10 @@ dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
qdf_assert(0);
}
if (!peer)
if (!txrx_peer)
goto drop_nbuf;
vdev = peer->vdev;
vdev = txrx_peer->vdev;
if (!vdev) {
dp_err_rl("Null vdev!");
DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
@@ -1900,7 +1911,7 @@ dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
qdf_nbuf_set_exc_frame(nbuf, 1);
qdf_nbuf_set_next(nbuf, NULL);
dp_rx_deliver_to_osif_stack(soc, vdev, peer, nbuf,
dp_rx_deliver_to_osif_stack(soc, vdev, txrx_peer, nbuf,
NULL, is_eapol);
return;
@@ -2665,11 +2676,13 @@ done:
nbuf = nbuf_head;
while (nbuf) {
struct dp_txrx_peer *txrx_peer;
struct dp_peer *peer;
uint16_t peer_id;
uint8_t err_code;
uint8_t *tlv_hdr;
uint32_t peer_meta_data;
dp_txrx_ref_handle txrx_ref_handle;
rx_tlv_hdr = qdf_nbuf_data(nbuf);
/*
@@ -2683,9 +2696,11 @@ done:
peer_meta_data = hal_rx_mpdu_peer_meta_data_get(soc->hal_soc,
rx_tlv_hdr);
peer_id = dp_rx_peer_metadata_peer_id_get(soc, peer_meta_data);
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
&txrx_ref_handle,
DP_MOD_ID_RX_ERR);
if (!peer)
if (!txrx_peer)
dp_info_rl("peer is null peer_id%u err_src%u err_rsn%u",
peer_id, wbm_err_info.wbm_err_src,
wbm_err_info.reo_psh_rsn);
@@ -2709,8 +2724,9 @@ done:
dp_rx_nbuf_free(nbuf);
dp_info_rl("scattered msdu dropped");
nbuf = next;
if (peer)
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
if (txrx_peer)
dp_txrx_peer_unref_delete(txrx_ref_handle,
DP_MOD_ID_RX_ERR);
continue;
}
@@ -2737,7 +2753,8 @@ done:
pool_id = wbm_err_info.pool_id;
dp_rx_null_q_desc_handle(soc, nbuf,
rx_tlv_hdr,
pool_id, peer);
pool_id,
txrx_peer);
break;
/* TODO */
/* Add per error code accounting */
@@ -2763,7 +2780,7 @@ done:
peer_id, tid);
break;
case HAL_REO_ERR_REGULAR_FRAME_OOR:
if (peer)
if (txrx_peer)
DP_STATS_INC(peer,
rx.err.oor_err, 1);
if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
@@ -2781,10 +2798,12 @@ done:
break;
case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
case HAL_REO_ERR_BAR_FRAME_OOR:
if (peer)
dp_rx_err_handle_bar(soc,
peer,
peer = dp_peer_get_tgt_peer_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
if (peer) {
dp_rx_err_handle_bar(soc, peer,
nbuf);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
}
dp_rx_nbuf_free(nbuf);
break;
@@ -2803,7 +2822,7 @@ done:
}
} else if (wbm_err_info.reo_psh_rsn
== HAL_RX_WBM_REO_PSH_RSN_ROUTE) {
dp_rx_err_route_hdl(soc, nbuf, peer,
dp_rx_err_route_hdl(soc, nbuf, txrx_peer,
rx_tlv_hdr,
HAL_RX_WBM_ERR_SRC_REO);
} else {
@@ -2839,7 +2858,7 @@ done:
pool_id = wbm_err_info.pool_id;
dp_rx_process_rxdma_err(soc, nbuf,
rx_tlv_hdr,
peer,
txrx_peer,
wbm_err_info.
rxdma_err_code,
pool_id);
@@ -2848,14 +2867,14 @@ done:
case HAL_RXDMA_ERR_TKIP_MIC:
dp_rx_process_mic_error(soc, nbuf,
rx_tlv_hdr,
peer);
if (peer)
txrx_peer);
if (txrx_peer)
DP_STATS_INC(peer, rx.err.mic_err, 1);
break;
case HAL_RXDMA_ERR_DECRYPT:
if (peer) {
if (txrx_peer) {
DP_STATS_INC(peer, rx.err.
decrypt_err, 1);
dp_rx_nbuf_free(nbuf);
@@ -2896,7 +2915,7 @@ done:
}
} else if (wbm_err_info.rxdma_psh_rsn
== HAL_RX_WBM_RXDMA_PSH_RSN_ROUTE) {
dp_rx_err_route_hdl(soc, nbuf, peer,
dp_rx_err_route_hdl(soc, nbuf, txrx_peer,
rx_tlv_hdr,
HAL_RX_WBM_ERR_SRC_RXDMA);
} else if (wbm_err_info.rxdma_psh_rsn
@@ -2917,8 +2936,9 @@ done:
qdf_assert(0);
}
if (peer)
dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
if (txrx_peer)
dp_txrx_peer_unref_delete(txrx_ref_handle,
DP_MOD_ID_RX_ERR);
nbuf = next;
}