qcacmn: Add RX prealloc pool for replenishing RX buffers

Add and initialize a preallocated pool of buffers which can
be used to replenish RX buffers. During replenish, the buffers
from the pool are used instead of allocating/mapping a new buffer
in the softirq context. This preallocated pool will be refilled
in thread context.

Change-Id: Idf3bd7d25c5d57ddba105ccd8fab672c26a184f1
CRs-Fixed: 2869345
This commit is contained in:
Karthik Kantamneni
2021-01-19 11:41:00 +05:30
committed by snandini
parent 71e3244d46
commit 595bc84a39
7 changed files with 305 additions and 13 deletions

View File

@@ -17,13 +17,22 @@
*/
#include "dp_rx_buffer_pool.h"
#include "dp_ipa.h"
#ifndef DP_RX_BUFFER_POOL_SIZE
#define DP_RX_BUFFER_POOL_SIZE 128
#endif
#ifndef DP_RX_BUFFER_POOL_ALLOC_THRES
#define DP_RX_BUFFER_POOL_ALLOC_THRES 1
#ifndef DP_RX_REFILL_BUFF_POOL_SIZE
#define DP_RX_REFILL_BUFF_POOL_SIZE 2048
#endif
#ifndef DP_RX_REFILL_BUFF_POOL_BURST
#define DP_RX_REFILL_BUFF_POOL_BURST 64
#endif
#ifndef DP_RX_BUFF_POOL_ALLOC_THRES
#define DP_RX_BUFF_POOL_ALLOC_THRES 1
#endif
#ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL
@@ -109,6 +118,96 @@ void dp_rx_buffer_pool_nbuf_free(struct dp_soc *soc, qdf_nbuf_t nbuf, u8 mac_id)
qdf_nbuf_queue_head_enqueue_tail(&buff_pool->emerg_nbuf_q, nbuf);
}
void dp_rx_refill_buff_pool_enqueue(struct dp_soc *soc)
{
struct rx_desc_pool *rx_desc_pool;
struct rx_refill_buff_pool *buff_pool;
struct dp_pdev *dp_pdev;
qdf_nbuf_t nbuf;
QDF_STATUS ret;
int count, i;
qdf_nbuf_t nbuf_head;
qdf_nbuf_t nbuf_tail;
uint32_t num_req_refill;
if (!soc)
return;
buff_pool = &soc->rx_refill_buff_pool;
if (!buff_pool->is_initialized)
return;
rx_desc_pool = &soc->rx_desc_buf[0];
dp_pdev = dp_get_pdev_for_lmac_id(soc, 0);
num_req_refill = buff_pool->max_bufq_len - buff_pool->bufq_len;
while (num_req_refill) {
if (num_req_refill > DP_RX_REFILL_BUFF_POOL_BURST)
num_req_refill = DP_RX_REFILL_BUFF_POOL_BURST;
count = 0;
nbuf_head = NULL;
nbuf_tail = NULL;
for (i = 0; i < num_req_refill; i++) {
nbuf = qdf_nbuf_alloc(soc->osdev,
rx_desc_pool->buf_size,
RX_BUFFER_RESERVATION,
rx_desc_pool->buf_alignment,
FALSE);
if (!nbuf)
continue;
ret = qdf_nbuf_map_nbytes_single(soc->osdev, nbuf,
QDF_DMA_FROM_DEVICE,
rx_desc_pool->buf_size);
if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
qdf_nbuf_free(nbuf);
continue;
}
dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
rx_desc_pool->buf_size,
true);
DP_RX_LIST_APPEND(nbuf_head, nbuf_tail, nbuf);
count++;
}
if (count) {
qdf_spin_lock_bh(&buff_pool->bufq_lock);
DP_RX_MERGE_TWO_LIST(buff_pool->buf_head,
buff_pool->buf_tail,
nbuf_head, nbuf_tail);
buff_pool->bufq_len += count;
num_req_refill = buff_pool->max_bufq_len -
buff_pool->bufq_len;
qdf_spin_unlock_bh(&buff_pool->bufq_lock);
DP_STATS_INC(dp_pdev,
rx_refill_buff_pool.num_bufs_refilled,
count);
}
}
}
static inline qdf_nbuf_t dp_rx_refill_buff_pool_dequeue_nbuf(struct dp_soc *soc)
{
qdf_nbuf_t nbuf = NULL;
struct rx_refill_buff_pool *buff_pool = &soc->rx_refill_buff_pool;
if (!buff_pool->is_initialized || !buff_pool->bufq_len)
return nbuf;
qdf_spin_lock_bh(&buff_pool->bufq_lock);
nbuf = buff_pool->buf_head;
buff_pool->buf_head = qdf_nbuf_next(buff_pool->buf_head);
qdf_nbuf_set_next(nbuf, NULL);
buff_pool->bufq_len--;
qdf_spin_unlock_bh(&buff_pool->bufq_lock);
return nbuf;
}
qdf_nbuf_t
dp_rx_buffer_pool_nbuf_alloc(struct dp_soc *soc, uint32_t mac_id,
struct rx_desc_pool *rx_desc_pool,
@@ -119,6 +218,13 @@ dp_rx_buffer_pool_nbuf_alloc(struct dp_soc *soc, uint32_t mac_id,
struct dp_srng *dp_rxdma_srng;
qdf_nbuf_t nbuf;
nbuf = dp_rx_refill_buff_pool_dequeue_nbuf(soc);
if (nbuf) {
DP_STATS_INC(dp_pdev,
rx_refill_buff_pool.num_bufs_allocated, 1);
return nbuf;
}
if (!wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
mac_id = dp_pdev->lmac_id;
@@ -152,6 +258,81 @@ dp_rx_buffer_pool_nbuf_alloc(struct dp_soc *soc, uint32_t mac_id,
return nbuf;
}
QDF_STATUS
dp_rx_buffer_pool_nbuf_map(struct dp_soc *soc,
struct rx_desc_pool *rx_desc_pool,
struct dp_rx_nbuf_frag_info *nbuf_frag_info_t)
{
QDF_STATUS ret = QDF_STATUS_SUCCESS;
if (!QDF_NBUF_CB_PADDR((nbuf_frag_info_t->virt_addr).nbuf)) {
ret = qdf_nbuf_map_nbytes_single(soc->osdev,
(nbuf_frag_info_t->virt_addr).nbuf,
QDF_DMA_FROM_DEVICE,
rx_desc_pool->buf_size);
if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret)))
return ret;
dp_ipa_handle_rx_buf_smmu_mapping(soc,
(qdf_nbuf_t)((nbuf_frag_info_t->virt_addr).nbuf),
rx_desc_pool->buf_size,
true);
}
return ret;
}
static void dp_rx_refill_buff_pool_init(struct dp_soc *soc, u8 mac_id)
{
struct rx_desc_pool *rx_desc_pool = &soc->rx_desc_buf[mac_id];
qdf_nbuf_t nbuf;
struct rx_refill_buff_pool *buff_pool = &soc->rx_refill_buff_pool;
QDF_STATUS ret;
int i;
if (!wlan_cfg_is_rx_refill_buffer_pool_enabled(soc->wlan_cfg_ctx)) {
dp_err("RX refill buffer pool support is disabled");
buff_pool->is_initialized = false;
return;
}
buff_pool->bufq_len = 0;
buff_pool->buf_head = NULL;
buff_pool->buf_tail = NULL;
buff_pool->max_bufq_len = DP_RX_REFILL_BUFF_POOL_SIZE;
qdf_spinlock_create(&buff_pool->bufq_lock);
for (i = 0; i < buff_pool->max_bufq_len; i++) {
nbuf = qdf_nbuf_alloc(soc->osdev, rx_desc_pool->buf_size,
RX_BUFFER_RESERVATION,
rx_desc_pool->buf_alignment, FALSE);
if (!nbuf)
continue;
ret = qdf_nbuf_map_nbytes_single(soc->osdev, nbuf,
QDF_DMA_FROM_DEVICE,
rx_desc_pool->buf_size);
if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
qdf_nbuf_free(nbuf);
continue;
}
dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
rx_desc_pool->buf_size,
true);
DP_RX_LIST_APPEND(buff_pool->buf_head,
buff_pool->buf_tail, nbuf);
buff_pool->bufq_len++;
}
dp_info("RX refill buffer pool required allocation: %u actual allocation: %u",
buff_pool->max_bufq_len,
buff_pool->bufq_len);
buff_pool->is_initialized = true;
}
void dp_rx_buffer_pool_init(struct dp_soc *soc, u8 mac_id)
{
struct rx_desc_pool *rx_desc_pool = &soc->rx_desc_buf[mac_id];
@@ -159,6 +340,8 @@ void dp_rx_buffer_pool_init(struct dp_soc *soc, u8 mac_id)
qdf_nbuf_t nbuf;
int i;
dp_rx_refill_buff_pool_init(soc, mac_id);
if (!wlan_cfg_is_rx_buffer_pool_enabled(soc->wlan_cfg_ctx)) {
dp_err("RX buffer pool support is disabled");
buff_pool->is_initialized = false;
@@ -187,11 +370,35 @@ void dp_rx_buffer_pool_init(struct dp_soc *soc, u8 mac_id)
buff_pool->is_initialized = true;
}
static void dp_rx_refill_buff_pool_deinit(struct dp_soc *soc, u8 mac_id)
{
struct rx_refill_buff_pool *buff_pool = &soc->rx_refill_buff_pool;
struct rx_desc_pool *rx_desc_pool = &soc->rx_desc_buf[mac_id];
qdf_nbuf_t nbuf;
if (!buff_pool->is_initialized)
return;
while ((nbuf = dp_rx_refill_buff_pool_dequeue_nbuf(soc))) {
dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
rx_desc_pool->buf_size,
false);
qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf,
QDF_DMA_BIDIRECTIONAL,
rx_desc_pool->buf_size);
qdf_nbuf_free(nbuf);
}
buff_pool->is_initialized = false;
}
void dp_rx_buffer_pool_deinit(struct dp_soc *soc, u8 mac_id)
{
struct rx_buff_pool *buff_pool = &soc->rx_buff_pool[mac_id];
qdf_nbuf_t nbuf;
dp_rx_refill_buff_pool_deinit(soc, mac_id);
if (!buff_pool->is_initialized)
return;