A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-15 01:01:56 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacld-3.0: Remove unnecessary prints from data path

Browse source 
1. Remove error prints for qdf_mem_malloc APIs.
2. Remove unnecessary __func__ from data path prints.

Change-Id: I6c4b110f626d84da055821c5f210a3d000b6ff15
CRs-Fixed: 2317315
This commit is contained in:
Nirav Shah 2018-09-10 16:01:31 +05:30 • committed by nshrivas
commit 7c8c171e05
26 changed files with 193 additions and 330 deletions
Download patch file Download diff file Expand all files Collapse all files

7
core/dp/htt/htt.c
View file

@ -72,10 +72,9 @@ struct htt_htc_pkt *htt_htc_pkt_alloc(struct htt_pdev_t *pdev)
if (pkt == NULL)
pkt = qdf_mem_malloc(sizeof(*pkt));
if (!pkt) {
qdf_print("%s: HTC packet allocation failed\n", __func__);
if (!pkt)
return NULL;
}
htc_packet_set_magic_cookie(&(pkt->u.pkt.htc_pkt), 0);
return &pkt->u.pkt; /* not actually a dereference */
}
@ -85,7 +84,7 @@ void htt_htc_pkt_free(struct htt_pdev_t *pdev, struct htt_htc_pkt *pkt)
struct htt_htc_pkt_union *u_pkt = (struct htt_htc_pkt_union *)pkt;
if (!u_pkt) {
qdf_print("%s: HTC packet is NULL\n", __func__);
qdf_print("HTC packet is NULL");
return;
}

4
core/dp/htt/htt_internal.h
View file

@ -968,8 +968,8 @@ htt_rx_paddr_unmark_high_bits(qdf_dma_addr_t paddr)
* padded (with 0b0) to 8 bits
*/
if ((markings & 0xFFFF0000) != RX_PADDR_MAGIC_PATTERN) {
qdf_print("%s: paddr not marked correctly: 0x%pK!\n",
__func__, (void *)paddr);
qdf_print("paddr not marked correctly: 0x%pK!\n",
(void *)paddr);
HTT_ASSERT_ALWAYS(0);
}

15
core/dp/htt/htt_monitor_rx.c
View file

@ -97,7 +97,7 @@ int htt_mon_rx_handle_amsdu_packet(qdf_nbuf_t msdu, htt_pdev_handle pdev,
paddr = htt_rx_in_ord_paddr_get(*msg_word);
frag_nbuf = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!frag_nbuf)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
return 0;
}
*frag_cnt = *frag_cnt + 1;
@ -124,7 +124,7 @@ int htt_mon_rx_handle_amsdu_packet(qdf_nbuf_t msdu, htt_pdev_handle pdev,
*msg_word)->msdu_info;
if (qdf_unlikely(!frag_nbuf)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
prev_frag_nbuf->next = NULL;
return 0;
}
@ -548,7 +548,7 @@ int htt_rx_mon_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
msdu = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!msdu)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
return 0;
}
@ -581,8 +581,7 @@ int htt_rx_mon_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
htt_rx_in_ord_paddr_ind_msdu_t *)
msg_word)->msdu_info;
if (qdf_unlikely(!msdu)) {
qdf_print("%s: netbuf pop failed!\n",
__func__);
qdf_print("netbuf pop failed!");
return 0;
}
*replenish_cnt = *replenish_cnt + 1;
@ -698,8 +697,7 @@ int htt_rx_mon_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
&msg_word,
amsdu_len,
replenish_cnt)) {
qdf_print("%s: failed to handle amsdu packet\n",
__func__);
qdf_print("failed to handle amsdu packet");
return 0;
}
}
@ -711,8 +709,7 @@ next_pop:
paddr = htt_rx_in_ord_paddr_get(msg_word);
next = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!next)) {
qdf_print("%s: netbuf pop failed!\n",
__func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
return 0;
}

10
core/dp/htt/htt_rx.c
View file

@ -396,10 +396,7 @@ void htt_register_rx_pkt_dump_callback(struct htt_pdev_t *pdev,
tp_rx_pkt_dump_cb callback)
{
if (!pdev) {
qdf_print("%s: %s, %s",
__func__,
"htt pdev is NULL",
"rx packet status callback register unsuccessful\n");
qdf_print("pdev is NULL");
return;
}
pdev->rx_pkt_dump_cb = callback;
@ -420,10 +417,7 @@ void htt_register_rx_pkt_dump_callback(struct htt_pdev_t *pdev,
void htt_deregister_rx_pkt_dump_callback(struct htt_pdev_t *pdev)
{
if (!pdev) {
qdf_print("%s: %s, %s",
__func__,
"htt pdev is NULL",
"rx packet status callback deregister unsuccessful\n");
qdf_print("pdev is NULL");
return;
}
pdev->rx_pkt_dump_cb = NULL;

31
core/dp/htt/htt_rx_ll.c
View file

@ -922,7 +922,7 @@ htt_rx_offload_msdu_pop_ll(htt_pdev_handle pdev,
*head_buf = *tail_buf = buf = htt_rx_netbuf_pop(pdev);
if (qdf_unlikely(!buf)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
return 1;
}
@ -972,7 +972,7 @@ htt_rx_offload_paddr_msdu_pop_ll(htt_pdev_handle pdev,
*head_buf = *tail_buf = buf = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!buf)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
return 1;
}
qdf_nbuf_set_pktlen(buf, HTT_RX_BUF_SIZE);
@ -1149,8 +1149,8 @@ htt_rx_hash_list_insert(struct htt_pdev_t *pdev,
htt_list_add_tail(&pdev->rx_ring.hash_table[i]->listhead,
&hash_element->listnode);
RX_HASH_LOG(qdf_print("rx hash: %s: paddr 0x%x netbuf %pK bucket %d\n",
__func__, paddr, netbuf, (int)i));
RX_HASH_LOG(qdf_print("rx hash: paddr 0x%x netbuf %pK bucket %d\n",
paddr, netbuf, (int)i));
HTT_RX_HASH_COUNT_INCR(pdev->rx_ring.hash_table[i]);
HTT_RX_HASH_COUNT_PRINT(pdev->rx_ring.hash_table[i]);
@ -1214,15 +1214,15 @@ qdf_nbuf_t htt_rx_hash_list_lookup(struct htt_pdev_t *pdev,
}
}
RX_HASH_LOG(qdf_print("rx hash: %s: paddr 0x%x, netbuf %pK, bucket %d\n",
__func__, paddr, netbuf, (int)i));
RX_HASH_LOG(qdf_print("rx hash: paddr 0x%x, netbuf %pK, bucket %d\n",
paddr, netbuf, (int)i));
HTT_RX_HASH_COUNT_PRINT(pdev->rx_ring.hash_table[i]);
qdf_spin_unlock_bh(&pdev->rx_ring.rx_hash_lock);
if (!netbuf) {
qdf_print("rx hash: %s: no entry found for %pK!\n",
__func__, (void *)paddr);
qdf_print("rx hash: no entry found for %pK!\n",
(void *)paddr);
cds_trigger_recovery(QDF_RX_HASH_NO_ENTRY_FOUND);
}
@ -1247,10 +1247,8 @@ static int htt_rx_hash_init(struct htt_pdev_t *pdev)
qdf_mem_malloc(RX_NUM_HASH_BUCKETS *
sizeof(struct htt_rx_hash_bucket *));
if (!pdev->rx_ring.hash_table) {
qdf_print("rx hash table allocation failed!\n");
if (!pdev->rx_ring.hash_table)
return 1;
}
qdf_spinlock_create(&pdev->rx_ring.rx_hash_lock);
qdf_spin_lock_bh(&pdev->rx_ring.rx_hash_lock);
@ -1465,7 +1463,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
(*head_msdu) = msdu = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!msdu)) {
qdf_print("%s: netbuf pop failed!\n", __func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
pdev->rx_ring.pop_fail_cnt++;
ret = 0;
@ -1510,8 +1508,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
paddr = htt_rx_in_ord_paddr_get(msg_word);
next = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!next)) {
qdf_print("%s: netbuf pop failed!\n",
__func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
pdev->rx_ring.pop_fail_cnt++;
ret = 0;
@ -1606,8 +1603,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
paddr = htt_rx_in_ord_paddr_get(msg_word);
next = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!next)) {
qdf_print("%s: netbuf pop failed!\n",
__func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
pdev->rx_ring.pop_fail_cnt++;
ret = 0;
@ -1635,8 +1631,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
paddr = htt_rx_in_ord_paddr_get(msg_word);
next = htt_rx_in_order_netbuf_pop(pdev, paddr);
if (qdf_unlikely(!next)) {
qdf_print("%s: netbuf pop failed!\n",
__func__);
qdf_print("netbuf pop failed!");
*tail_msdu = NULL;
pdev->rx_ring.pop_fail_cnt++;
ret = 0;

44
core/dp/htt/htt_t2h.c
View file

@ -168,10 +168,9 @@ static void htt_ipa_op_response(struct htt_pdev_t *pdev, uint32_t *msg_word)
qdf_mem_malloc(sizeof
(struct htt_wdi_ipa_op_response_t) +
len);
if (!op_msg_buffer) {
qdf_print("OPCODE message buffer alloc fail");
if (!op_msg_buffer)
return;
}
qdf_mem_copy(op_msg_buffer,
msg_start_ptr,
sizeof(struct htt_wdi_ipa_op_response_t) +
@ -287,9 +286,7 @@ static void htt_t2h_lp_msg_handler(void *context, qdf_nbuf_t htt_t2h_msg,
sizeof(struct hl_htt_rx_ind_base)+
sizeof(struct ieee80211_frame))) {
qdf_print("%s: invalid packet len, %u\n",
__func__,
rx_pkt_len);
qdf_print("invalid packet len, %u", rx_pkt_len);
/*
* This buf will be freed before
* exiting this function.
@ -446,7 +443,7 @@ static void htt_t2h_lp_msg_handler(void *context, qdf_nbuf_t htt_t2h_msg,
uint32_t len = qdf_nbuf_len(htt_t2h_msg);
if (len < sizeof(*msg_word) + sizeof(uint32_t)) {
qdf_print("%s: invalid nbuff len \n", __func__);
qdf_print("invalid nbuff len");
WARN_ON(1);
break;
}
@ -470,11 +467,8 @@ static void htt_t2h_lp_msg_handler(void *context, qdf_nbuf_t htt_t2h_msg,
old_credit = qdf_atomic_read(&pdev->htt_tx_credit.target_delta);
if (((old_credit + htt_credit_delta) > MAX_TARGET_TX_CREDIT) ||
((old_credit + htt_credit_delta) < -MAX_TARGET_TX_CREDIT)) {
qdf_print("%s: invalid credit update,old_credit=%d,"
"htt_credit_delta=%d\n",
__func__,
old_credit,
htt_credit_delta);
qdf_err("invalid update,old_credit=%d, htt_credit_delta=%d",
old_credit, htt_credit_delta);
break;
}
@ -594,8 +588,7 @@ static void htt_t2h_lp_msg_handler(void *context, qdf_nbuf_t htt_t2h_msg,
peer = ol_txrx_peer_find_by_id(pdev->txrx_pdev,
peer_id);
if (!peer) {
qdf_print("%s: invalid peer id %d\n",
__func__, peer_id);
qdf_print("invalid peer id %d", peer_id);
qdf_assert(0);
break;
}
@ -620,9 +613,8 @@ static void htt_t2h_lp_msg_handler(void *context, qdf_nbuf_t htt_t2h_msg,
}
default:
{
qdf_print("%s: unhandled error type %d\n",
__func__,
HTT_RX_OFLD_PKT_ERR_MSG_SUB_TYPE_GET(*msg_word));
qdf_print("unhandled error type %d",
HTT_RX_OFLD_PKT_ERR_MSG_SUB_TYPE_GET(*msg_word));
break;
}
}
@ -820,11 +812,8 @@ void htt_t2h_msg_handler(void *context, HTC_PACKET *pkt)
&pdev->htt_tx_credit.target_delta);
if (((old_credit + num_msdus) > MAX_TARGET_TX_CREDIT) ||
((old_credit + num_msdus) < -MAX_TARGET_TX_CREDIT)) {
qdf_print("%s: invalid credit update,old_credit=%d,"
"num_msdus=%d\n",
__func__,
old_credit,
num_msdus);
qdf_err("invalid update,old_credit=%d, num_msdus=%d",
old_credit, num_msdus);
} else {
if (!pdev->cfg.default_tx_comp_req) {
int credit_delta;
@ -931,15 +920,12 @@ void htt_t2h_msg_handler(void *context, HTC_PACKET *pkt)
uint8_t offload_ind, frag_ind;
if (qdf_unlikely(!pdev->cfg.is_full_reorder_offload)) {
qdf_print("HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND not ");
qdf_print("supported when full reorder offload is ");
qdf_print("disabled in the configuration.\n");
qdf_print("full reorder offload is disable");
break;
}
if (qdf_unlikely(pdev->cfg.is_high_latency)) {
qdf_print("HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND ");
qdf_print("not supported on high latency.\n");
qdf_print("full reorder offload not support in HL");
break;
}
@ -949,8 +935,8 @@ void htt_t2h_msg_handler(void *context, HTC_PACKET *pkt)
frag_ind = HTT_RX_IN_ORD_PADDR_IND_FRAG_GET(*msg_word);
#if defined(HELIUMPLUS_DEBUG)
qdf_print("%s %d: peerid %d tid %d offloadind %d fragind %d\n",
__func__, __LINE__, peer_id, tid, offload_ind,
qdf_print("peerid %d tid %d offloadind %d fragind %d",
peer_id, tid, offload_ind,
frag_ind);
#endif
if (qdf_unlikely(frag_ind)) {

24
core/dp/htt/htt_tx.c
View file

@ -838,7 +838,7 @@ htt_tx_resume_handler(void *context) { }
qdf_nbuf_t
htt_tx_send_batch(htt_pdev_handle pdev, qdf_nbuf_t head_msdu, int num_msdus)
{
qdf_print("*** %s currently only applies for HL systems\n", __func__);
qdf_print("Not apply to LL");
qdf_assert(0);
return head_msdu;
@ -1072,8 +1072,7 @@ static int htt_tx_ipa_uc_wdi_tx_buf_alloc(struct htt_pdev_t *pdev,
if (qdf_mem_smmu_s1_enabled(pdev->osdev)) {
mem_map_table = qdf_mem_map_table_alloc(uc_tx_buf_cnt);
if (!mem_map_table) {
qdf_print("%s: Failed to allocate memory for mem map table\n",
__func__);
qdf_print("Failed to allocate memory");
return 0;
}
mem_info = mem_map_table;
@ -1191,8 +1190,7 @@ static void htt_tx_buf_pool_free(struct htt_pdev_t *pdev)
mem_map_table = qdf_mem_map_table_alloc(
pdev->ipa_uc_tx_rsc.alloc_tx_buf_cnt);
if (!mem_map_table) {
qdf_print("%s: Failed to allocate memory for mem map table\n",
__func__);
qdf_print("Failed to allocate memory");
return;
}
mem_info = mem_map_table;
@ -1238,8 +1236,7 @@ static int htt_tx_ipa_uc_wdi_tx_buf_alloc(struct htt_pdev_t *pdev,
if (qdf_mem_smmu_s1_enabled(pdev->osdev)) {
mem_map_table = qdf_mem_map_table_alloc(uc_tx_buf_cnt);
if (!mem_map_table) {
qdf_print("%s: Failed to allocate memory for mem map table\n",
__func__);
qdf_print("Failed to allocate memory");
return 0;
}
mem_info = mem_map_table;
@ -1251,8 +1248,8 @@ static int htt_tx_ipa_uc_wdi_tx_buf_alloc(struct htt_pdev_t *pdev,
shared_tx_buffer = qdf_mem_shared_mem_alloc(pdev->osdev,
uc_tx_buf_sz);
if (!shared_tx_buffer || !shared_tx_buffer->vaddr) {
qdf_print("%s: TX BUF alloc fail, loop index: %d",
__func__, tx_buffer_count);
qdf_print("TX BUF alloc fail, loop index: %d",
tx_buffer_count);
goto pwr2;
}
@ -1338,8 +1335,7 @@ static void htt_tx_buf_pool_free(struct htt_pdev_t *pdev)
mem_map_table = qdf_mem_map_table_alloc(
pdev->ipa_uc_tx_rsc.alloc_tx_buf_cnt);
if (!mem_map_table) {
qdf_print("%s: Failed to allocate memory for mem map table\n",
__func__);
qdf_print("Failed to allocate memory");
return;
}
mem_info = mem_map_table;
@ -1390,8 +1386,7 @@ int htt_tx_ipa_uc_attach(struct htt_pdev_t *pdev,
pdev->ipa_uc_tx_rsc.tx_ce_idx =
qdf_mem_shared_mem_alloc(pdev->osdev, 4);
if (!pdev->ipa_uc_tx_rsc.tx_ce_idx) {
qdf_print("%s: Unable to allocate memory for IPA tx ce idx\n",
__func__);
qdf_print("Unable to allocate memory for IPA tx ce idx");
return -ENOBUFS;
}
@ -1402,7 +1397,7 @@ int htt_tx_ipa_uc_attach(struct htt_pdev_t *pdev,
tx_comp_ring_size);
if (!pdev->ipa_uc_tx_rsc.tx_comp_ring ||
!pdev->ipa_uc_tx_rsc.tx_comp_ring->vaddr) {
qdf_print("%s: TX COMP ring alloc fail", __func__);
qdf_print("TX COMP ring alloc fail");
return_code = -ENOBUFS;
goto free_tx_ce_idx;
}
@ -1412,7 +1407,6 @@ int htt_tx_ipa_uc_attach(struct htt_pdev_t *pdev,
qdf_mem_malloc(uc_tx_buf_cnt *
sizeof(*pdev->ipa_uc_tx_rsc.tx_buf_pool_strg));
if (!pdev->ipa_uc_tx_rsc.tx_buf_pool_strg) {
qdf_print("%s: TX BUF POOL vaddr storage alloc fail", __func__);
return_code = -ENOBUFS;
goto free_tx_comp_base;
}

4
core/dp/txrx/ol_cfg.c
View file

@ -115,10 +115,8 @@ struct cdp_cfg *ol_pdev_cfg_attach(qdf_device_t osdev, void *pcfg_param)
int i;
cfg_ctx = qdf_mem_malloc(sizeof(*cfg_ctx));
if (!cfg_ctx) {
printk(KERN_ERR "cfg ctx allocation failed\n");
if (!cfg_ctx)
return NULL;
}
ol_pdev_cfg_param_update(cfg_ctx);

28
core/dp/txrx/ol_rx.c
View file

@ -230,7 +230,7 @@ void ol_rx_update_histogram_stats(uint32_t msdu_count, uint8_t frag_ind,
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
return;
}
@ -555,8 +555,7 @@ ol_rx_indication_handler(ol_txrx_pdev_handle pdev,
ol_rx_reorder_peer_cleanup(vdev, peer);
} else {
if (tid >= OL_TXRX_NUM_EXT_TIDS) {
ol_txrx_err("%s: invalid tid, %u\n",
__func__, tid);
ol_txrx_err("invalid tid, %u", tid);
WARN_ON(1);
return;
}
@ -970,9 +969,7 @@ ol_rx_offload_deliver_ind_handler(ol_txrx_pdev_handle pdev,
htt_pdev_handle htt_pdev = pdev->htt_pdev;
if (msdu_cnt > htt_rx_offload_msdu_cnt(htt_pdev)) {
ol_txrx_err("%s: invalid msdu_cnt=%u\n",
__func__,
msdu_cnt);
ol_txrx_err("invalid msdu_cnt=%u", msdu_cnt);
if (pdev->cfg.is_high_latency)
htt_rx_desc_frame_free(htt_pdev, msg);
@ -1503,7 +1500,7 @@ ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev,
uint32_t filled = 0;
if (tid >= OL_TXRX_NUM_EXT_TIDS) {
ol_txrx_err("%s: invalid tid, %u\n", __FUNCTION__, tid);
ol_txrx_err("invalid tid, %u", tid);
WARN_ON(1);
return;
}
@ -1515,14 +1512,14 @@ ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev,
peer = ol_txrx_peer_find_by_id(pdev, peer_id);
htt_pdev = pdev->htt_pdev;
} else {
ol_txrx_err("%s: Invalid pdev passed!\n", __func__);
ol_txrx_err("Invalid pdev passed!");
qdf_assert_always(pdev);
return;
}
#if defined(HELIUMPLUS_DEBUG)
qdf_print("%s %d: rx_ind_msg 0x%pK peer_id %d tid %d is_offload %d\n",
__func__, __LINE__, rx_ind_msg, peer_id, tid, is_offload);
qdf_print("rx_ind_msg 0x%pK peer_id %d tid %d is_offload %d",
rx_ind_msg, peer_id, tid, is_offload);
#endif
pktlog_bit = (htt_rx_amsdu_rx_in_order_get_pktlog(rx_ind_msg) == 0x01);
@ -1543,7 +1540,7 @@ ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev,
ol_rx_ind_record_event(status, OL_RX_INDICATION_POP_END);
if (qdf_unlikely(0 == status)) {
ol_txrx_warn("%s: Pop status is 0, returning here", __func__);
ol_txrx_warn("pop failed");
return;
}
@ -1574,9 +1571,7 @@ ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev,
if (peer) {
vdev = peer->vdev;
} else {
ol_txrx_dbg(
"%s: Couldn't find peer from ID 0x%x\n",
__func__, peer_id);
ol_txrx_dbg("Couldn't find peer from ID 0x%x", peer_id);
while (head_msdu) {
qdf_nbuf_t msdu = head_msdu;
@ -1619,14 +1614,13 @@ void ol_rx_pkt_dump_call(
pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
peer = ol_txrx_peer_find_by_id(pdev, peer_id);
if (!peer) {
ol_txrx_dbg("%s: peer with peer id %d is NULL", __func__,
peer_id);
ol_txrx_dbg("peer with peer id %d is NULL", peer_id);
return;
}

5
core/dp/txrx/ol_rx_fwd.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011, 2014-2017 The Linux Foundation. All rights reserved.
* Copyright (c) 2011, 2014-2018 The Linux Foundation. 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
@ -70,8 +70,7 @@ static inline void ol_ap_fwd_check(struct ol_txrx_vdev_t *vdev, qdf_nbuf_t msdu)
qdf_mem_cmp
(mac_header->i_addr3, vdev->mac_addr.raw,
IEEE80211_ADDR_LEN)) {
ol_txrx_dbg("Exit: %s | Unnecessary to adjust mac header\n",
__func__);
ol_txrx_dbg("Exit | Unnecessary to adjust mac header");
} else {
/* Flip the ToDs bit to FromDs */
mac_header->i_fc[1] &= 0xfe;

6
core/dp/txrx/ol_tx.c
View file

@ -77,7 +77,7 @@ qdf_nbuf_t ol_tx_data(void *data_vdev, qdf_nbuf_t skb)
qdf_nbuf_set_next(skb, NULL);
ret = OL_TX_SEND(vdev, skb);
if (ret) {
ol_txrx_dbg("%s: Failed to tx", __func__);
ol_txrx_dbg("Failed to tx");
return ret;
}
@ -93,7 +93,7 @@ qdf_nbuf_t ol_tx_send_ipa_data_frame(struct cdp_vdev *vdev, qdf_nbuf_t skb)
if (qdf_unlikely(!pdev)) {
qdf_net_buf_debug_acquire_skb(skb, __FILE__, __LINE__);
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return skb;
}
@ -113,7 +113,7 @@ qdf_nbuf_t ol_tx_send_ipa_data_frame(struct cdp_vdev *vdev, qdf_nbuf_t skb)
ret = OL_TX_SEND((struct ol_txrx_vdev_t *)vdev, skb);
if (ret) {
ol_txrx_dbg("%s: Failed to tx", __func__);
ol_txrx_dbg("Failed to tx");
return ret;
}

9
core/dp/txrx/ol_tx_classify.c
View file

@ -572,9 +572,8 @@ ol_tx_classify(
*/
if (tx_msdu_info->htt.info.peer_id == HTT_INVALID_PEER_ID) {
if (peer) {
ol_txrx_info(
"%s: remove the peer for invalid peer_id %pK\n",
__func__, peer);
ol_txrx_info("remove the peer for invalid peer_id %pK",
peer);
/* remove the peer reference added above */
ol_txrx_peer_release_ref
(peer,
@ -597,9 +596,7 @@ ol_tx_classify(
if (IEEE80211_IS_MULTICAST(dest_addr) && vdev->opmode !=
wlan_op_mode_sta && tx_msdu_info->peer !=
NULL) {
ol_txrx_dbg(
"%s: remove the peer reference %pK\n",
__func__, peer);
ol_txrx_dbg("remove the peer reference %pK", peer);
/* remove the peer reference added above */
ol_txrx_peer_release_ref(tx_msdu_info->peer,
PEER_DEBUG_ID_OL_INTERNAL);

22
core/dp/txrx/ol_tx_desc.c
View file

@ -39,9 +39,8 @@ static inline void ol_tx_desc_sanity_checks(struct ol_txrx_pdev_t *pdev,
struct ol_tx_desc_t *tx_desc)
{
if (tx_desc->pkt_type != ol_tx_frm_freed) {
ol_txrx_err(
"%s Potential tx_desc corruption pkt_type:0x%x pdev:0x%pK",
__func__, tx_desc->pkt_type, pdev);
ol_txrx_err("Potential tx_desc corruption pkt_type:0x%x pdev:0x%pK",
tx_desc->pkt_type, pdev);
qdf_assert(0);
}
}
@ -53,8 +52,7 @@ static inline void ol_tx_desc_reset_pkt_type(struct ol_tx_desc_t *tx_desc)
static inline void ol_tx_desc_compute_delay(struct ol_tx_desc_t *tx_desc)
{
if (tx_desc->entry_timestamp_ticks != 0xffffffff) {
ol_txrx_err("%s Timestamp:0x%x\n",
__func__, tx_desc->entry_timestamp_ticks);
ol_txrx_err("Timestamp:0x%x", tx_desc->entry_timestamp_ticks);
qdf_assert(0);
}
tx_desc->entry_timestamp_ticks = qdf_system_ticks();
@ -526,16 +524,14 @@ void ol_tx_desc_free(struct ol_txrx_pdev_t *pdev, struct ol_tx_desc_t *tx_desc)
if (pool->avail_desc == pool->flow_pool_size) {
qdf_spin_unlock_bh(&pool->flow_pool_lock);
ol_tx_free_invalid_flow_pool(pool);
qdf_print("%s %d pool is INVALID State!!\n",
__func__, __LINE__);
qdf_print("pool is INVALID State!!");
return;
}
break;
case FLOW_POOL_ACTIVE_UNPAUSED:
break;
default:
qdf_print("%s %d pool is INACTIVE State!!\n",
__func__, __LINE__);
qdf_print("pool is INACTIVE State!!");
break;
};
@ -712,8 +708,8 @@ struct ol_tx_desc_t *ol_tx_desc_ll(struct ol_txrx_pdev_t *pdev,
htt_tx_desc_frag(pdev->htt_pdev, tx_desc->htt_frag_desc,
i - 1, frag_paddr, frag_len);
#if defined(HELIUMPLUS_DEBUG)
qdf_print("%s:%d: htt_fdesc=%pK frag=%d frag_vaddr=0x%pK frag_paddr=0x%llx len=%zu\n",
__func__, __LINE__, tx_desc->htt_frag_desc,
qdf_debug("htt_fdesc=%pK frag=%d frag_vaddr=0x%pK frag_paddr=0x%llx len=%zu\n",
tx_desc->htt_frag_desc,
i-1, frag_vaddr, frag_paddr, frag_len);
ol_txrx_dump_pkt(netbuf, frag_paddr, 64);
#endif /* HELIUMPLUS_DEBUG */
@ -855,8 +851,8 @@ void ol_tx_desc_frame_free_nonstd(struct ol_txrx_pdev_t *pdev,
* table pointer needs to be reset.
*/
#if defined(HELIUMPLUS_DEBUG)
qdf_print("%s %d: Frag Descriptor Reset [%d] to 0x%x\n",
__func__, __LINE__, tx_desc->id,
qdf_print("Frag Descriptor Reset [%d] to 0x%x\n",
tx_desc->id,
frag_desc_paddr);
#endif /* HELIUMPLUS_DEBUG */
#endif /* HELIUMPLUS */

12
core/dp/txrx/ol_tx_desc.h
View file

@ -359,8 +359,6 @@ void ol_tx_desc_dup_detect_init(struct ol_txrx_pdev_t *pdev, uint16_t pool_size)
uint16_t size = (pool_size >> DIV_BY_8) +
sizeof(*pdev->tx_desc.free_list_bitmap);
pdev->tx_desc.free_list_bitmap = qdf_mem_malloc(size);
if (!pdev->tx_desc.free_list_bitmap)
qdf_print("%s: malloc failed", __func__);
}
/**
@ -397,8 +395,8 @@ void ol_tx_desc_dup_detect_set(struct ol_txrx_pdev_t *pdev,
return;
if (qdf_unlikely(msdu_id > pdev->tx_desc.pool_size)) {
qdf_print("%s: msdu_id %d > pool_size %d",
__func__, msdu_id, pdev->tx_desc.pool_size);
qdf_print("msdu_id %d > pool_size %d",
msdu_id, pdev->tx_desc.pool_size);
QDF_BUG(0);
}
@ -406,7 +404,7 @@ void ol_tx_desc_dup_detect_set(struct ol_txrx_pdev_t *pdev,
if (qdf_unlikely(test)) {
uint16_t size = (pdev->tx_desc.pool_size >> DIV_BY_8) +
((pdev->tx_desc.pool_size & MOD_BY_8) ? 1 : 0);
qdf_print("duplicate msdu_id %d detected !!\n", msdu_id);
qdf_print("duplicate msdu_id %d detected!!", msdu_id);
qdf_trace_hex_dump(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
(void *)pdev->tx_desc.free_list_bitmap, size);
QDF_BUG(0);
@ -431,8 +429,8 @@ void ol_tx_desc_dup_detect_reset(struct ol_txrx_pdev_t *pdev,
return;
if (qdf_unlikely(msdu_id > pdev->tx_desc.pool_size)) {
qdf_print("%s: msdu_id %d > pool_size %d",
__func__, msdu_id, pdev->tx_desc.pool_size);
qdf_print("msdu_id %d > pool_size %d",
msdu_id, pdev->tx_desc.pool_size);
QDF_BUG(0);
}

4
core/dp/txrx/ol_tx_hl.c
View file

@ -1041,9 +1041,7 @@ void ol_txrx_update_tx_queue_groups(
struct ol_txrx_vdev_t *vdev;
if (group_id >= OL_TX_MAX_TXQ_GROUPS) {
ol_txrx_warn("%s: invalid group_id=%u, ignore update.\n",
__func__,
group_id);
ol_txrx_warn("invalid group_id=%u, ignore update", group_id);
return;
}

4
core/dp/txrx/ol_tx_ll_fastpath.c
View file

@ -234,8 +234,8 @@ ol_tx_prepare_ll_fast(struct ol_txrx_pdev_t *pdev,
htt_tx_desc_frag(pdev->htt_pdev, tx_desc->htt_frag_desc,
i - 1, frag_paddr, frag_len);
#if defined(HELIUMPLUS_DEBUG)
qdf_print("%s:%d: htt_fdesc=%pK frag=%d frag_paddr=0x%0llx len=%zu",
__func__, __LINE__, tx_desc->htt_frag_desc,
qdf_debug("htt_fdesc=%pK frag=%d frag_paddr=0x%0llx len=%zu",
tx_desc->htt_frag_desc,
i - 1, frag_paddr, frag_len);
ol_txrx_dump_pkt(netbuf, frag_paddr, 64);
#endif /* HELIUMPLUS_DEBUG */

3
core/dp/txrx/ol_tx_queue.c
View file

@ -120,8 +120,7 @@ ol_tx_queue_vdev_flush(struct ol_txrx_pdev_t *pdev, struct ol_txrx_vdev_t *vdev)
if (txq->frms)
ol_tx_queue_free(pdev, txq, j, true);
}
ol_txrx_info(
"%s: Delete Peer %pK\n", __func__, peer);
ol_txrx_info("Delete Peer %pK", peer);
ol_txrx_peer_release_ref(peers[i],
PEER_DEBUG_ID_OL_TXQ_VDEV_FL);
}

15
core/dp/txrx/ol_tx_send.c
View file

@ -897,7 +897,7 @@ void ol_tx_desc_update_group_credit(ol_txrx_pdev_handle pdev,
struct ol_tx_desc_t *tx_desc;
if (tx_desc_id >= pdev->tx_desc.pool_size) {
qdf_print("%s: Invalid desc id", __func__);
qdf_print("Invalid desc id");
return;
}
@ -1036,8 +1036,7 @@ ol_tx_single_completion_handler(ol_txrx_pdev_handle pdev,
tx_desc = ol_tx_desc_find_check(pdev, tx_desc_id);
if (tx_desc == NULL) {
ol_txrx_err("%s: invalid desc_id(%u), ignore it.\n",
__func__, tx_desc_id);
ol_txrx_err("invalid desc_id(%u), ignore it", tx_desc_id);
return;
}
@ -1508,8 +1507,7 @@ void ol_register_packetdump_callback(tp_ol_packetdump_cb ol_tx_packetdump_cb,
ol_txrx_pdev_handle pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
@ -1533,8 +1531,7 @@ void ol_deregister_packetdump_callback(void)
ol_txrx_pdev_handle pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
@ -1548,7 +1545,7 @@ void ol_register_timestamp_callback(tp_ol_timestamp_cb ol_tx_timestamp_cb)
ol_txrx_pdev_handle pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
pdev->ol_tx_timestamp_cb = ol_tx_timestamp_cb;
@ -1559,7 +1556,7 @@ void ol_deregister_timestamp_callback(void)
ol_txrx_pdev_handle pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
pdev->ol_tx_timestamp_cb = NULL;

4
core/dp/txrx/ol_tx_throttle.c
View file

@ -202,9 +202,7 @@ void ol_tx_throttle_set_level(struct cdp_pdev *ppdev, int level)
int ms = 0;
if (level >= THROTTLE_LEVEL_MAX) {
ol_txrx_dbg(
"%s invalid throttle level set %d, ignoring\n",
__func__, level);
ol_txrx_dbg("invalid throttle level set %d, ignoring", level);
return;
}

131
core/dp/txrx/ol_txrx.c
View file

@ -129,8 +129,7 @@ static void ol_tx_mark_first_wakeup_packet(uint8_t value)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
return;
}
@ -149,7 +148,7 @@ void ol_tx_set_is_mgmt_over_wmi_enabled(uint8_t value)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
qdf_print("%s: pdev is NULL\n", __func__);
qdf_print("pdev is NULL");
return;
}
pdev->is_mgmt_over_wmi_enabled = value;
@ -165,7 +164,7 @@ uint8_t ol_tx_get_is_mgmt_over_wmi_enabled(void)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
qdf_print("%s: pdev is NULL\n", __func__);
qdf_print("pdev is NULL");
return 0;
}
return pdev->is_mgmt_over_wmi_enabled;
@ -604,12 +603,9 @@ static QDF_STATUS ol_txrx_write_dpt_buff_debugfs(void *priv,
}
buf1 = (char *)qdf_mem_malloc(len);
if (!buf1) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: qdf_mem_malloc failure",
__func__);
if (!buf1)
return QDF_STATUS_E_FAULT;
}
qdf_mem_copy(buf1, buf, len);
ret = ol_txrx_conv_str_to_int_debugfs(buf1, len, &proto_bitmap,
&nr_records, &verbosity);
@ -808,7 +804,7 @@ void htt_pkt_log_init(struct cdp_pdev *ppdev, void *scn)
pktlog_sethandle(&handle->pl_dev, scn);
pktlog_set_callback_regtype(PKTLOG_DEFAULT_CALLBACK_REGISTRATION);
if (pktlogmod_init(scn))
qdf_print("%s: pktlogmod_init failed", __func__);
qdf_print(" pktlogmod_init failed");
else
handle->pkt_log_init = true;
}
@ -990,10 +986,9 @@ ol_txrx_pdev_post_attach(struct cdp_pdev *ppdev)
/* link SW tx descs into a freelist */
pdev->tx_desc.num_free = desc_pool_size;
ol_txrx_dbg(
"%s first tx_desc:0x%pK Last tx desc:0x%pK\n", __func__,
(uint32_t *) pdev->tx_desc.freelist,
(uint32_t *) (pdev->tx_desc.freelist + desc_pool_size));
ol_txrx_dbg("first tx_desc:0x%pK Last tx desc:0x%pK",
(uint32_t *)pdev->tx_desc.freelist,
(uint32_t *)(pdev->tx_desc.freelist + desc_pool_size));
/* check what format of frames are expected to be delivered by the OS */
pdev->frame_format = ol_cfg_frame_type(pdev->ctrl_pdev);
@ -1507,8 +1502,7 @@ static void ol_txrx_pdev_detach(struct cdp_pdev *ppdev, int force)
/*checking to ensure txrx pdev structure is not NULL */
if (!pdev) {
ol_txrx_err(
"NULL pdev passed to %s\n", __func__);
ol_txrx_err("pdev is NULL");
return;
}
@ -1718,7 +1712,7 @@ static void ol_txrx_vdev_register(struct cdp_vdev *pvdev, void *osif_vdev,
struct ol_txrx_vdev_t *vdev = (struct ol_txrx_vdev_t *)pvdev;
if (qdf_unlikely(!vdev) || qdf_unlikely(!txrx_ops)) {
qdf_print("%s: vdev/txrx_ops is NULL!\n", __func__);
qdf_print("vdev/txrx_ops is NULL!");
qdf_assert(0);
return;
}
@ -1888,8 +1882,8 @@ ol_txrx_vdev_detach(struct cdp_vdev *pvdev,
if (!TAILQ_EMPTY(&vdev->peer_list)) {
/* debug print - will be removed later */
ol_txrx_dbg(
"%s: not deleting vdev object %pK (%02x:%02x:%02x:%02x:%02x:%02x) until deletion finishes for all its peers\n",
__func__, vdev,
"not deleting vdev object %pK (%02x:%02x:%02x:%02x:%02x:%02x) until deletion finishes for all its peers\n",
vdev,
vdev->mac_addr.raw[0], vdev->mac_addr.raw[1],
vdev->mac_addr.raw[2], vdev->mac_addr.raw[3],
vdev->mac_addr.raw[4], vdev->mac_addr.raw[5]);
@ -1904,8 +1898,8 @@ ol_txrx_vdev_detach(struct cdp_vdev *pvdev,
qdf_event_destroy(&vdev->wait_delete_comp);
ol_txrx_dbg(
"%s: deleting vdev obj %pK (%02x:%02x:%02x:%02x:%02x:%02x)\n",
__func__, vdev,
"deleting vdev obj %pK (%02x:%02x:%02x:%02x:%02x:%02x)\n",
vdev,
vdev->mac_addr.raw[0], vdev->mac_addr.raw[1],
vdev->mac_addr.raw[2], vdev->mac_addr.raw[3],
vdev->mac_addr.raw[4], vdev->mac_addr.raw[5]);
@ -2521,8 +2515,7 @@ ol_txrx_remove_peers_for_vdev(struct cdp_vdev *pvdev,
qdf_spin_unlock_bh(&vdev->pdev->peer_ref_mutex);
if (self_removed)
ol_txrx_info("%s: self peer removed by caller ",
__func__);
ol_txrx_info("self peer removed by caller");
if (remove_last_peer) {
/* remove IBSS bss peer last */
@ -2551,8 +2544,8 @@ ol_txrx_remove_peers_for_vdev_no_lock(struct cdp_vdev *pvdev,
TAILQ_FOREACH_SAFE(peer, &vdev->peer_list, peer_list_elem, tmp_peer) {
ol_txrx_info_high(
"%s: peer found for vdev id %d. deleting the peer",
__func__, vdev->vdev_id);
"peer found for vdev id %d. deleting the peer",
vdev->vdev_id);
callback(callback_context, (uint8_t *)&vdev->mac_addr,
vdev->vdev_id, peer);
}
@ -2624,8 +2617,7 @@ QDF_STATUS ol_txrx_peer_state_update(struct cdp_pdev *ppdev,
PEER_DEBUG_ID_OL_INTERNAL);
if (NULL == peer) {
ol_txrx_err(
"%s: peer is null for peer_mac 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
__func__,
"peer is null for peer_mac 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
peer_mac[0], peer_mac[1], peer_mac[2], peer_mac[3],
peer_mac[4], peer_mac[5]);
return QDF_STATUS_E_INVAL;
@ -2635,9 +2627,7 @@ QDF_STATUS ol_txrx_peer_state_update(struct cdp_pdev *ppdev,
/* avoid multiple auth state change. */
if (peer->state == state) {
#ifdef TXRX_PRINT_VERBOSE_ENABLE
ol_txrx_dbg(
"%s: no state change, returns directly\n",
__func__);
ol_txrx_dbg("no state change, returns directly");
#endif
peer_ref_cnt = ol_txrx_peer_release_ref
(peer,
@ -2645,8 +2635,8 @@ QDF_STATUS ol_txrx_peer_state_update(struct cdp_pdev *ppdev,
return QDF_STATUS_SUCCESS;
}
ol_txrx_dbg("%s: change from %d to %d\n",
__func__, peer->state, state);
ol_txrx_dbg("change from %d to %d",
peer->state, state);
peer->tx_filter = (state == OL_TXRX_PEER_STATE_AUTH)
? ol_tx_filter_pass_thru
@ -2661,9 +2651,7 @@ QDF_STATUS ol_txrx_peer_state_update(struct cdp_pdev *ppdev,
* Pause all regular (non-extended) TID tx queues until
* data arrives and ADDBA negotiation has completed.
*/
ol_txrx_dbg(
"%s: pause peer and unpause mgmt/non-qos\n",
__func__);
ol_txrx_dbg("pause peer and unpause mgmt/non-qos");
ol_txrx_peer_pause(peer); /* pause all tx queues */
/* unpause mgmt and non-QoS tx queues */
for (tid = OL_TX_NUM_QOS_TIDS;
@ -2703,8 +2691,7 @@ ol_txrx_peer_update(ol_txrx_vdev_handle vdev,
peer = ol_txrx_peer_find_hash_find_get_ref(vdev->pdev, peer_mac, 0, 1,
PEER_DEBUG_ID_OL_INTERNAL);
if (!peer) {
ol_txrx_dbg("%s: peer is null",
__func__);
ol_txrx_dbg("peer is null");
return;
}
@ -2828,9 +2815,7 @@ static inline void ol_txrx_peer_free_tids(ol_txrx_peer_handle peer)
for (i = 0; i < OL_TXRX_NUM_EXT_TIDS; i++) {
if (peer->tids_rx_reorder[i].array !=
&peer->tids_rx_reorder[i].base) {
ol_txrx_dbg(
"%s, delete reorder arr, tid:%d\n",
__func__, i);
ol_txrx_dbg("delete reorder arr, tid:%d", i);
qdf_mem_free(peer->tids_rx_reorder[i].array);
ol_rx_reorder_init(&peer->tids_rx_reorder[i],
(uint8_t)i);
@ -2997,8 +2982,8 @@ int ol_txrx_peer_release_ref(ol_txrx_peer_handle peer,
*/
ol_txrx_tx_desc_reset_vdev(vdev);
ol_txrx_dbg(
"%s: deleting vdev object %pK (%02x:%02x:%02x:%02x:%02x:%02x) - its last peer is done",
__func__, vdev,
"deleting vdev object %pK (%02x:%02x:%02x:%02x:%02x:%02x) - its last peer is done",
vdev,
vdev->mac_addr.raw[0],
vdev->mac_addr.raw[1],
vdev->mac_addr.raw[2],
@ -3245,8 +3230,8 @@ static void ol_txrx_peer_detach_force_delete(void *ppeer)
ol_txrx_peer_handle peer = ppeer;
ol_txrx_pdev_handle pdev = peer->vdev->pdev;
ol_txrx_info_high("%s peer %pK, peer->ref_cnt %d",
__func__, peer, qdf_atomic_read(&peer->ref_cnt));
ol_txrx_info_high("peer %pK, peer->ref_cnt %d",
peer, qdf_atomic_read(&peer->ref_cnt));
/* Clear the peer_id_to_obj map entries */
ol_txrx_peer_remove_obj_map_entries(pdev, peer);
@ -3294,16 +3279,14 @@ static QDF_STATUS ol_txrx_wait_for_pending_tx(int timeout)
struct ol_txrx_pdev_t *txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (txrx_pdev == NULL) {
ol_txrx_err(
"%s: txrx context is null", __func__);
ol_txrx_err("txrx context is null");
return QDF_STATUS_E_FAULT;
}
while (ol_txrx_get_tx_pending((struct cdp_pdev *)txrx_pdev)) {
qdf_sleep(OL_ATH_TX_DRAIN_WAIT_DELAY);
if (timeout <= 0) {
ol_txrx_err(
"%s: tx frames are pending", __func__);
ol_txrx_err("tx frames are pending");
ol_txrx_dump_tx_desc(txrx_pdev);
return QDF_STATUS_E_TIMEOUT;
}
@ -3456,15 +3439,14 @@ int ol_txrx_fw_stats_desc_pool_init(struct ol_txrx_pdev_t *pdev,
int i;
if (!pdev) {
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return -EINVAL;
}
pdev->ol_txrx_fw_stats_desc_pool.pool = qdf_mem_malloc(pool_size *
sizeof(struct ol_txrx_fw_stats_desc_elem_t));
if (!pdev->ol_txrx_fw_stats_desc_pool.pool) {
ol_txrx_err("%s: failed to allocate desc pool", __func__);
if (!pdev->ol_txrx_fw_stats_desc_pool.pool)
return -ENOMEM;
}
pdev->ol_txrx_fw_stats_desc_pool.freelist =
&pdev->ol_txrx_fw_stats_desc_pool.pool[0];
pdev->ol_txrx_fw_stats_desc_pool.pool_size = pool_size;
@ -3494,15 +3476,15 @@ int ol_txrx_fw_stats_desc_pool_init(struct ol_txrx_pdev_t *pdev,
void ol_txrx_fw_stats_desc_pool_deinit(struct ol_txrx_pdev_t *pdev)
{
if (!pdev) {
ol_txrx_err("%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
if (!qdf_atomic_read(&pdev->ol_txrx_fw_stats_desc_pool.initialized)) {
ol_txrx_err("%s: Pool is not initialized", __func__);
ol_txrx_err("Pool is not initialized");
return;
}
if (!pdev->ol_txrx_fw_stats_desc_pool.pool) {
ol_txrx_err("%s: Pool is not allocated", __func__);
ol_txrx_err("Pool is not allocated");
return;
}
qdf_spin_lock_bh(&pdev->ol_txrx_fw_stats_desc_pool.pool_lock);
@ -3531,7 +3513,7 @@ struct ol_txrx_fw_stats_desc_t
if (!qdf_atomic_read(&pdev->ol_txrx_fw_stats_desc_pool.initialized)) {
qdf_spin_unlock_bh(&pdev->
ol_txrx_fw_stats_desc_pool.pool_lock);
ol_txrx_err("%s: Pool deinitialized", __func__);
ol_txrx_err("Pool deinitialized");
return NULL;
}
if (pdev->ol_txrx_fw_stats_desc_pool.freelist) {
@ -3542,10 +3524,9 @@ struct ol_txrx_fw_stats_desc_t
qdf_spin_unlock_bh(&pdev->ol_txrx_fw_stats_desc_pool.pool_lock);
if (desc)
ol_txrx_dbg("%s: desc_id %d allocated",
__func__, desc->desc_id);
ol_txrx_dbg("desc_id %d allocated", desc->desc_id);
else
ol_txrx_err("%s: fw stats descriptors are exhausted", __func__);
ol_txrx_err("fw stats descriptors are exhausted");
return desc;
}
@ -3569,8 +3550,7 @@ struct ol_txrx_stats_req_internal
if (!qdf_atomic_read(&pdev->ol_txrx_fw_stats_desc_pool.initialized)) {
qdf_spin_unlock_bh(&pdev->
ol_txrx_fw_stats_desc_pool.pool_lock);
ol_txrx_err("%s: Desc ID %u Pool deinitialized",
__func__, desc_id);
ol_txrx_err("Desc ID %u Pool deinitialized", desc_id);
return NULL;
}
desc_elem = &pdev->ol_txrx_fw_stats_desc_pool.pool[desc_id];
@ -3679,7 +3659,7 @@ ol_txrx_fw_stats_handler(ol_txrx_pdev_handle pdev,
int found = 0;
if (cookie >= FW_STATS_DESC_POOL_SIZE) {
ol_txrx_err("%s: Cookie is not valid", __func__);
ol_txrx_err("Cookie is not valid");
return;
}
req = ol_txrx_fw_stats_desc_get_req(pdev, (uint8_t)cookie);
@ -4510,7 +4490,7 @@ static void ol_rx_data_cb(struct ol_txrx_pdev_t *pdev,
free_buf:
drop_count = ol_txrx_drop_nbuf_list(buf_list);
ol_txrx_warn("%s:Dropped frames %u", __func__, drop_count);
ol_txrx_warn("Dropped frames %u", drop_count);
}
/* print for every 16th packet */
@ -4562,8 +4542,6 @@ static QDF_STATUS ol_txrx_enqueue_rx_frames(
next_buf = qdf_nbuf_queue_next(buf);
cache_buf = qdf_mem_malloc(sizeof(*cache_buf));
if (!cache_buf) {
ol_txrx_err(
"Failed to allocate buf to cache the rx frames");
qdf_nbuf_free(buf);
} else {
/* Add NULL terminator */
@ -4733,16 +4711,14 @@ static QDF_STATUS ol_txrx_register_ocb_peer(uint8_t *mac_addr,
pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s: Unable to find pdev!",
__func__);
ol_txrx_err("Unable to find pdev!");
return QDF_STATUS_E_FAILURE;
}
peer = ol_txrx_find_peer_by_addr((struct cdp_pdev *)pdev,
mac_addr, peer_id);
if (!peer) {
ol_txrx_err("%s: Unable to find OCB peer!",
__func__);
ol_txrx_err("Unable to find OCB peer!");
return QDF_STATUS_E_FAILURE;
}
@ -4956,7 +4932,7 @@ static QDF_STATUS ol_register_data_stall_detect_cb(
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (pdev == NULL) {
ol_txrx_err("%s: pdev NULL!", __func__);
ol_txrx_err("pdev NULL!");
return QDF_STATUS_E_INVAL;
}
pdev->data_stall_detect_callback = data_stall_detect_callback;
@ -4976,7 +4952,7 @@ static QDF_STATUS ol_deregister_data_stall_detect_cb(
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (pdev == NULL) {
ol_txrx_err("%s: pdev NULL!", __func__);
ol_txrx_err("pdev NULL!");
return QDF_STATUS_E_INVAL;
}
pdev->data_stall_detect_callback = NULL;
@ -5011,11 +4987,9 @@ static void ol_txrx_post_data_stall_event(
return;
}
data_stall_info = qdf_mem_malloc(sizeof(*data_stall_info));
if (!data_stall_info) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: data_stall_info is NULL.", __func__);
if (!data_stall_info)
return;
}
data_stall_info->indicator = indicator;
data_stall_info->data_stall_type = data_stall_type;
data_stall_info->vdev_id_bitmap = vdev_id_bitmap;
@ -5046,7 +5020,7 @@ static void ol_txrx_post_data_stall_event(
void
ol_txrx_dump_pkt(qdf_nbuf_t nbuf, uint32_t nbuf_paddr, int len)
{
qdf_print("%s: Pkt: VA 0x%pK PA 0x%llx len %d\n", __func__,
qdf_print(" Pkt: VA 0x%pK PA 0x%llx len %d\n",
qdf_nbuf_data(nbuf), (unsigned long long int)nbuf_paddr, len);
print_hex_dump(KERN_DEBUG, "Pkt: ", DUMP_PREFIX_ADDRESS, 16, 4,
qdf_nbuf_data(nbuf), len, true);
@ -5664,11 +5638,8 @@ struct cdp_soc_t *ol_txrx_soc_attach(void *scn_handle,
{
struct cdp_soc_t *soc = qdf_mem_malloc(sizeof(struct cdp_soc_t));
if (!soc) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: OL SOC memory allocation failed\n", __func__);
if (!soc)
return NULL;
}
soc->ops = &ol_txrx_ops;
return soc;

6
core/dp/txrx/ol_txrx_event.c
View file

@ -194,11 +194,9 @@ A_STATUS wdi_event_attach(struct ol_txrx_pdev_t *txrx_pdev)
qdf_mem_malloc(
sizeof(wdi_event_subscribe *) *
WDI_NUM_EVENTS);
if (!txrx_pdev->wdi_event_list) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"Insufficient memory for the WDI event lists\n");
if (!txrx_pdev->wdi_event_list)
return A_NO_MEMORY;
}
return A_OK;
}

99
core/dp/txrx/ol_txrx_flow_control.c
View file

@ -135,7 +135,7 @@ void ol_tx_set_desc_global_pool_size(uint32_t num_msdu_desc)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
qdf_print("%s: pdev is NULL\n", __func__);
qdf_print("pdev is NULL");
return;
}
pdev->num_msdu_desc = num_msdu_desc;
@ -235,14 +235,12 @@ static int ol_tx_delete_flow_pool(struct ol_tx_flow_pool_t *pool, bool force)
struct ol_tx_desc_t *tx_desc = NULL;
if (!pool) {
ol_txrx_err(
"%s: pool is NULL\n", __func__);
ol_txrx_err("pool is NULL");
QDF_ASSERT(0);
return -ENOMEM;
}
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
QDF_ASSERT(0);
return -ENOMEM;
}
@ -271,9 +269,8 @@ static int ol_tx_delete_flow_pool(struct ol_tx_flow_pool_t *pool, bool force)
ol_tx_inc_pool_ref(pool);
pdev->tx_desc.num_invalid_bin++;
ol_txrx_info(
"%s: invalid pool created %d\n",
__func__, pdev->tx_desc.num_invalid_bin);
ol_txrx_info("invalid pool created %d",
pdev->tx_desc.num_invalid_bin);
if (pdev->tx_desc.num_invalid_bin > MAX_INVALID_BIN)
ASSERT(0);
@ -451,8 +448,7 @@ void ol_tx_clear_flow_pool_stats(void)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if (!pdev) {
ol_txrx_err("%s: pdev is null\n",
__func__);
ol_txrx_err("pdev is null");
return;
}
qdf_mem_zero(&pdev->pool_stats, sizeof(pdev->pool_stats));
@ -529,8 +525,7 @@ ol_tx_distribute_descs_to_deficient_pools(struct ol_tx_flow_pool_t *src_pool)
uint16_t desc_move_count = 0;
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
return -EINVAL;
}
qdf_spin_lock_bh(&pdev->tx_desc.flow_pool_list_lock);
@ -590,19 +585,16 @@ struct ol_tx_flow_pool_t *ol_tx_create_flow_pool(uint8_t flow_pool_id,
uint32_t start_threshold;
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
return NULL;
}
stop_threshold = ol_cfg_get_tx_flow_stop_queue_th(pdev->ctrl_pdev);
start_threshold = stop_threshold +
ol_cfg_get_tx_flow_start_queue_offset(pdev->ctrl_pdev);
pool = qdf_mem_malloc(sizeof(*pool));
if (!pool) {
ol_txrx_err(
"%s: malloc failed\n", __func__);
if (!pool)
return NULL;
}
pool->flow_pool_id = flow_pool_id;
pool->flow_pool_size = flow_pool_size;
pool->status = FLOW_POOL_ACTIVE_UNPAUSED;
@ -663,8 +655,7 @@ int ol_tx_free_invalid_flow_pool(struct ol_tx_flow_pool_t *pool)
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
if ((!pdev) || (!pool) || (pool->status != FLOW_POOL_INVALID)) {
ol_txrx_err(
"%s: Invalid pool/pdev\n", __func__);
ol_txrx_err("Invalid pool/pdev");
return -EINVAL;
}
@ -676,9 +667,8 @@ int ol_tx_free_invalid_flow_pool(struct ol_tx_flow_pool_t *pool)
qdf_spin_unlock_bh(&pool->flow_pool_lock);
pdev->tx_desc.num_invalid_bin--;
ol_txrx_info(
"%s: invalid pool deleted %d\n",
__func__, pdev->tx_desc.num_invalid_bin);
ol_txrx_info("invalid pool deleted %d",
pdev->tx_desc.num_invalid_bin);
return ol_tx_dec_pool_ref(pool, false);
}
@ -734,9 +724,7 @@ static void ol_tx_flow_pool_vdev_map(struct ol_tx_flow_pool_t *pool,
vdev = (struct ol_txrx_vdev_t *)ol_txrx_get_vdev_from_vdev_id(vdev_id);
if (!vdev) {
ol_txrx_err(
"%s: invalid vdev_id %d\n",
__func__, vdev_id);
ol_txrx_err("invalid vdev_id %d", vdev_id);
return;
}
@ -760,9 +748,7 @@ static void ol_tx_flow_pool_vdev_unmap(struct ol_tx_flow_pool_t *pool,
vdev = (struct ol_txrx_vdev_t *)ol_txrx_get_vdev_from_vdev_id(vdev_id);
if (!vdev) {
ol_txrx_err(
"%s: invalid vdev_id %d\n",
__func__, vdev_id);
ol_txrx_err("invalid vdev_id %d", vdev_id);
return;
}
@ -792,13 +778,11 @@ void ol_tx_flow_pool_map_handler(uint8_t flow_id, uint8_t flow_type,
uint8_t pool_create = 0;
enum htt_flow_type type = flow_type;
ol_txrx_dbg(
"%s: flow_id %d flow_type %d flow_pool_id %d flow_pool_size %d\n",
__func__, flow_id, flow_type, flow_pool_id, flow_pool_size);
ol_txrx_dbg("flow_id %d flow_type %d flow_pool_id %d flow_pool_size %d",
flow_id, flow_type, flow_pool_id, flow_pool_size);
if (qdf_unlikely(!pdev)) {
ol_txrx_err(
"%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
pdev->pool_stats.pool_map_count++;
@ -807,9 +791,8 @@ void ol_tx_flow_pool_map_handler(uint8_t flow_id, uint8_t flow_type,
if (!pool) {
pool = ol_tx_create_flow_pool(flow_pool_id, flow_pool_size);
if (pool == NULL) {
ol_txrx_err(
"%s: creation of flow_pool %d size %d failed\n",
__func__, flow_pool_id, flow_pool_size);
ol_txrx_err("creation of flow_pool %d size %d failed",
flow_pool_id, flow_pool_size);
return;
}
pool_create = 1;
@ -826,9 +809,7 @@ void ol_tx_flow_pool_map_handler(uint8_t flow_id, uint8_t flow_type,
default:
if (pool_create)
ol_tx_dec_pool_ref(pool, false);
ol_txrx_err(
"%s: flow type %d not supported !!!\n",
__func__, type);
ol_txrx_err("flow type %d not supported", type);
break;
}
}
@ -851,22 +832,18 @@ void ol_tx_flow_pool_unmap_handler(uint8_t flow_id, uint8_t flow_type,
struct ol_tx_flow_pool_t *pool;
enum htt_flow_type type = flow_type;
ol_txrx_dbg(
"%s: flow_id %d flow_type %d flow_pool_id %d\n",
__func__, flow_id, flow_type, flow_pool_id);
ol_txrx_dbg("flow_id %d flow_type %d flow_pool_id %d",
flow_id, flow_type, flow_pool_id);
if (qdf_unlikely(!pdev)) {
ol_txrx_err(
"%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
pdev->pool_stats.pool_unmap_count++;
pool = ol_tx_get_flow_pool(flow_pool_id);
if (!pool) {
ol_txrx_info(
"%s: flow_pool not available flow_pool_id %d\n",
__func__, type);
ol_txrx_info("flow_pool not available flow_pool_id %d", type);
return;
}
@ -876,9 +853,7 @@ void ol_tx_flow_pool_unmap_handler(uint8_t flow_id, uint8_t flow_type,
ol_tx_flow_pool_vdev_unmap(pool, flow_id);
break;
default:
ol_txrx_info(
"%s: flow type %d not supported !!!\n",
__func__, type);
ol_txrx_info("flow type %d not supported", type);
return;
}
@ -911,8 +886,7 @@ int ol_tx_distribute_descs_to_deficient_pools_from_global_pool(void)
uint8_t free_invalid_pool = 0;
if (!pdev) {
ol_txrx_err(
"%s: pdev is NULL\n", __func__);
ol_txrx_err("pdev is NULL");
return -EINVAL;
}
@ -1206,20 +1180,19 @@ void ol_tx_flow_pool_resize_handler(uint8_t flow_pool_id,
struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
struct ol_tx_flow_pool_t *pool;
ol_txrx_dbg("%s: flow_pool_id %d flow_pool_size %d\n",
__func__, flow_pool_id, flow_pool_size);
ol_txrx_dbg("flow_pool_id %d flow_pool_size %d",
flow_pool_id, flow_pool_size);
if (qdf_unlikely(!pdev)) {
ol_txrx_err(
"%s: pdev is NULL", __func__);
ol_txrx_err("pdev is NULL");
return;
}
pdev->pool_stats.pool_resize_count++;
pool = ol_tx_get_flow_pool(flow_pool_id);
if (!pool) {
ol_txrx_err("%s: resize for flow_pool %d size %d failed\n",
__func__, flow_pool_id, flow_pool_size);
ol_txrx_err("resize for flow_pool %d size %d failed",
flow_pool_id, flow_pool_size);
return;
}
@ -1250,9 +1223,7 @@ ol_txrx_map_to_netif_reason_type(uint32_t reason)
case OL_TXQ_PAUSE_REASON_THERMAL_MITIGATION:
return WLAN_THERMAL_MITIGATION;
default:
ol_txrx_err(
"%s: reason not supported %d\n",
__func__, reason);
ol_txrx_err("reason not supported %d", reason);
return WLAN_REASON_TYPE_MAX;
}
}
@ -1271,7 +1242,7 @@ void ol_txrx_vdev_pause(struct cdp_vdev *pvdev, uint32_t reason)
enum netif_reason_type netif_reason;
if (qdf_unlikely((!pdev) || (!pdev->pause_cb))) {
ol_txrx_err("%s: invalid pdev\n", __func__);
ol_txrx_err("invalid pdev");
return;
}
@ -1296,7 +1267,7 @@ void ol_txrx_vdev_unpause(struct cdp_vdev *pvdev, uint32_t reason)
enum netif_reason_type netif_reason;
if (qdf_unlikely((!pdev) || (!pdev->pause_cb))) {
ol_txrx_err("%s: invalid pdev\n", __func__);
ol_txrx_err("invalid pdev");
return;
}

18
core/dp/txrx/ol_txrx_ipa.c
View file

@ -1131,11 +1131,9 @@ static QDF_STATUS ol_txrx_ipa_remove_header(char *name)
hdrlookup.hdl);
len = sizeof(qdf_ipa_ioc_del_hdr_t) + sizeof(qdf_ipa_hdr_del_t) * 1;
ipa_hdr = (qdf_ipa_ioc_del_hdr_t *)qdf_mem_malloc(len);
if (ipa_hdr == NULL) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"ipa_hdr allocation failed");
if (!ipa_hdr)
return QDF_STATUS_E_FAILURE;
}
QDF_IPA_IOC_DEL_HDR_NUM_HDRS(ipa_hdr) = 1;
QDF_IPA_IOC_DEL_HDR_COMMIT(ipa_hdr) = 0;
QDF_IPA_IOC_DEL_HDR_HDL(ipa_hdr) = QDF_IPA_IOC_GET_HDR_HDL(&hdrlookup);
@ -1174,8 +1172,6 @@ static int ol_txrx_ipa_add_header_info(char *ifname, uint8_t *mac_addr,
ipa_hdr = qdf_mem_malloc(sizeof(qdf_ipa_ioc_add_hdr_t)
+ sizeof(qdf_ipa_hdr_add_t));
if (!ipa_hdr) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: ipa_hdr allocation failed", ifname);
ret = -ENOMEM;
goto end;
}
@ -1283,20 +1279,14 @@ static int ol_txrx_ipa_register_interface(char *ifname,
/* Allocate TX properties for TOS categories, 1 each for IPv4 & IPv6 */
tx_prop =
qdf_mem_malloc(sizeof(qdf_ipa_ioc_tx_intf_prop_t) * num_prop);
if (!tx_prop) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"tx_prop allocation failed");
if (!tx_prop)
goto register_interface_fail;
}
/* Allocate RX properties, 1 each for IPv4 & IPv6 */
rx_prop =
qdf_mem_malloc(sizeof(qdf_ipa_ioc_rx_intf_prop_t) * num_prop);
if (!rx_prop) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"rx_prop allocation failed");
if (!rx_prop)
goto register_interface_fail;
}
qdf_mem_zero(&tx_intf, sizeof(tx_intf));
qdf_mem_zero(&rx_intf, sizeof(rx_intf));

16
core/dp/txrx/ol_txrx_peer_find.c
View file

@ -388,9 +388,8 @@ static inline void ol_txrx_peer_find_add_id(struct ol_txrx_pdev_t *pdev,
* If the peer ID is for a vdev, then we will fail to find a
* peer with a matching MAC address.
*/
ol_txrx_err(
"%s: peer not found or peer ID is %d invalid",
__func__, peer_id);
ol_txrx_err("peer not found or peer ID is %d invalid",
peer_id);
wlan_roam_debug_log(DEBUG_INVALID_VDEV_ID,
DEBUG_PEER_MAP_EVENT,
peer_id, peer_mac_addr,
@ -572,7 +571,7 @@ void ol_rx_peer_unmap_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id)
if (peer_id == HTT_INVALID_PEER) {
ol_txrx_err(
"%s: invalid peer ID %d\n", __func__, peer_id);
"invalid peer ID %d\n", peer_id);
wlan_roam_debug_log(DEBUG_INVALID_VDEV_ID,
DEBUG_PEER_UNMAP_EVENT,
peer_id, NULL, NULL, 0, 0x100);
@ -592,9 +591,8 @@ void ol_rx_peer_unmap_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id)
wlan_roam_debug_log(DEBUG_INVALID_VDEV_ID,
DEBUG_PEER_UNMAP_EVENT,
peer_id, NULL, NULL, ref_cnt, 0x101);
ol_txrx_dbg(
"%s: peer already deleted, peer_id %d del_peer_id_ref_cnt %d",
__func__, peer_id, ref_cnt);
ol_txrx_dbg("peer already deleted, peer_id %d del_peer_id_ref_cnt %d",
peer_id, ref_cnt);
return;
}
peer = pdev->peer_id_to_obj_map[peer_id].peer;
@ -606,9 +604,7 @@ void ol_rx_peer_unmap_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id)
* in peer_id_to_obj_map will be NULL.
*/
qdf_spin_unlock_bh(&pdev->peer_map_unmap_lock);
ol_txrx_info(
"%s: peer not found for peer_id %d",
__func__, peer_id);
ol_txrx_info("peer not found for peer_id %d", peer_id);
wlan_roam_debug_log(DEBUG_INVALID_VDEV_ID,
DEBUG_PEER_UNMAP_EVENT,
peer_id, NULL, NULL, 0, 0x102);

1
core/dp/txrx3.0/dp_rx_thread.c
View file

@ -475,7 +475,6 @@ QDF_STATUS dp_rx_tm_init(struct dp_rx_tm_handle *rx_tm_hdl,
if (qdf_unlikely(!rx_tm_hdl->rx_thread[i])) {
QDF_ASSERT(0);
qdf_status = QDF_STATUS_E_NOMEM;
dp_err("failed to allocate memory for dp_rx_thread");
goto ret;
}
rx_tm_hdl->rx_thread[i]->rtm_handle_cmn =

1
core/dp/txrx3.0/dp_txrx.c
View file

@ -28,7 +28,6 @@ QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, struct cdp_pdev *pdev,
dp_ext_hdl = qdf_mem_malloc(sizeof(*dp_ext_hdl));
if (!dp_ext_hdl) {
dp_err("failed to alloc dp_txrx_handle");
QDF_ASSERT(0);
return QDF_STATUS_E_NOMEM;
}