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

Merge "qcacmn: Use multi-page alloc for tso descs"

Browse source
This commit is contained in:
Linux Build Service Account 2018-09-03 10:03:23 -07:00 • committed by Gerrit - the friendly Code Review server
commit d4b28882ec
8 changed files with 116 additions and 147 deletions
Download patch file Download diff file Expand all files Collapse all files

26
dp/inc/cdp_txrx_mob_def.h
View file

@ -198,16 +198,28 @@ enum ol_tx_spec {
* @PEER_DEBUG_ID_LIM_SEND_ADDBA_RESP: debug id for send ADDBA response
* @PEER_DEBUG_ID_OL_RX_THREAD: debug id for rx thread
* @PEER_DEBUG_ID_WMA_CCMP_REPLAY_ATTACK: debug id for CCMP replay
* @PEER_DEBUG_ID_WMA_DEL_BSS:debug id for remove BSS
* @PEER_DEBUG_ID_WMA_VDEV_STOP_RESP:debug id for vdev stop response handler
* @PEER_DEBUG_ID_OL_PEER_MAP:debug id for peer map/unmap
* @PEER_DEBUG_ID_OL_PEER_ATTACH: debug id for peer attach/detach
* @PEER_DEBUG_ID_OL_TXQ_VDEV_FL: debug id for vdev flush
* @PEER_DEBUG_ID_OL_HASH_ERS:debug id for peer find hash erase
* @PEER_DEBUG_ID_MAX: debug id MAX
*/
enum peer_debug_id_type {
PEER_DEBUG_ID_OL_INTERNAL = 0,
PEER_DEBUG_ID_WMA_PKT_DROP = 1,
PEER_DEBUG_ID_WMA_ADDBA_REQ = 2,
PEER_DEBUG_ID_WMA_DELBA_REQ = 3,
PEER_DEBUG_ID_LIM_SEND_ADDBA_RESP = 4,
PEER_DEBUG_ID_OL_RX_THREAD = 5,
PEER_DEBUG_ID_WMA_CCMP_REPLAY_ATTACK = 6,
PEER_DEBUG_ID_OL_INTERNAL,
PEER_DEBUG_ID_WMA_PKT_DROP,
PEER_DEBUG_ID_WMA_ADDBA_REQ,
PEER_DEBUG_ID_WMA_DELBA_REQ,
PEER_DEBUG_ID_LIM_SEND_ADDBA_RESP,
PEER_DEBUG_ID_OL_RX_THREAD,
PEER_DEBUG_ID_WMA_CCMP_REPLAY_ATTACK,
PEER_DEBUG_ID_WMA_DEL_BSS,
PEER_DEBUG_ID_WMA_VDEV_STOP_RESP,
PEER_DEBUG_ID_OL_PEER_MAP,
PEER_DEBUG_ID_OL_PEER_ATTACH,
PEER_DEBUG_ID_OL_TXQ_VDEV_FL,
PEER_DEBUG_ID_OL_HASH_ERS,
PEER_DEBUG_ID_MAX
};

188
dp/wifi3.0/dp_tx_desc.c
View file

@ -323,53 +323,46 @@ QDF_STATUS dp_tx_ext_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
QDF_STATUS dp_tx_tso_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
uint16_t num_elem)
{
int i;
struct qdf_tso_seg_elem_t *c_element;
struct qdf_tso_seg_elem_t *temp;
struct dp_tx_tso_seg_pool_s *tso_desc_pool;
uint32_t desc_size;
soc->tx_tso_desc[pool_id].num_free = 0;
c_element = qdf_mem_malloc(sizeof(struct qdf_tso_seg_elem_t));
tso_desc_pool = &soc->tx_tso_desc[pool_id];
tso_desc_pool->num_free = 0;
desc_size = DP_TX_DESC_SIZE(sizeof(struct qdf_tso_seg_elem_t));
qdf_mem_multi_pages_alloc(soc->osdev,
&tso_desc_pool->desc_pages,
desc_size,
num_elem, 0, true);
if (!c_element) {
if (!tso_desc_pool->desc_pages.num_pages) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
FL("Alloc Failed %pK pool_id %d"),
soc, pool_id);
return QDF_STATUS_E_NOMEM;
}
soc->tx_tso_desc[pool_id].freelist = c_element;
soc->tx_tso_desc[pool_id].num_free++;
for (i = 0; i < (num_elem - 1); i++) {
c_element->next =
qdf_mem_malloc(sizeof(struct qdf_tso_seg_elem_t));
if (!c_element->next) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
FL("Alloc Failed %pK pool_id %d"),
soc, pool_id);
goto fail;
}
soc->tx_tso_desc[pool_id].num_free++;
c_element = c_element->next;
c_element->next = NULL;
tso_desc_pool->freelist = (struct qdf_tso_seg_elem_t *)
*tso_desc_pool->desc_pages.cacheable_pages;
tso_desc_pool->num_free = num_elem;
if (qdf_mem_multi_page_link(soc->osdev,
&tso_desc_pool->desc_pages,
desc_size,
num_elem, true)) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"invalid tso desc allocation - overflow num link");
goto free_tso_desc;
}
TSO_DEBUG("Number of free descriptors: %u\n",
soc->tx_tso_desc[pool_id].num_free);
soc->tx_tso_desc[pool_id].pool_size = num_elem;
qdf_spinlock_create(&soc->tx_tso_desc[pool_id].lock);
TSO_DEBUG("Number of free descriptors: %u\n", tso_desc_pool->num_free);
tso_desc_pool->pool_size = num_elem;
qdf_spinlock_create(&tso_desc_pool->lock);
return QDF_STATUS_SUCCESS;
fail:
c_element = soc->tx_tso_desc[pool_id].freelist;
while (c_element) {
temp = c_element->next;
qdf_mem_free(c_element);
c_element = temp;
}
free_tso_desc:
qdf_mem_multi_pages_free(soc->osdev,
&tso_desc_pool->desc_pages, 0, true);
return QDF_STATUS_E_NOMEM;
return QDF_STATUS_E_FAULT;
}
/**
@ -381,33 +374,19 @@ fail:
*/
void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
{
int i;
struct qdf_tso_seg_elem_t *c_element;
struct qdf_tso_seg_elem_t *temp;
struct dp_tx_tso_seg_pool_s *tso_desc_pool;
qdf_spin_lock_bh(&soc->tx_tso_desc[pool_id].lock);
c_element = soc->tx_tso_desc[pool_id].freelist;
tso_desc_pool = &soc->tx_tso_desc[pool_id];
if (!c_element) {
qdf_spin_unlock_bh(&soc->tx_tso_desc[pool_id].lock);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("Desc Pool Corrupt %d"), pool_id);
return;
}
qdf_spin_lock_bh(&tso_desc_pool->lock);
for (i = 0; i < soc->tx_tso_desc[pool_id].pool_size; i++) {
temp = c_element->next;
qdf_mem_free(c_element);
c_element = temp;
if (!c_element)
break;
}
soc->tx_tso_desc[pool_id].freelist = NULL;
soc->tx_tso_desc[pool_id].num_free = 0;
soc->tx_tso_desc[pool_id].pool_size = 0;
qdf_spin_unlock_bh(&soc->tx_tso_desc[pool_id].lock);
qdf_spinlock_destroy(&soc->tx_tso_desc[pool_id].lock);
qdf_mem_multi_pages_free(soc->osdev,
&tso_desc_pool->desc_pages, 0, true);
tso_desc_pool->freelist = NULL;
tso_desc_pool->num_free = 0;
tso_desc_pool->pool_size = 0;
qdf_spin_unlock_bh(&tso_desc_pool->lock);
qdf_spinlock_destroy(&tso_desc_pool->lock);
return;
}
/**
@ -421,51 +400,45 @@ void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
QDF_STATUS dp_tx_tso_num_seg_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
uint16_t num_elem)
{
struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
uint32_t desc_size;
int i;
struct qdf_tso_num_seg_elem_t *c_element;
struct qdf_tso_num_seg_elem_t *temp;
soc->tx_tso_num_seg[pool_id].num_free = 0;
c_element = qdf_mem_malloc(sizeof(struct qdf_tso_num_seg_elem_t));
if (!c_element) {
tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
tso_num_seg_pool->num_free = 0;
desc_size = DP_TX_DESC_SIZE(sizeof(struct qdf_tso_num_seg_elem_t));
qdf_mem_multi_pages_alloc(soc->osdev,
&tso_num_seg_pool->desc_pages,
desc_size,
num_elem, 0, true);
if (!tso_num_seg_pool->desc_pages.num_pages) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
FL("Alloc Failed %pK pool_id %d"),
soc, pool_id);
return QDF_STATUS_E_NOMEM;
}
soc->tx_tso_num_seg[pool_id].freelist = c_element;
soc->tx_tso_num_seg[pool_id].num_free++;
for (i = 0; i < (num_elem - 1); i++) {
c_element->next =
qdf_mem_malloc(sizeof(struct qdf_tso_num_seg_elem_t));
if (!c_element->next) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
FL("Alloc Failed %pK pool_id %d"),
soc, pool_id);
goto fail;
}
soc->tx_tso_num_seg[pool_id].num_free++;
c_element = c_element->next;
c_element->next = NULL;
if (qdf_mem_multi_page_link(soc->osdev,
&tso_num_seg_pool->desc_pages,
desc_size,
num_elem, true)) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"invalid tso desc allocation - overflow num link");
goto fail;
}
soc->tx_tso_num_seg[pool_id].num_seg_pool_size = num_elem;
qdf_spinlock_create(&soc->tx_tso_num_seg[pool_id].lock);
tso_num_seg_pool->freelist = (struct qdf_tso_num_seg_elem_t *)
*tso_num_seg_pool->desc_pages.cacheable_pages;
tso_num_seg_pool->num_free = num_elem;
tso_num_seg_pool->num_seg_pool_size = num_elem;
qdf_spinlock_create(&tso_num_seg_pool->lock);
return QDF_STATUS_SUCCESS;
fail:
c_element = soc->tx_tso_num_seg[pool_id].freelist;
while (c_element) {
temp = c_element->next;
qdf_mem_free(c_element);
c_element = temp;
}
qdf_mem_multi_pages_free(soc->osdev,
&tso_num_seg_pool->desc_pages, 0, true);
return QDF_STATUS_E_NOMEM;
}
@ -479,33 +452,18 @@ fail:
*/
void dp_tx_tso_num_seg_pool_free(struct dp_soc *soc, uint8_t pool_id)
{
int i;
struct qdf_tso_num_seg_elem_t *c_element;
struct qdf_tso_num_seg_elem_t *temp;
struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
qdf_spin_lock_bh(&soc->tx_tso_num_seg[pool_id].lock);
c_element = soc->tx_tso_num_seg[pool_id].freelist;
tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
qdf_spin_lock_bh(&tso_num_seg_pool->lock);
if (!c_element) {
qdf_spin_unlock_bh(&soc->tx_tso_num_seg[pool_id].lock);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("Desc Pool Corrupt %d"), pool_id);
return;
}
for (i = 0; i < soc->tx_tso_num_seg[pool_id].num_seg_pool_size; i++) {
temp = c_element->next;
qdf_mem_free(c_element);
c_element = temp;
if (!c_element)
break;
}
soc->tx_tso_num_seg[pool_id].freelist = NULL;
soc->tx_tso_num_seg[pool_id].num_free = 0;
soc->tx_tso_num_seg[pool_id].num_seg_pool_size = 0;
qdf_spin_unlock_bh(&soc->tx_tso_num_seg[pool_id].lock);
qdf_spinlock_destroy(&soc->tx_tso_num_seg[pool_id].lock);
qdf_mem_multi_pages_free(soc->osdev,
&tso_num_seg_pool->desc_pages, 0, true);
tso_num_seg_pool->freelist = NULL;
tso_num_seg_pool->num_free = 0;
tso_num_seg_pool->num_seg_pool_size = 0;
qdf_spin_unlock_bh(&tso_num_seg_pool->lock);
qdf_spinlock_destroy(&tso_num_seg_pool->lock);
return;
}

4
dp/wifi3.0/dp_types.h
View file

@ -323,12 +323,14 @@ enum flow_pool_status {
* @pool_size: total number of pool elements
* @num_free: free element count
* @freelist: first free element pointer
* @desc_pages: multiple page allocation information for actual descriptors
* @lock: lock for accessing the pool
*/
struct dp_tx_tso_seg_pool_s {
uint16_t pool_size;
uint16_t num_free;
struct qdf_tso_seg_elem_t *freelist;
struct qdf_mem_multi_page_t desc_pages;
qdf_spinlock_t lock;
};
@ -337,6 +339,7 @@ struct dp_tx_tso_seg_pool_s {
* @num_seg_pool_size: total number of pool elements
* @num_free: free element count
* @freelist: first free element pointer
* @desc_pages: multiple page allocation information for actual descriptors
* @lock: lock for accessing the pool
*/
@ -344,6 +347,7 @@ struct dp_tx_tso_num_seg_pool_s {
uint16_t num_seg_pool_size;
uint16_t num_free;
struct qdf_tso_num_seg_elem_t *freelist;
struct qdf_mem_multi_page_t desc_pages;
/*tso mutex */
qdf_spinlock_t lock;
};

8
qdf/inc/qdf_types.h
View file

@ -1005,16 +1005,16 @@ struct qdf_tso_seg_dbg_t {
/**
* qdf_tso_seg_elem_t - tso segment element
* @seg: instance of segment
* @next: pointer to the next segment
* @seg: instance of segment
*/
struct qdf_tso_seg_elem_t {
struct qdf_tso_seg_elem_t *next;
struct qdf_tso_seg_t seg;
uint32_t cookie:13,
on_freelist:1,
sent_to_target:1,
force_free:1;
struct qdf_tso_seg_elem_t *next;
#ifdef TSOSEG_DEBUG
struct qdf_tso_seg_dbg_t dbg;
#endif /* TSOSEG_DEBUG */
@ -1033,12 +1033,12 @@ struct qdf_tso_num_seg_t {
/**
* qdf_tso_num_seg_elem_t - num of tso segment element for jumbo skb
* @num_seg: instance of num of seg
* @next: pointer to the next segment
* @num_seg: instance of num of seg
*/
struct qdf_tso_num_seg_elem_t {
struct qdf_tso_num_seg_t num_seg;
struct qdf_tso_num_seg_elem_t *next;
struct qdf_tso_num_seg_t num_seg;
};
/**

2
umac/cmn_services/cmn_defs/inc/wlan_cmn_ieee80211.h
View file

@ -446,7 +446,7 @@ struct wlan_rsn_ie_hdr {
u8 version[2];
};
#define WLAN_RSN_IE_MIN_LEN 3
#define WLAN_RSN_IE_MIN_LEN 2
/**
* struct wlan_rsn_ie: rsn ie info

3
utils/logging/inc/wlan_roam_debug.h
View file

@ -22,6 +22,9 @@
#define _WLAN_ROAM_DEBUG_H_
#define roam_debug(args ...) \
QDF_TRACE_DEBUG(QDF_MODULE_ID_ROAM_DEBUG, ## args)
/**
* struct wlan_roam_debug_rec - roam debug information record definition
* @time: timestamp when record was added

31
utils/logging/src/wlan_roam_debug.c
View file

@ -220,13 +220,10 @@ void wlan_roam_debug_dump_table(void)
current_index = qdf_atomic_read(&dbg_tbl->index);
if (current_index < 0) {
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"%s: No records to dump", __func__);
roam_debug("No records to dump");
return;
}
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"%s: Dumping all records. current index %d",
__func__, current_index);
roam_debug("Dumping all records. current index %d", current_index);
i = current_index;
do {
@ -248,23 +245,17 @@ void wlan_roam_debug_dump_table(void)
0xffffffff);
delta = delta / (DEBUG_CLOCK_TICKS_PER_MSEC >> 8);
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"index = %5d timestamp = 0x%016llx delta ms = %-12u",
i, dbg_rec->time, delta);
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"info = %-24s vdev_id = %-3d mac addr = %pM",
wlan_roam_debug_string(dbg_rec->operation),
(int8_t) dbg_rec->vdev_id, dbg_rec->mac_addr.bytes);
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"peer obj = 0x%pK peer_id = %-4d",
dbg_rec->peer_obj, (int8_t) dbg_rec->peer_id);
QDF_TRACE(QDF_MODULE_ID_ROAM_DEBUG, QDF_TRACE_LEVEL_ERROR,
"arg1 = 0x%-8x arg2 = 0x%-8x",
dbg_rec->arg1, dbg_rec->arg2);
roam_debug("index = %5d timestamp = 0x%016llx delta ms = %-12u",
i, dbg_rec->time, delta);
roam_debug("info = %-24s vdev_id = %-3d mac addr = %pM",
wlan_roam_debug_string(dbg_rec->operation),
(int8_t)dbg_rec->vdev_id, dbg_rec->mac_addr.bytes);
roam_debug("peer obj = 0x%pK peer_id = %-4d", dbg_rec->peer_obj,
(int8_t)dbg_rec->peer_id);
roam_debug("arg1 = 0x%-8x arg2 = 0x%-8x", dbg_rec->arg1,
dbg_rec->arg2);
} while (i != current_index);
}
qdf_export_symbol(wlan_roam_debug_dump_table);
#endif /* FEATURE_ROAM_DEBUG */

1
wmi/src/wmi_unified_non_tlv.c
View file

@ -8402,6 +8402,7 @@ static QDF_STATUS extract_tx_data_traffic_ctrl_ev_non_tlv(
ev->peer_ast_idx = evt->peer_ast_idx;
ev->vdev_id = evt->vdev_id;
ev->ctrl_cmd = evt->ctrl_cmd;
ev->wmm_ac = evt->wmm_ac;
return QDF_STATUS_SUCCESS;
}