|
|
@@ -0,0 +1,417 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 2015-2017 The Linux Foundation. All rights reserved.
|
|
|
+ *
|
|
|
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * Permission to use, copy, modify, and/or distribute this software for
|
|
|
+ * any purpose with or without fee is hereby granted, provided that the
|
|
|
+ * above copyright notice and this permission notice appear in all
|
|
|
+ * copies.
|
|
|
+ *
|
|
|
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
|
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
|
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
|
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
|
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
+ * PERFORMANCE OF THIS SOFTWARE.
|
|
|
+ */
|
|
|
+
|
|
|
+/*
|
|
|
+ * This file was originally distributed by Qualcomm Atheros, Inc.
|
|
|
+ * under proprietary terms before Copyright ownership was assigned
|
|
|
+ * to the Linux Foundation.
|
|
|
+ */
|
|
|
+#include <cds_api.h>
|
|
|
+
|
|
|
+/* OS abstraction libraries */
|
|
|
+#include <qdf_nbuf.h> /* qdf_nbuf_t, etc. */
|
|
|
+#include <qdf_atomic.h> /* qdf_atomic_read, etc. */
|
|
|
+#include <qdf_util.h> /* qdf_unlikely */
|
|
|
+#include "dp_types.h"
|
|
|
+#include "dp_tx_desc.h"
|
|
|
+
|
|
|
+#include <cdp_txrx_handle.h>
|
|
|
+#include "dp_internal.h"
|
|
|
+#define INVALID_FLOW_ID 0xFF
|
|
|
+#define MAX_INVALID_BIN 3
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_dump_flow_pool_info() - dump global_pool and flow_pool info
|
|
|
+ *
|
|
|
+ * @ctx: Handle to struct dp_soc.
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+void dp_tx_dump_flow_pool_info(void *ctx)
|
|
|
+{
|
|
|
+ struct dp_soc *soc = ctx;
|
|
|
+ struct dp_txrx_pool_stats *pool_stats = &soc->pool_stats;
|
|
|
+ struct dp_tx_desc_pool_s *pool = NULL;
|
|
|
+ struct dp_tx_desc_pool_s tmp_pool;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "No of pool map received %d", pool_stats->pool_map_count);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "No of pool unmap received %d", pool_stats->pool_unmap_count);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Pkt dropped due to unavailablity of pool %d",
|
|
|
+ pool_stats->pkt_drop_no_pool);
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Nested spin lock.
|
|
|
+ * Always take in below order.
|
|
|
+ * flow_pool_array_lock -> flow_pool_lock
|
|
|
+ */
|
|
|
+ qdf_spin_lock_bh(&soc->flow_pool_array_lock);
|
|
|
+ for (i = 0; i < MAX_TXDESC_POOLS; i++) {
|
|
|
+ pool = &soc->tx_desc[i];
|
|
|
+ if (pool->status > FLOW_POOL_INVALID)
|
|
|
+ continue;
|
|
|
+ qdf_spin_lock_bh(&pool->flow_pool_lock);
|
|
|
+ qdf_mem_copy(&tmp_pool, pool, sizeof(tmp_pool));
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+ qdf_spin_unlock_bh(&soc->flow_pool_array_lock);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, "\n");
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Flow_pool_id %d :: status %d",
|
|
|
+ tmp_pool.flow_pool_id, tmp_pool.status);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Total %d :: Available %d",
|
|
|
+ tmp_pool.pool_size, tmp_pool.avail_desc);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Start threshold %d :: Stop threshold %d",
|
|
|
+ tmp_pool.start_th, tmp_pool.stop_th);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Member flow_id %d :: flow_type %d",
|
|
|
+ tmp_pool.flow_pool_id, tmp_pool.flow_type);
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "Pkt dropped due to unavailablity of descriptors %d",
|
|
|
+ tmp_pool.pkt_drop_no_desc);
|
|
|
+ qdf_spin_lock_bh(&soc->flow_pool_array_lock);
|
|
|
+ }
|
|
|
+ qdf_spin_unlock_bh(&soc->flow_pool_array_lock);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_clear_flow_pool_stats() - clear flow pool statistics
|
|
|
+ *
|
|
|
+ * @soc: Handle to struct dp_soc.
|
|
|
+ *
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+void dp_tx_clear_flow_pool_stats(struct dp_soc *soc)
|
|
|
+{
|
|
|
+
|
|
|
+ if (!soc) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: soc is null\n", __func__);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ qdf_mem_zero(&soc->pool_stats, sizeof(soc->pool_stats));
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_create_flow_pool() - create flow pool
|
|
|
+ * @soc: Handle to struct dp_soc
|
|
|
+ * @flow_pool_id: flow pool id
|
|
|
+ * @flow_pool_size: flow pool size
|
|
|
+ *
|
|
|
+ * Return: flow_pool pointer / NULL for error
|
|
|
+ */
|
|
|
+struct dp_tx_desc_pool_s *dp_tx_create_flow_pool(struct dp_soc *soc,
|
|
|
+ uint8_t flow_pool_id, uint16_t flow_pool_size)
|
|
|
+{
|
|
|
+ struct dp_tx_desc_pool_s *pool;
|
|
|
+ uint32_t stop_threshold;
|
|
|
+ uint32_t start_threshold;
|
|
|
+
|
|
|
+ if (!soc) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: soc is NULL\n", __func__);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+ pool = &soc->tx_desc[flow_pool_id];
|
|
|
+ qdf_spin_lock_bh(&pool->flow_pool_lock);
|
|
|
+ if (pool->status == FLOW_POOL_INVALID) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: flow pool already allocated\n", __func__);
|
|
|
+ if (pool->avail_desc > pool->start_th)
|
|
|
+ pool->status = FLOW_POOL_ACTIVE_UNPAUSED;
|
|
|
+ else
|
|
|
+ pool->status = FLOW_POOL_ACTIVE_PAUSED;
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+ return pool;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (dp_tx_desc_pool_alloc(soc, flow_pool_id, flow_pool_size))
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ stop_threshold = wlan_cfg_get_tx_flow_stop_queue_th(soc->wlan_cfg_ctx);
|
|
|
+ start_threshold = stop_threshold +
|
|
|
+ wlan_cfg_get_tx_flow_start_queue_offset(soc->wlan_cfg_ctx);
|
|
|
+
|
|
|
+ pool->flow_pool_id = flow_pool_id;
|
|
|
+ pool->pool_size = flow_pool_size;
|
|
|
+ pool->avail_desc = flow_pool_size;
|
|
|
+ pool->status = FLOW_POOL_ACTIVE_UNPAUSED;
|
|
|
+ /* INI is in percentage so divide by 100 */
|
|
|
+ pool->start_th = (start_threshold * flow_pool_size)/100;
|
|
|
+ pool->stop_th = (stop_threshold * flow_pool_size)/100;
|
|
|
+
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+
|
|
|
+ return pool;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_delete_flow_pool() - delete flow pool
|
|
|
+ * @soc: Handle to struct dp_soc
|
|
|
+ * @pool: flow pool pointer
|
|
|
+ * @force: free pool forcefully
|
|
|
+ *
|
|
|
+ * Delete flow_pool if all tx descriptors are available.
|
|
|
+ * Otherwise put it in FLOW_POOL_INVALID state.
|
|
|
+ * If force is set then pull all available descriptors to
|
|
|
+ * global pool.
|
|
|
+ *
|
|
|
+ * Return: 0 for success or error
|
|
|
+ */
|
|
|
+int dp_tx_delete_flow_pool(struct dp_soc *soc, struct dp_tx_desc_pool_s *pool,
|
|
|
+ bool force)
|
|
|
+{
|
|
|
+ if (!soc || !pool) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: pool or soc is NULL\n", __func__);
|
|
|
+ QDF_ASSERT(0);
|
|
|
+ return ENOMEM;
|
|
|
+ }
|
|
|
+
|
|
|
+ qdf_spin_lock_bh(&pool->flow_pool_lock);
|
|
|
+ if (pool->avail_desc < pool->pool_size) {
|
|
|
+ pool->status = FLOW_POOL_INVALID;
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+ return EAGAIN;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* We have all the descriptors for the pool, we can delete the pool */
|
|
|
+ dp_tx_desc_pool_free(soc, pool->flow_pool_id);
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_pool_vdev_map() - Map flow_pool with vdev
|
|
|
+ * @pdev: Handle to struct dp_pdev
|
|
|
+ * @pool: flow_pool
|
|
|
+ * @vdev_id: flow_id /vdev_id
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+static void dp_tx_flow_pool_vdev_map(struct dp_pdev *pdev,
|
|
|
+ struct dp_tx_desc_pool_s *pool, uint8_t vdev_id)
|
|
|
+{
|
|
|
+ struct dp_vdev *vdev;
|
|
|
+ struct dp_soc *soc = pdev->soc;
|
|
|
+
|
|
|
+ vdev = (struct dp_vdev *)cdp_get_vdev_from_vdev_id((void *)soc,
|
|
|
+ (struct cdp_pdev *)pdev, vdev_id);
|
|
|
+ if (!vdev) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: invalid vdev_id %d\n",
|
|
|
+ __func__, vdev_id);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ vdev->pool = pool;
|
|
|
+ qdf_spin_lock_bh(&pool->flow_pool_lock);
|
|
|
+ pool->pool_owner_ctx = soc;
|
|
|
+ pool->flow_pool_id = vdev_id;
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_pool_vdev_unmap() - Unmap flow_pool from vdev
|
|
|
+ * @pdev: Handle to struct dp_pdev
|
|
|
+ * @pool: flow_pool
|
|
|
+ * @vdev_id: flow_id /vdev_id
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+static void dp_tx_flow_pool_vdev_unmap(struct dp_pdev *pdev,
|
|
|
+ struct dp_tx_desc_pool_s *pool, uint8_t vdev_id)
|
|
|
+{
|
|
|
+ struct dp_vdev *vdev;
|
|
|
+ struct dp_soc *soc = pdev->soc;
|
|
|
+
|
|
|
+ vdev = (struct dp_vdev *)cdp_get_vdev_from_vdev_id((void *)soc,
|
|
|
+ (struct cdp_pdev *)pdev, vdev_id);
|
|
|
+ if (!vdev) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: invalid vdev_id %d\n",
|
|
|
+ __func__, vdev_id);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ vdev->pool = NULL;
|
|
|
+ qdf_spin_lock_bh(&pool->flow_pool_lock);
|
|
|
+ pool->flow_pool_id = INVALID_FLOW_ID;
|
|
|
+ qdf_spin_unlock_bh(&pool->flow_pool_lock);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_pool_map_handler() - Map flow_id with pool of descriptors
|
|
|
+ * @pdev: Handle to struct dp_pdev
|
|
|
+ * @flow_id: flow id
|
|
|
+ * @flow_type: flow type
|
|
|
+ * @flow_pool_id: pool id
|
|
|
+ * @flow_pool_size: pool size
|
|
|
+ *
|
|
|
+ * Process below target to host message
|
|
|
+ * HTT_T2H_MSG_TYPE_FLOW_POOL_MAP
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+QDF_STATUS dp_tx_flow_pool_map_handler(struct dp_pdev *pdev, uint8_t flow_id,
|
|
|
+ uint8_t flow_type, uint8_t flow_pool_id, uint16_t flow_pool_size)
|
|
|
+{
|
|
|
+ struct dp_soc *soc = pdev->soc;
|
|
|
+ struct dp_tx_desc_pool_s *pool;
|
|
|
+ enum htt_flow_type type = flow_type;
|
|
|
+
|
|
|
+
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
|
|
|
+ "%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);
|
|
|
+
|
|
|
+ if (qdf_unlikely(!soc)) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: soc is NULL", __func__);
|
|
|
+ return QDF_STATUS_E_FAULT;
|
|
|
+ }
|
|
|
+ soc->pool_stats.pool_map_count++;
|
|
|
+
|
|
|
+ pool = dp_tx_create_flow_pool(soc, flow_pool_id,
|
|
|
+ flow_pool_size);
|
|
|
+ if (pool == NULL) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: creation of flow_pool %d size %d failed\n",
|
|
|
+ __func__, flow_pool_id, flow_pool_size);
|
|
|
+ return QDF_STATUS_E_RESOURCES;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case FLOW_TYPE_VDEV:
|
|
|
+ dp_tx_flow_pool_vdev_map(pdev, pool, flow_id);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: flow type %d not supported !!!\n",
|
|
|
+ __func__, type);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_pool_unmap_handler() - Unmap flow_id from pool of descriptors
|
|
|
+ * @pdev: Handle to struct dp_pdev
|
|
|
+ * @flow_id: flow id
|
|
|
+ * @flow_type: flow type
|
|
|
+ * @flow_pool_id: pool id
|
|
|
+ *
|
|
|
+ * Process below target to host message
|
|
|
+ * HTT_T2H_MSG_TYPE_FLOW_POOL_UNMAP
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+void dp_tx_flow_pool_unmap_handler(struct dp_pdev *pdev, uint8_t flow_id,
|
|
|
+ uint8_t flow_type, uint8_t flow_pool_id)
|
|
|
+{
|
|
|
+ struct dp_soc *soc = pdev->soc;
|
|
|
+ struct dp_tx_desc_pool_s *pool;
|
|
|
+ enum htt_flow_type type = flow_type;
|
|
|
+
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
|
|
|
+ "%s: flow_id %d flow_type %d flow_pool_id %d\n",
|
|
|
+ __func__, flow_id, flow_type, flow_pool_id);
|
|
|
+
|
|
|
+ if (qdf_unlikely(!pdev)) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: pdev is NULL", __func__);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ soc->pool_stats.pool_unmap_count++;
|
|
|
+
|
|
|
+ pool = &soc->tx_desc[flow_pool_id];
|
|
|
+ if (!pool) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: flow_pool not available flow_pool_id %d\n",
|
|
|
+ __func__, type);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (type) {
|
|
|
+
|
|
|
+ case FLOW_TYPE_VDEV:
|
|
|
+ dp_tx_flow_pool_vdev_unmap(pdev, pool, flow_id);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ "%s: flow type %d not supported !!!\n",
|
|
|
+ __func__, type);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* only delete if all descriptors are available */
|
|
|
+ dp_tx_delete_flow_pool(soc, pool, false);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_control_init() - Initialize tx flow control
|
|
|
+ * @tx_desc_pool: Handle to flow_pool
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+void dp_tx_flow_control_init(struct dp_soc *soc)
|
|
|
+{
|
|
|
+ qdf_spinlock_create(&soc->flow_pool_array_lock);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_tx_flow_control_deinit() - Deregister fw based tx flow control
|
|
|
+ * @tx_desc_pool: Handle to flow_pool
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+void dp_tx_flow_control_deinit(struct dp_soc *soc)
|
|
|
+{
|
|
|
+ qdf_spinlock_destroy(&soc->flow_pool_array_lock);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * dp_txrx_register_pause_cb() - Register pause callback
|
|
|
+ * @ctx: Handle to struct dp_soc
|
|
|
+ * @pause_cb: Tx pause_cb
|
|
|
+ *
|
|
|
+ * Return: none
|
|
|
+ */
|
|
|
+QDF_STATUS dp_txrx_register_pause_cb(struct cdp_soc_t *handle,
|
|
|
+ tx_pause_callback pause_cb)
|
|
|
+{
|
|
|
+ struct dp_soc *soc = (struct dp_soc *)handle;
|
|
|
+
|
|
|
+ if (!soc || !pause_cb) {
|
|
|
+ QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
|
|
|
+ FL("soc or pause_cb is NULL"));
|
|
|
+ return QDF_STATUS_E_INVAL;
|
|
|
+ }
|
|
|
+ soc->pause_cb = pause_cb;
|
|
|
+
|
|
|
+ return QDF_STATUS_SUCCESS;
|
|
|
+}
|
Manjunathappa Prakash