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

qcacmn: Rename mslot/pslot with module_id/pool_id

Browse Source 
Currently in WBUFF code, mslot/pslot is used to refer module_id/pool_id
and there are references of them being used interchangeably.

Rename mslot/pslot to module_id/pool_id to improve the readability of
the code. This is the pre-requisite to support mutilple modules in WBUFF
which will be added with a future patch.

Change-Id: Ia5a113535cff950cd3f464b6133370f026d4fc87
CRs-Fixed: 3516982
This commit is contained in:
Manikanta Pubbisetty
2023-06-01 16:36:30 +05:30
committed by Rahul Choudhary
parent 2baa26c9b4
commit 3ea9fb0844
2 changed files with 84 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
wbuff/src/i_wbuff.h
View File

@@ -52,11 +52,11 @@
/* Allocation of size 2048 bytes */ /* Allocation of size 2048 bytes */
#define WBUFF_POOL_3_MAX 32 #define WBUFF_POOL_3_MAX 32
#define WBUFF_MSLOT_SHIFT 4 #define WBUFF_MODULE_ID_SHIFT 4
#define WBUFF_MSLOT_BITMASK 0xF0 #define WBUFF_MODULE_ID_BITMASK 0xF0
#define WBUFF_PSLOT_SHIFT 1 #define WBUFF_POOL_ID_SHIFT 1
#define WBUFF_PSLOT_BITMASK 0xE #define WBUFF_POOL_ID_BITMASK 0xE
/* Comparison array for maximum allocation per pool*/ /* Comparison array for maximum allocation per pool*/
uint16_t wbuff_alloc_max[WBUFF_MAX_POOLS] = {WBUFF_POOL_0_MAX, uint16_t wbuff_alloc_max[WBUFF_MAX_POOLS] = {WBUFF_POOL_0_MAX,
@@ -77,7 +77,7 @@ struct wbuff_handle {
* @registered: To identify whether module is registered * @registered: To identify whether module is registered
* @pending_returns: Number of buffers pending to be returned to * @pending_returns: Number of buffers pending to be returned to
* wbuff by the module * wbuff by the module
* @lock: Lock for accessing per module buffer slots * @lock: Lock for accessing per module buffer pools
* @handle: wbuff handle for the registered module * @handle: wbuff handle for the registered module
* @reserve: nbuf headroom to start with * @reserve: nbuf headroom to start with
* @align: alignment for the nbuf * @align: alignment for the nbuf

156
wbuff/src/wbuff.c
View File

@@ -31,10 +31,10 @@
struct wbuff_holder wbuff; struct wbuff_holder wbuff;
/** /**
* wbuff_get_pool_slot_from_len() - get pool_slot from length * wbuff_get_pool_slot_from_len() - get pool_id from length
* @len: length of the buffer * @len: length of the buffer
* *
* Return: pool slot * Return: pool_id
*/ */
static uint8_t wbuff_get_pool_slot_from_len(uint16_t len) static uint8_t wbuff_get_pool_slot_from_len(uint16_t len)
{ {
@@ -49,16 +49,16 @@ static uint8_t wbuff_get_pool_slot_from_len(uint16_t len)
} }
/** /**
* wbuff_get_len_from_pool_slot() - get len from pool slot * wbuff_get_len_from_pool_slot() - get len from pool_id
* @pool_slot: wbuff pool_slot * @pool_id: pool ID
* *
* Return: nbuf length from pool slot * Return: nbuf length from pool_id
*/ */
static uint32_t wbuff_get_len_from_pool_slot(uint16_t pool_slot) static uint32_t wbuff_get_len_from_pool_slot(uint16_t pool_id)
{ {
uint32_t len = 0; uint32_t len = 0;
switch (pool_slot) { switch (pool_id) {
case 0: case 0:
len = WBUFF_LEN_POOL0; len = WBUFF_LEN_POOL0;
break; break;
@@ -79,25 +79,25 @@ static uint32_t wbuff_get_len_from_pool_slot(uint16_t pool_slot)
} }
/** /**
* wbuff_get_free_mod_slot() - get free module slot * wbuff_get_free_mod_slot() - get free module_id
* *
* Return: module slot * Return: module_id
*/ */
static uint8_t wbuff_get_free_mod_slot(void) static uint8_t wbuff_get_free_mod_slot(void)
{ {
uint8_t mslot = 0; uint8_t module_id = 0;
for (mslot = 0; mslot < WBUFF_MAX_MODULES; mslot++) { for (module_id = 0; module_id < WBUFF_MAX_MODULES; module_id++) {
qdf_spin_lock_bh(&wbuff.mod[mslot].lock); qdf_spin_lock_bh(&wbuff.mod[module_id].lock);
if (!wbuff.mod[mslot].registered) { if (!wbuff.mod[module_id].registered) {
wbuff.mod[mslot].registered = true; wbuff.mod[module_id].registered = true;
qdf_spin_unlock_bh(&wbuff.mod[mslot].lock); qdf_spin_unlock_bh(&wbuff.mod[module_id].lock);
break; break;
} }
qdf_spin_unlock_bh(&wbuff.mod[mslot].lock); qdf_spin_unlock_bh(&wbuff.mod[module_id].lock);
} }
return mslot; return module_id;
} }
/** /**
@@ -112,13 +112,13 @@ static bool wbuff_is_valid_alloc_req(struct wbuff_alloc_request *req,
uint8_t num) uint8_t num)
{ {
uint16_t psize = 0; uint16_t psize = 0;
uint8_t alloc = 0, pslot = 0; uint8_t alloc = 0, pool_id = 0;
for (alloc = 0; alloc < num; alloc++) { for (alloc = 0; alloc < num; alloc++) {
pslot = req[alloc].slot; pool_id = req[alloc].slot;
psize = req[alloc].size; psize = req[alloc].size;
if ((pslot > WBUFF_MAX_POOLS - 1) || if ((pool_id > WBUFF_MAX_POOLS - 1) ||
(psize > wbuff_alloc_max[pslot])) (psize > wbuff_alloc_max[pool_id]))
return false; return false;
} }
@@ -127,8 +127,8 @@ static bool wbuff_is_valid_alloc_req(struct wbuff_alloc_request *req,
/** /**
* wbuff_prepare_nbuf() - allocate nbuf * wbuff_prepare_nbuf() - allocate nbuf
* @mslot: module slot * @module_id: module ID
* @pslot: pool slot * @pool_id: pool ID
* @len: length of the buffer * @len: length of the buffer
* @reserve: nbuf headroom to start with * @reserve: nbuf headroom to start with
* @align: alignment for the nbuf * @align: alignment for the nbuf
@@ -136,7 +136,7 @@ static bool wbuff_is_valid_alloc_req(struct wbuff_alloc_request *req,
* Return: nbuf if success * Return: nbuf if success
* NULL if failure * NULL if failure
*/ */
static qdf_nbuf_t wbuff_prepare_nbuf(uint8_t mslot, uint8_t pslot, static qdf_nbuf_t wbuff_prepare_nbuf(uint8_t module_id, uint8_t pool_id,
uint32_t len, int reserve, int align) uint32_t len, int reserve, int align)
{ {
qdf_nbuf_t buf; qdf_nbuf_t buf;
@@ -146,9 +146,9 @@ static qdf_nbuf_t wbuff_prepare_nbuf(uint8_t mslot, uint8_t pslot,
align, false); align, false);
if (!buf) if (!buf)
return NULL; return NULL;
dev_scratch = mslot; dev_scratch = module_id;
dev_scratch <<= WBUFF_MSLOT_SHIFT; dev_scratch <<= WBUFF_MODULE_ID_SHIFT;
dev_scratch |= ((pslot << WBUFF_PSLOT_SHIFT) | 1); dev_scratch |= ((pool_id << WBUFF_POOL_ID_SHIFT) | 1);
qdf_nbuf_set_dev_scratch(buf, dev_scratch); qdf_nbuf_set_dev_scratch(buf, dev_scratch);
return buf; return buf;
@@ -173,18 +173,18 @@ static bool wbuff_is_valid_handle(struct wbuff_handle *handle)
QDF_STATUS wbuff_module_init(void) QDF_STATUS wbuff_module_init(void)
{ {
struct wbuff_module *mod = NULL; struct wbuff_module *mod = NULL;
uint8_t mslot = 0, pslot = 0; uint8_t module_id = 0, pool_id = 0;
if (!qdf_nbuf_is_dev_scratch_supported()) { if (!qdf_nbuf_is_dev_scratch_supported()) {
wbuff.initialized = false; wbuff.initialized = false;
return QDF_STATUS_E_NOSUPPORT; return QDF_STATUS_E_NOSUPPORT;
} }
for (mslot = 0; mslot < WBUFF_MAX_MODULES; mslot++) { for (module_id = 0; module_id < WBUFF_MAX_MODULES; module_id++) {
mod = &wbuff.mod[mslot]; mod = &wbuff.mod[module_id];
qdf_spinlock_create(&mod->lock); qdf_spinlock_create(&mod->lock);
for (pslot = 0; pslot < WBUFF_MAX_POOLS; pslot++) for (pool_id = 0; pool_id < WBUFF_MAX_POOLS; pool_id++)
mod->pool[pslot] = NULL; mod->pool[pool_id] = NULL;
mod->registered = false; mod->registered = false;
} }
wbuff.initialized = true; wbuff.initialized = true;
@@ -195,14 +195,14 @@ QDF_STATUS wbuff_module_init(void)
QDF_STATUS wbuff_module_deinit(void) QDF_STATUS wbuff_module_deinit(void)
{ {
struct wbuff_module *mod = NULL; struct wbuff_module *mod = NULL;
uint8_t mslot = 0; uint8_t module_id = 0;
if (!wbuff.initialized) if (!wbuff.initialized)
return QDF_STATUS_E_INVAL; return QDF_STATUS_E_INVAL;
wbuff.initialized = false; wbuff.initialized = false;
for (mslot = 0; mslot < WBUFF_MAX_MODULES; mslot++) { for (module_id = 0; module_id < WBUFF_MAX_MODULES; module_id++) {
mod = &wbuff.mod[mslot]; mod = &wbuff.mod[module_id];
if (mod->registered) if (mod->registered)
wbuff_module_deregister((struct wbuff_mod_handle *) wbuff_module_deregister((struct wbuff_mod_handle *)
&mod->handle); &mod->handle);
@@ -220,7 +220,7 @@ wbuff_module_register(struct wbuff_alloc_request *req, uint8_t num,
qdf_nbuf_t buf = NULL; qdf_nbuf_t buf = NULL;
uint32_t len = 0; uint32_t len = 0;
uint16_t idx = 0, psize = 0; uint16_t idx = 0, psize = 0;
uint8_t alloc = 0, mslot = 0, pslot = 0; uint8_t alloc = 0, module_id = 0, pool_id = 0;
if (!wbuff.initialized) if (!wbuff.initialized)
return NULL; return NULL;
@@ -231,33 +231,33 @@ wbuff_module_register(struct wbuff_alloc_request *req, uint8_t num,
if (!wbuff_is_valid_alloc_req(req, num)) if (!wbuff_is_valid_alloc_req(req, num))
return NULL; return NULL;
mslot = wbuff_get_free_mod_slot(); module_id = wbuff_get_free_mod_slot();
if (mslot == WBUFF_MAX_MODULES) if (module_id == WBUFF_MAX_MODULES)
return NULL; return NULL;
mod = &wbuff.mod[mslot]; mod = &wbuff.mod[module_id];
mod->handle.id = mslot; mod->handle.id = module_id;
for (alloc = 0; alloc < num; alloc++) { for (alloc = 0; alloc < num; alloc++) {
pslot = req[alloc].slot; pool_id = req[alloc].slot;
psize = req[alloc].size; psize = req[alloc].size;
len = wbuff_get_len_from_pool_slot(pslot); len = wbuff_get_len_from_pool_slot(pool_id);
/** /**
* Allocate pool_cnt number of buffers for * Allocate pool_cnt number of buffers for
* the pool given by pslot * the pool given by pool_id
*/ */
for (idx = 0; idx < psize; idx++) { for (idx = 0; idx < psize; idx++) {
buf = wbuff_prepare_nbuf(mslot, pslot, len, reserve, buf = wbuff_prepare_nbuf(module_id, pool_id, len,
align); reserve, align);
if (!buf) if (!buf)
continue; continue;
if (!mod->pool[pslot]) { if (!mod->pool[pool_id]) {
qdf_nbuf_set_next(buf, NULL); qdf_nbuf_set_next(buf, NULL);
mod->pool[pslot] = buf; mod->pool[pool_id] = buf;
} else { } else {
qdf_nbuf_set_next(buf, mod->pool[pslot]); qdf_nbuf_set_next(buf, mod->pool[pool_id]);
mod->pool[pslot] = buf; mod->pool[pool_id] = buf;
} }
} }
} }
@@ -271,7 +271,7 @@ QDF_STATUS wbuff_module_deregister(struct wbuff_mod_handle *hdl)
{ {
struct wbuff_handle *handle; struct wbuff_handle *handle;
struct wbuff_module *mod = NULL; struct wbuff_module *mod = NULL;
uint8_t mslot = 0, pslot = 0; uint8_t module_id = 0, pool_id = 0;
qdf_nbuf_t first = NULL, buf = NULL; qdf_nbuf_t first = NULL, buf = NULL;
handle = (struct wbuff_handle *)hdl; handle = (struct wbuff_handle *)hdl;
@@ -279,12 +279,12 @@ QDF_STATUS wbuff_module_deregister(struct wbuff_mod_handle *hdl)
if ((!wbuff.initialized) || (!wbuff_is_valid_handle(handle))) if ((!wbuff.initialized) || (!wbuff_is_valid_handle(handle)))
return QDF_STATUS_E_INVAL; return QDF_STATUS_E_INVAL;
mslot = handle->id; module_id = handle->id;
mod = &wbuff.mod[mslot]; mod = &wbuff.mod[module_id];
qdf_spin_lock_bh(&mod->lock); qdf_spin_lock_bh(&mod->lock);
for (pslot = 0; pslot < WBUFF_MAX_POOLS; pslot++) { for (pool_id = 0; pool_id < WBUFF_MAX_POOLS; pool_id++) {
first = mod->pool[pslot]; first = mod->pool[pool_id];
while (first) { while (first) {
buf = first; buf = first;
first = qdf_nbuf_next(buf); first = qdf_nbuf_next(buf);
@@ -302,8 +302,8 @@ qdf_nbuf_t wbuff_buff_get(struct wbuff_mod_handle *hdl, uint32_t len,
{ {
struct wbuff_handle *handle; struct wbuff_handle *handle;
struct wbuff_module *mod = NULL; struct wbuff_module *mod = NULL;
uint8_t mslot = 0; uint8_t module_id = 0;
uint8_t pslot = 0; uint8_t pool_id = 0;
qdf_nbuf_t buf = NULL; qdf_nbuf_t buf = NULL;
handle = (struct wbuff_handle *)hdl; handle = (struct wbuff_handle *)hdl;
@@ -312,14 +312,14 @@ qdf_nbuf_t wbuff_buff_get(struct wbuff_mod_handle *hdl, uint32_t len,
(len > WBUFF_MAX_BUFFER_SIZE)) (len > WBUFF_MAX_BUFFER_SIZE))
return NULL; return NULL;
mslot = handle->id; module_id = handle->id;
pslot = wbuff_get_pool_slot_from_len(len); pool_id = wbuff_get_pool_slot_from_len(len);
mod = &wbuff.mod[mslot]; mod = &wbuff.mod[module_id];
qdf_spin_lock_bh(&mod->lock); qdf_spin_lock_bh(&mod->lock);
if (mod->pool[pslot]) { if (mod->pool[pool_id]) {
buf = mod->pool[pslot]; buf = mod->pool[pool_id];
mod->pool[pslot] = qdf_nbuf_next(buf); mod->pool[pool_id] = qdf_nbuf_next(buf);
mod->pending_returns++; mod->pending_returns++;
} }
qdf_spin_unlock_bh(&mod->lock); qdf_spin_unlock_bh(&mod->lock);
@@ -334,32 +334,34 @@ qdf_nbuf_t wbuff_buff_get(struct wbuff_mod_handle *hdl, uint32_t len,
qdf_nbuf_t wbuff_buff_put(qdf_nbuf_t buf) qdf_nbuf_t wbuff_buff_put(qdf_nbuf_t buf)
{ {
qdf_nbuf_t buffer = buf; qdf_nbuf_t buffer = buf;
unsigned long slot_info = 0; unsigned long pool_info = 0;
uint8_t mslot = 0, pslot = 0; uint8_t module_id = 0, pool_id = 0;
if (!wbuff.initialized) if (!wbuff.initialized)
return buffer; return buffer;
slot_info = qdf_nbuf_get_dev_scratch(buf); pool_info = qdf_nbuf_get_dev_scratch(buf);
if (!slot_info) if (!pool_info)
return buffer; return buffer;
mslot = (slot_info & WBUFF_MSLOT_BITMASK) >> WBUFF_MSLOT_SHIFT; module_id = (pool_info & WBUFF_MODULE_ID_BITMASK) >>
pslot = (slot_info & WBUFF_PSLOT_BITMASK) >> WBUFF_PSLOT_SHIFT; WBUFF_MODULE_ID_SHIFT;
pool_id = (pool_info & WBUFF_POOL_ID_BITMASK) >> WBUFF_POOL_ID_SHIFT;
if (mslot >= WBUFF_MAX_MODULES || pslot >= WBUFF_MAX_POOLS) if (module_id >= WBUFF_MAX_MODULES || pool_id >= WBUFF_MAX_POOLS)
return NULL; return NULL;
qdf_nbuf_reset(buffer, wbuff.mod[mslot].reserve, wbuff.mod[mslot]. qdf_nbuf_reset(buffer, wbuff.mod[module_id].reserve,
align); wbuff.mod[module_id].align);
qdf_spin_lock_bh(&wbuff.mod[mslot].lock);
if (wbuff.mod[mslot].registered) { qdf_spin_lock_bh(&wbuff.mod[module_id].lock);
qdf_nbuf_set_next(buffer, wbuff.mod[mslot].pool[pslot]); if (wbuff.mod[module_id].registered) {
wbuff.mod[mslot].pool[pslot] = buffer; qdf_nbuf_set_next(buffer, wbuff.mod[module_id].pool[pool_id]);
wbuff.mod[mslot].pending_returns--; wbuff.mod[module_id].pool[pool_id] = buffer;
wbuff.mod[module_id].pending_returns--;
buffer = NULL; buffer = NULL;
} }
qdf_spin_unlock_bh(&wbuff.mod[mslot].lock); qdf_spin_unlock_bh(&wbuff.mod[module_id].lock);
return buffer; return buffer;
} }