|
|
@@ -1,5 +1,5 @@
|
|
|
/*
|
|
|
- * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
|
|
|
+ * Copyright (c) 2016-2020 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
|
|
|
@@ -65,7 +65,7 @@ dp_tx_desc_pool_counter_initialize(struct dp_tx_desc_pool_s *tx_desc_pool,
|
|
|
/**
|
|
|
* dp_tx_desc_pool_alloc() - Allocate Tx Descriptor pool(s)
|
|
|
* @soc Handle to DP SoC structure
|
|
|
- * @num_pool Number of pools to allocate
|
|
|
+ * @pool_id pool to allocate
|
|
|
* @num_elem Number of descriptor elements per pool
|
|
|
*
|
|
|
* This function allocates memory for SW tx descriptors
|
|
|
@@ -91,42 +91,77 @@ dp_tx_desc_pool_counter_initialize(struct dp_tx_desc_pool_s *tx_desc_pool,
|
|
|
* Return: Status code. 0 for success.
|
|
|
*/
|
|
|
QDF_STATUS dp_tx_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
- uint32_t id, count, page_id, offset, pool_id_32;
|
|
|
- uint16_t num_desc_per_page;
|
|
|
- struct dp_tx_desc_s *tx_desc_elem;
|
|
|
uint32_t desc_size;
|
|
|
- struct dp_tx_desc_pool_s *tx_desc_pool = &((soc)->tx_desc[(pool_id)]);
|
|
|
+ struct dp_tx_desc_pool_s *tx_desc_pool;
|
|
|
+
|
|
|
+ desc_size = DP_TX_DESC_SIZE(sizeof(struct dp_tx_desc_s));
|
|
|
+ tx_desc_pool = &((soc)->tx_desc[(pool_id)]);
|
|
|
+ qdf_mem_multi_pages_alloc(soc->osdev,
|
|
|
+ &tx_desc_pool->desc_pages,
|
|
|
+ desc_size, num_elem,
|
|
|
+ 0, true);
|
|
|
|
|
|
- desc_size = DP_TX_DESC_SIZE(sizeof(*tx_desc_elem));
|
|
|
- tx_desc_pool->elem_size = desc_size;
|
|
|
- if (!dp_is_soc_reinit(soc))
|
|
|
- qdf_mem_multi_pages_alloc(soc->osdev,
|
|
|
- &tx_desc_pool->desc_pages,
|
|
|
- desc_size, num_elem,
|
|
|
- 0, true);
|
|
|
if (!tx_desc_pool->desc_pages.num_pages) {
|
|
|
dp_err("Multi page alloc fail, tx desc");
|
|
|
- goto fail_exit;
|
|
|
+ return QDF_STATUS_E_NOMEM;
|
|
|
}
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_desc_pool_free() - Free the tx dexcriptor pools
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @pool_id: pool to free
|
|
|
+ *
|
|
|
+ */
|
|
|
+void dp_tx_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+{
|
|
|
+ struct dp_tx_desc_pool_s *tx_desc_pool;
|
|
|
|
|
|
+ tx_desc_pool = &((soc)->tx_desc[pool_id]);
|
|
|
|
|
|
- num_desc_per_page =
|
|
|
- tx_desc_pool->desc_pages.num_element_per_page;
|
|
|
- tx_desc_pool->freelist = (struct dp_tx_desc_s *)
|
|
|
- *tx_desc_pool->desc_pages.cacheable_pages;
|
|
|
+ if (tx_desc_pool->desc_pages.num_pages)
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &tx_desc_pool->desc_pages, 0, true);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_desc_pool_init() - Initialize Tx Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @pool_id: pool to allocate
|
|
|
+ * @num_elem: Number of descriptor elements per pool
|
|
|
+ *
|
|
|
+ * Return: QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_FAULT
|
|
|
+ */
|
|
|
+QDF_STATUS dp_tx_desc_pool_init(struct dp_soc *soc, uint8_t pool_id,
|
|
|
+ uint16_t num_elem)
|
|
|
+{
|
|
|
+ uint32_t id, count, page_id, offset, pool_id_32;
|
|
|
+ struct dp_tx_desc_pool_s *tx_desc_pool;
|
|
|
+ struct dp_tx_desc_s *tx_desc_elem;
|
|
|
+ uint16_t num_desc_per_page;
|
|
|
+ uint32_t desc_size;
|
|
|
+
|
|
|
+ desc_size = DP_TX_DESC_SIZE(sizeof(*tx_desc_elem));
|
|
|
+
|
|
|
+ tx_desc_pool = &((soc)->tx_desc[(pool_id)]);
|
|
|
if (qdf_mem_multi_page_link(soc->osdev,
|
|
|
&tx_desc_pool->desc_pages,
|
|
|
desc_size, num_elem, true)) {
|
|
|
- dp_err("invalid tx desc allocation - overflow num link");
|
|
|
- goto free_tx_desc;
|
|
|
+ dp_err("invalid tx desc allocation -overflow num link");
|
|
|
+ return QDF_STATUS_E_FAULT;
|
|
|
}
|
|
|
|
|
|
+ tx_desc_pool->freelist = (struct dp_tx_desc_s *)
|
|
|
+ *tx_desc_pool->desc_pages.cacheable_pages;
|
|
|
/* Set unique IDs for each Tx descriptor */
|
|
|
tx_desc_elem = tx_desc_pool->freelist;
|
|
|
count = 0;
|
|
|
pool_id_32 = (uint32_t)pool_id;
|
|
|
+ num_desc_per_page = tx_desc_pool->desc_pages.num_element_per_page;
|
|
|
while (tx_desc_elem) {
|
|
|
page_id = count / num_desc_per_page;
|
|
|
offset = count % num_desc_per_page;
|
|
|
@@ -139,365 +174,532 @@ QDF_STATUS dp_tx_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
+ tx_desc_pool->elem_size = DP_TX_DESC_SIZE(sizeof(*tx_desc_elem));
|
|
|
+
|
|
|
dp_tx_desc_pool_counter_initialize(tx_desc_pool, num_elem);
|
|
|
TX_DESC_LOCK_CREATE(&tx_desc_pool->lock);
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
-
|
|
|
-free_tx_desc:
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &tx_desc_pool->desc_pages, 0, true);
|
|
|
|
|
|
-fail_exit:
|
|
|
- return QDF_STATUS_E_FAULT;
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_desc_pool_free() - Free the memory pool allocated for Tx Descriptors
|
|
|
- *
|
|
|
+ * dp_tx_desc_pool_deinit() - de-initialize Tx Descriptor pool(s)
|
|
|
* @soc Handle to DP SoC structure
|
|
|
- * @pool_id
|
|
|
+ * @pool_id: pool to de-initialize
|
|
|
*
|
|
|
- * Return:
|
|
|
*/
|
|
|
-QDF_STATUS dp_tx_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+void dp_tx_desc_pool_deinit(struct dp_soc *soc, uint8_t pool_id)
|
|
|
{
|
|
|
- struct dp_tx_desc_pool_s *tx_desc_pool =
|
|
|
- &((soc)->tx_desc[(pool_id)]);
|
|
|
+ struct dp_tx_desc_pool_s *tx_desc_pool;
|
|
|
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &tx_desc_pool->desc_pages, 0, true);
|
|
|
- TX_DESC_LOCK_DESTROY(&tx_desc_pool->lock);
|
|
|
+ tx_desc_pool = &((soc)->tx_desc[(pool_id)]);
|
|
|
TX_DESC_POOL_MEMBER_CLEAN(tx_desc_pool);
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
+ TX_DESC_LOCK_DESTROY(&tx_desc_pool->lock);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_ext_desc_pool_alloc() - Allocate tx ext descriptor pool
|
|
|
- * @soc Handle to DP SoC structure
|
|
|
- * @pool_id
|
|
|
+ * dp_tx_ext_desc_pool_alloc() - allocate Tx extenstion Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @num_pool: Number of pools to allocate
|
|
|
+ * @num_elem: Number of descriptor elements per pool
|
|
|
*
|
|
|
- * Return: NONE
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_NOMEM
|
|
|
*/
|
|
|
-QDF_STATUS dp_tx_ext_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+QDF_STATUS dp_tx_ext_desc_pool_alloc(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
- uint16_t num_page;
|
|
|
- uint32_t count;
|
|
|
- struct dp_tx_ext_desc_elem_s *c_elem, *p_elem;
|
|
|
- struct qdf_mem_dma_page_t *page_info;
|
|
|
- struct qdf_mem_multi_page_t *pages;
|
|
|
- QDF_STATUS status;
|
|
|
+ QDF_STATUS status = QDF_STATUS_SUCCESS;
|
|
|
qdf_dma_context_t memctx = 0;
|
|
|
+ uint8_t pool_id, count;
|
|
|
+ uint16_t elem_size = HAL_TX_EXT_DESC_WITH_META_DATA;
|
|
|
+ struct dp_tx_ext_desc_pool_s *dp_tx_ext_desc_pool;
|
|
|
+ uint16_t link_elem_size = sizeof(struct dp_tx_ext_desc_elem_s);
|
|
|
|
|
|
/* Coherent tx extension descriptor alloc */
|
|
|
- soc->tx_ext_desc[pool_id].elem_size = HAL_TX_EXT_DESC_WITH_META_DATA;
|
|
|
- soc->tx_ext_desc[pool_id].elem_count = num_elem;
|
|
|
- memctx = qdf_get_dma_mem_context((&soc->tx_ext_desc[pool_id]), memctx);
|
|
|
- if (!dp_is_soc_reinit(soc)) {
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ memctx = qdf_get_dma_mem_context(dp_tx_ext_desc_pool, memctx);
|
|
|
qdf_mem_multi_pages_alloc(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].
|
|
|
- desc_pages,
|
|
|
- soc->tx_ext_desc[pool_id].elem_size,
|
|
|
- soc->tx_ext_desc[pool_id].elem_count,
|
|
|
+ &dp_tx_ext_desc_pool->desc_pages,
|
|
|
+ elem_size,
|
|
|
+ num_elem,
|
|
|
memctx, false);
|
|
|
- }
|
|
|
- if (!soc->tx_ext_desc[pool_id].desc_pages.num_pages) {
|
|
|
- QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
- "ext desc page alloc fail");
|
|
|
- status = QDF_STATUS_E_NOMEM;
|
|
|
- goto fail_exit;
|
|
|
+
|
|
|
+ if (!dp_tx_ext_desc_pool->desc_pages.num_pages) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "ext desc page alloc fail");
|
|
|
+ status = QDF_STATUS_E_NOMEM;
|
|
|
+ goto fail_exit;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- num_page = soc->tx_ext_desc[pool_id].desc_pages.num_pages;
|
|
|
/*
|
|
|
* Cacheable ext descriptor link alloc
|
|
|
* This structure also large size already
|
|
|
* single element is 24bytes, 2K elements are 48Kbytes
|
|
|
* Have to alloc multi page cacheable memory
|
|
|
*/
|
|
|
- soc->tx_ext_desc[pool_id].link_elem_size =
|
|
|
- sizeof(struct dp_tx_ext_desc_elem_s);
|
|
|
- if (!dp_is_soc_reinit(soc)) {
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
qdf_mem_multi_pages_alloc(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].
|
|
|
- desc_link_pages,
|
|
|
- soc->tx_ext_desc[pool_id].
|
|
|
+ &dp_tx_ext_desc_pool->desc_link_pages,
|
|
|
link_elem_size,
|
|
|
- soc->tx_ext_desc[pool_id].
|
|
|
- elem_count,
|
|
|
+ num_elem,
|
|
|
0, true);
|
|
|
+
|
|
|
+ if (!dp_tx_ext_desc_pool->desc_link_pages.num_pages) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "ext link desc page alloc fail");
|
|
|
+ status = QDF_STATUS_E_NOMEM;
|
|
|
+ goto free_ext_desc_page;
|
|
|
+ }
|
|
|
}
|
|
|
- if (!soc->tx_ext_desc[pool_id].desc_link_pages.num_pages) {
|
|
|
- QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
- "ext link desc page alloc fail");
|
|
|
- status = QDF_STATUS_E_NOMEM;
|
|
|
- goto free_ext_desc_page;
|
|
|
+ return status;
|
|
|
+
|
|
|
+free_ext_desc_page:
|
|
|
+ for (count = 0; count < pool_id; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &dp_tx_ext_desc_pool->desc_link_pages,
|
|
|
+ 0, true);
|
|
|
}
|
|
|
+ pool_id = num_pool;
|
|
|
|
|
|
- /* link tx descriptors into a freelist */
|
|
|
- soc->tx_ext_desc[pool_id].freelist = (struct dp_tx_ext_desc_elem_s *)
|
|
|
- *soc->tx_ext_desc[pool_id].desc_link_pages.cacheable_pages;
|
|
|
- if (qdf_mem_multi_page_link(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].desc_link_pages,
|
|
|
- soc->tx_ext_desc[pool_id].link_elem_size,
|
|
|
- soc->tx_ext_desc[pool_id].elem_count, true)) {
|
|
|
- QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
- "ext link desc page linking fail");
|
|
|
- status = QDF_STATUS_E_FAULT;
|
|
|
- goto free_ext_link_desc_page;
|
|
|
+fail_exit:
|
|
|
+ for (count = 0; count < pool_id; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ memctx = qdf_get_dma_mem_context(dp_tx_ext_desc_pool, memctx);
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &dp_tx_ext_desc_pool->desc_pages,
|
|
|
+ memctx, false);
|
|
|
}
|
|
|
+ return status;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_ext_desc_pool_init() - initialize Tx extenstion Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @num_pool: Number of pools to initialize
|
|
|
+ * @num_elem: Number of descriptor elements per pool
|
|
|
+ *
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_NOMEM
|
|
|
+ */
|
|
|
+QDF_STATUS dp_tx_ext_desc_pool_init(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
+{
|
|
|
+ uint32_t i;
|
|
|
+ struct dp_tx_ext_desc_elem_s *c_elem, *p_elem;
|
|
|
+ struct qdf_mem_dma_page_t *page_info;
|
|
|
+ struct qdf_mem_multi_page_t *pages;
|
|
|
+ struct dp_tx_ext_desc_pool_s *dp_tx_ext_desc_pool;
|
|
|
+ uint8_t pool_id;
|
|
|
+ QDF_STATUS status;
|
|
|
|
|
|
- /* Assign coherent memory pointer into linked free list */
|
|
|
- pages = &soc->tx_ext_desc[pool_id].desc_pages;
|
|
|
- page_info = soc->tx_ext_desc[pool_id].desc_pages.dma_pages;
|
|
|
- c_elem = soc->tx_ext_desc[pool_id].freelist;
|
|
|
- p_elem = c_elem;
|
|
|
- for (count = 0; count < soc->tx_ext_desc[pool_id].elem_count; count++) {
|
|
|
- if (!(count % pages->num_element_per_page)) {
|
|
|
+ /* link tx descriptors into a freelist */
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ soc->tx_ext_desc[pool_id].elem_size =
|
|
|
+ HAL_TX_EXT_DESC_WITH_META_DATA;
|
|
|
+ soc->tx_ext_desc[pool_id].link_elem_size =
|
|
|
+ sizeof(struct dp_tx_ext_desc_elem_s);
|
|
|
+ soc->tx_ext_desc[pool_id].elem_count = num_elem;
|
|
|
+
|
|
|
+ dp_tx_ext_desc_pool->freelist = (struct dp_tx_ext_desc_elem_s *)
|
|
|
+ *dp_tx_ext_desc_pool->desc_link_pages.cacheable_pages;
|
|
|
+
|
|
|
+ if (qdf_mem_multi_page_link(soc->osdev,
|
|
|
+ &dp_tx_ext_desc_pool->
|
|
|
+ desc_link_pages,
|
|
|
+ dp_tx_ext_desc_pool->link_elem_size,
|
|
|
+ dp_tx_ext_desc_pool->elem_count,
|
|
|
+ true)) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "ext link desc page linking fail");
|
|
|
+ status = QDF_STATUS_E_FAULT;
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Assign coherent memory pointer into linked free list */
|
|
|
+ pages = &dp_tx_ext_desc_pool->desc_pages;
|
|
|
+ page_info = dp_tx_ext_desc_pool->desc_pages.dma_pages;
|
|
|
+ c_elem = dp_tx_ext_desc_pool->freelist;
|
|
|
+ p_elem = c_elem;
|
|
|
+ for (i = 0; i < dp_tx_ext_desc_pool->elem_count; i++) {
|
|
|
+ if (!(i % pages->num_element_per_page)) {
|
|
|
/**
|
|
|
* First element for new page,
|
|
|
* should point next page
|
|
|
*/
|
|
|
- if (!pages->dma_pages->page_v_addr_start) {
|
|
|
- QDF_TRACE(QDF_MODULE_ID_DP,
|
|
|
- QDF_TRACE_LEVEL_ERROR,
|
|
|
- "link over flow");
|
|
|
- status = QDF_STATUS_E_FAULT;
|
|
|
- goto free_ext_link_desc_page;
|
|
|
+ if (!pages->dma_pages->page_v_addr_start) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP,
|
|
|
+ QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "link over flow");
|
|
|
+ status = QDF_STATUS_E_FAULT;
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+
|
|
|
+ c_elem->vaddr =
|
|
|
+ (void *)page_info->page_v_addr_start;
|
|
|
+ c_elem->paddr = page_info->page_p_addr;
|
|
|
+ page_info++;
|
|
|
+ } else {
|
|
|
+ c_elem->vaddr = (void *)(p_elem->vaddr +
|
|
|
+ dp_tx_ext_desc_pool->elem_size);
|
|
|
+ c_elem->paddr = (p_elem->paddr +
|
|
|
+ dp_tx_ext_desc_pool->elem_size);
|
|
|
}
|
|
|
- c_elem->vaddr = (void *)page_info->page_v_addr_start;
|
|
|
- c_elem->paddr = page_info->page_p_addr;
|
|
|
- page_info++;
|
|
|
- } else {
|
|
|
- c_elem->vaddr = (void *)(p_elem->vaddr +
|
|
|
- soc->tx_ext_desc[pool_id].elem_size);
|
|
|
- c_elem->paddr = (p_elem->paddr +
|
|
|
- soc->tx_ext_desc[pool_id].elem_size);
|
|
|
+ p_elem = c_elem;
|
|
|
+ c_elem = c_elem->next;
|
|
|
+ if (!c_elem)
|
|
|
+ break;
|
|
|
}
|
|
|
- p_elem = c_elem;
|
|
|
- c_elem = c_elem->next;
|
|
|
- if (!c_elem)
|
|
|
- break;
|
|
|
+ dp_tx_ext_desc_pool->num_free = num_elem;
|
|
|
+ qdf_spinlock_create(&dp_tx_ext_desc_pool->lock);
|
|
|
}
|
|
|
-
|
|
|
- soc->tx_ext_desc[pool_id].num_free = num_elem;
|
|
|
- qdf_spinlock_create(&soc->tx_ext_desc[pool_id].lock);
|
|
|
return QDF_STATUS_SUCCESS;
|
|
|
|
|
|
-free_ext_link_desc_page:
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].desc_link_pages, 0, true);
|
|
|
-
|
|
|
-free_ext_desc_page:
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].desc_pages,
|
|
|
- qdf_get_dma_mem_context((&soc->tx_ext_desc[pool_id]), memctx),
|
|
|
- false);
|
|
|
-
|
|
|
-fail_exit:
|
|
|
+fail:
|
|
|
return status;
|
|
|
-
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_ext_desc_pool_free() - free tx ext descriptor pool
|
|
|
+ * dp_tx_ext_desc_pool_free() - free Tx extenstion Descriptor pool(s)
|
|
|
* @soc: Handle to DP SoC structure
|
|
|
- * @pool_id: extension descriptor pool id
|
|
|
+ * @num_pool: Number of pools to free
|
|
|
*
|
|
|
- * Return: NONE
|
|
|
*/
|
|
|
-QDF_STATUS dp_tx_ext_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+void dp_tx_ext_desc_pool_free(struct dp_soc *soc, uint8_t num_pool)
|
|
|
{
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].desc_link_pages, 0, true);
|
|
|
+ uint8_t pool_id;
|
|
|
+ struct dp_tx_ext_desc_pool_s *dp_tx_ext_desc_pool;
|
|
|
+ qdf_dma_context_t memctx = 0;
|
|
|
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &soc->tx_ext_desc[pool_id].desc_pages,
|
|
|
- qdf_get_dma_mem_context((&soc->tx_ext_desc[pool_id]), memctx),
|
|
|
- false);
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ memctx = qdf_get_dma_mem_context(dp_tx_ext_desc_pool, memctx);
|
|
|
|
|
|
- qdf_spinlock_destroy(&soc->tx_ext_desc[pool_id].lock);
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &dp_tx_ext_desc_pool->desc_link_pages,
|
|
|
+ 0, true);
|
|
|
+
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &dp_tx_ext_desc_pool->desc_pages,
|
|
|
+ memctx, false);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_tso_desc_pool_alloc() - allocate tx tso descriptor pool
|
|
|
+ * dp_tx_ext_desc_pool_deinit() - deinit Tx extenstion Descriptor pool(s)
|
|
|
* @soc: Handle to DP SoC structure
|
|
|
- * @pool_id: tso descriptor pool id
|
|
|
- * @num_elem: number of element
|
|
|
+ * @num_pool: Number of pools to de-initialize
|
|
|
*
|
|
|
- * Return: QDF_STATUS_SUCCESS
|
|
|
*/
|
|
|
+void dp_tx_ext_desc_pool_deinit(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+ uint8_t pool_id;
|
|
|
+ struct dp_tx_ext_desc_pool_s *dp_tx_ext_desc_pool;
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ dp_tx_ext_desc_pool = &((soc)->tx_ext_desc[pool_id]);
|
|
|
+ qdf_spinlock_destroy(&dp_tx_ext_desc_pool->lock);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
#if defined(FEATURE_TSO)
|
|
|
-QDF_STATUS dp_tx_tso_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+/**
|
|
|
+ * dp_tx_tso_desc_pool_alloc() - allocate TSO Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @num_pool: Number of pools to allocate
|
|
|
+ * @num_elem: Number of descriptor elements per pool
|
|
|
+ *
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_NOMEM
|
|
|
+ */
|
|
|
+QDF_STATUS dp_tx_tso_desc_pool_alloc(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
struct dp_tx_tso_seg_pool_s *tso_desc_pool;
|
|
|
- uint32_t desc_size;
|
|
|
+ uint32_t desc_size, pool_id, i;
|
|
|
|
|
|
- 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));
|
|
|
- if (!dp_is_soc_reinit(soc))
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_desc_pool = &soc->tx_tso_desc[pool_id];
|
|
|
+ tso_desc_pool->num_free = 0;
|
|
|
qdf_mem_multi_pages_alloc(soc->osdev,
|
|
|
&tso_desc_pool->desc_pages,
|
|
|
desc_size,
|
|
|
num_elem, 0, true);
|
|
|
|
|
|
- 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;
|
|
|
+ if (!tso_desc_pool->desc_pages.num_pages) {
|
|
|
+ dp_err("Multi page alloc fail, tx desc");
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
}
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
|
|
|
- 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;
|
|
|
+fail:
|
|
|
+ for (i = 0; i < pool_id; i++) {
|
|
|
+ tso_desc_pool = &soc->tx_tso_desc[i];
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &tso_desc_pool->desc_pages,
|
|
|
+ 0, true);
|
|
|
}
|
|
|
- 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;
|
|
|
+ return QDF_STATUS_E_NOMEM;
|
|
|
+}
|
|
|
|
|
|
-free_tso_desc:
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &tso_desc_pool->desc_pages, 0, true);
|
|
|
+/**
|
|
|
+ * dp_tx_tso_desc_pool_free() - free TSO Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @num_pool: Number of pools to free
|
|
|
+ *
|
|
|
+ */
|
|
|
+void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+ struct dp_tx_tso_seg_pool_s *tso_desc_pool;
|
|
|
+ uint32_t pool_id;
|
|
|
|
|
|
- return QDF_STATUS_E_FAULT;
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_desc_pool = &soc->tx_tso_desc[pool_id];
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &tso_desc_pool->desc_pages, 0, true);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_tso_desc_pool_free() - free tx tso descriptor pool
|
|
|
+ * dp_tx_tso_desc_pool_init() - initialize TSO Descriptor pool(s)
|
|
|
* @soc: Handle to DP SoC structure
|
|
|
- * @pool_id: extension descriptor pool id
|
|
|
+ * @num_pool: Number of pools to initialize
|
|
|
+ * @num_elem: Number of descriptor elements per pool
|
|
|
*
|
|
|
- * Return: NONE
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_NOMEM
|
|
|
*/
|
|
|
-void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+QDF_STATUS dp_tx_tso_desc_pool_init(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
struct dp_tx_tso_seg_pool_s *tso_desc_pool;
|
|
|
+ uint32_t desc_size, pool_id;
|
|
|
+
|
|
|
+ desc_size = DP_TX_DESC_SIZE(sizeof(struct qdf_tso_seg_elem_t));
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_desc_pool = &soc->tx_tso_desc[pool_id];
|
|
|
+
|
|
|
+ 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");
|
|
|
+ return QDF_STATUS_E_FAULT;
|
|
|
+ }
|
|
|
+
|
|
|
+ tso_desc_pool->freelist = (struct qdf_tso_seg_elem_t *)
|
|
|
+ *tso_desc_pool->desc_pages.cacheable_pages;
|
|
|
+ tso_desc_pool->num_free = num_elem;
|
|
|
+
|
|
|
+ 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;
|
|
|
+}
|
|
|
|
|
|
- tso_desc_pool = &soc->tx_tso_desc[pool_id];
|
|
|
+/**
|
|
|
+ * dp_tx_tso_desc_pool_deinit() - deinitialize TSO Descriptor pool(s)
|
|
|
+ * @soc: Handle to DP SoC structure
|
|
|
+ * @num_pool: Number of pools to free
|
|
|
+ *
|
|
|
+ */
|
|
|
+void dp_tx_tso_desc_pool_deinit(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+ struct dp_tx_tso_seg_pool_s *tso_desc_pool;
|
|
|
+ uint32_t pool_id;
|
|
|
|
|
|
- qdf_spin_lock_bh(&tso_desc_pool->lock);
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_desc_pool = &soc->tx_tso_desc[pool_id];
|
|
|
+ qdf_spin_lock_bh(&tso_desc_pool->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;
|
|
|
+ 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);
|
|
|
+ }
|
|
|
}
|
|
|
+
|
|
|
/**
|
|
|
* dp_tx_tso_num_seg_pool_alloc() - Allocate descriptors that tracks the
|
|
|
* fragments in each tso segment
|
|
|
*
|
|
|
* @soc: handle to dp soc structure
|
|
|
- * @pool_id: descriptor pool id
|
|
|
+ * @num_pool: number of pools to allocate
|
|
|
* @num_elem: total number of descriptors to be allocated
|
|
|
+ *
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_NOMEM
|
|
|
*/
|
|
|
-QDF_STATUS dp_tx_tso_num_seg_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+QDF_STATUS dp_tx_tso_num_seg_pool_alloc(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
|
|
|
- uint32_t desc_size;
|
|
|
+ uint32_t desc_size, pool_id, i;
|
|
|
|
|
|
- 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));
|
|
|
- if (!dp_is_soc_reinit(soc))
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
|
|
|
+ tso_num_seg_pool->num_free = 0;
|
|
|
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;
|
|
|
- }
|
|
|
|
|
|
- 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;
|
|
|
+ if (!tso_num_seg_pool->desc_pages.num_pages) {
|
|
|
+ dp_err("Multi page alloc fail, tso_num_seg_pool");
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
}
|
|
|
-
|
|
|
- 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:
|
|
|
- qdf_mem_multi_pages_free(soc->osdev,
|
|
|
- &tso_num_seg_pool->desc_pages, 0, true);
|
|
|
-
|
|
|
+ for (i = 0; i < pool_id; i++) {
|
|
|
+ tso_num_seg_pool = &soc->tx_tso_num_seg[i];
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &tso_num_seg_pool->desc_pages,
|
|
|
+ 0, true);
|
|
|
+ }
|
|
|
return QDF_STATUS_E_NOMEM;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * dp_tx_tso_num_seg_pool_free() - free pool of descriptors that tracks
|
|
|
- * the fragments in tso segment
|
|
|
+ * dp_tx_tso_num_seg_pool_free() - free descriptors that tracks the
|
|
|
+ * fragments in each tso segment
|
|
|
*
|
|
|
+ * @soc: handle to dp soc structure
|
|
|
+ * @num_pool: number of pools to free
|
|
|
+ */
|
|
|
+void dp_tx_tso_num_seg_pool_free(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+ struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
|
|
|
+ uint32_t pool_id;
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
|
|
|
+ qdf_mem_multi_pages_free(soc->osdev,
|
|
|
+ &tso_num_seg_pool->desc_pages,
|
|
|
+ 0, true);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_tso_num_seg_pool_init() - Initialize descriptors that tracks the
|
|
|
+ * fragments in each tso segment
|
|
|
*
|
|
|
* @soc: handle to dp soc structure
|
|
|
- * @pool_id: descriptor pool_id
|
|
|
+ * @num_pool: number of pools to initialize
|
|
|
+ * @num_elem: total number of descriptors to be initialized
|
|
|
+ *
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_FAULT
|
|
|
*/
|
|
|
-void dp_tx_tso_num_seg_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+QDF_STATUS dp_tx_tso_num_seg_pool_init(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
|
|
|
+ uint32_t desc_size, pool_id;
|
|
|
+
|
|
|
+ desc_size = DP_TX_DESC_SIZE(sizeof(struct qdf_tso_num_seg_elem_t));
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
|
|
|
+ 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");
|
|
|
+ return QDF_STATUS_E_FAULT;
|
|
|
+ }
|
|
|
|
|
|
- tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
|
|
|
- qdf_spin_lock_bh(&tso_num_seg_pool->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;
|
|
|
+ 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;
|
|
|
}
|
|
|
|
|
|
+/**
|
|
|
+ * dp_tx_tso_num_seg_pool_deinit() - de-initialize descriptors that tracks the
|
|
|
+ * fragments in each tso segment
|
|
|
+ *
|
|
|
+ * @soc: handle to dp soc structure
|
|
|
+ * @num_pool: number of pools to de-initialize
|
|
|
+ *
|
|
|
+ * Return - QDF_STATUS_SUCCESS
|
|
|
+ * QDF_STATUS_E_FAULT
|
|
|
+ */
|
|
|
+void dp_tx_tso_num_seg_pool_deinit(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+ struct dp_tx_tso_num_seg_pool_s *tso_num_seg_pool;
|
|
|
+ uint32_t pool_id;
|
|
|
+
|
|
|
+ for (pool_id = 0; pool_id < num_pool; pool_id++) {
|
|
|
+ tso_num_seg_pool = &soc->tx_tso_num_seg[pool_id];
|
|
|
+ qdf_spin_lock_bh(&tso_num_seg_pool->lock);
|
|
|
+
|
|
|
+ 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);
|
|
|
+ }
|
|
|
+}
|
|
|
#else
|
|
|
-QDF_STATUS dp_tx_tso_desc_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+QDF_STATUS dp_tx_tso_desc_pool_alloc(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
+{
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+QDF_STATUS dp_tx_tso_desc_pool_init(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
+{
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+void dp_tx_tso_desc_pool_deinit(struct dp_soc *soc, uint8_t num_pool)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QDF_STATUS dp_tx_tso_num_seg_pool_alloc(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
return QDF_STATUS_SUCCESS;
|
|
|
}
|
|
|
|
|
|
-void dp_tx_tso_desc_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+void dp_tx_tso_num_seg_pool_free(struct dp_soc *soc, uint8_t num_pool)
|
|
|
{
|
|
|
- return;
|
|
|
}
|
|
|
|
|
|
-QDF_STATUS dp_tx_tso_num_seg_pool_alloc(struct dp_soc *soc, uint8_t pool_id,
|
|
|
- uint16_t num_elem)
|
|
|
+QDF_STATUS dp_tx_tso_num_seg_pool_init(struct dp_soc *soc, uint8_t num_pool,
|
|
|
+ uint16_t num_elem)
|
|
|
{
|
|
|
return QDF_STATUS_SUCCESS;
|
|
|
}
|
|
|
|
|
|
-void dp_tx_tso_num_seg_pool_free(struct dp_soc *soc, uint8_t pool_id)
|
|
|
+void dp_tx_tso_num_seg_pool_deinit(struct dp_soc *soc, uint8_t num_pool)
|
|
|
{
|
|
|
- return;
|
|
|
}
|
|
|
#endif
|
phadiman