/*
* Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. 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
* 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.
*/
#include "htt.h"
#include "dp_peer.h"
#include "hal_rx.h"
#include "hal_api.h"
#include "qdf_nbuf.h"
#include "dp_types.h"
#include "dp_internal.h"
#include "dp_tx.h"
#include "enet.h"
#ifdef WIFI_MONITOR_SUPPORT
#include "dp_mon.h"
#endif
#include "dp_txrx_wds.h"
/* Generic AST entry aging timer value */
#define DP_AST_AGING_TIMER_DEFAULT_MS 5000
#define DP_INVALID_AST_IDX 0xffff
#define DP_INVALID_FLOW_PRIORITY 0xff
#define DP_PEER_AST0_FLOW_MASK 0x4
#define DP_PEER_AST1_FLOW_MASK 0x8
#define DP_PEER_AST2_FLOW_MASK 0x1
#define DP_PEER_AST3_FLOW_MASK 0x2
#define DP_MAX_AST_INDEX_PER_PEER 4
#ifdef WLAN_FEATURE_MULTI_AST_DEL
void dp_peer_free_peer_ase_list(struct dp_soc *soc,
struct peer_del_multi_wds_entries *wds_list)
{
struct peer_wds_entry_list *wds_entry, *tmp_entry;
TAILQ_FOREACH_SAFE(wds_entry, &wds_list->ase_list,
ase_list_elem, tmp_entry) {
dp_peer_debug("type: %d mac_addr: " QDF_MAC_ADDR_FMT,
wds_entry->type,
QDF_MAC_ADDR_REF(wds_entry->dest_addr));
TAILQ_REMOVE(&wds_list->ase_list, wds_entry, ase_list_elem);
wds_list->num_entries--;
qdf_mem_free(wds_entry);
}
}
static void
dp_pdev_build_peer_ase_list(struct dp_soc *soc, struct dp_peer *peer,
void *arg)
{
struct dp_ast_entry *ase, *temp_ase;
struct peer_del_multi_wds_entries *list = arg;
struct peer_wds_entry_list *wds_entry;
if (!soc || !peer || !arg) {
dp_peer_err("Invalid input");
return;
}
list->vdev_id = peer->vdev->vdev_id;
DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) {
if (ase->type != CDP_TXRX_AST_TYPE_WDS &&
ase->type != CDP_TXRX_AST_TYPE_DA)
continue;
if (ase->is_active) {
ase->is_active = false;
continue;
}
if (ase->delete_in_progress) {
dp_info_rl("Del set addr:" QDF_MAC_ADDR_FMT " type:%d",
QDF_MAC_ADDR_REF(ase->mac_addr.raw),
ase->type);
continue;
}
if (ase->is_mapped)
soc->ast_table[ase->ast_idx] = NULL;
if (!ase->next_hop) {
dp_peer_unlink_ast_entry(soc, ase, peer);
continue;
}
wds_entry = (struct peer_wds_entry_list *)
qdf_mem_malloc(sizeof(*wds_entry));
if (!wds_entry) {
dp_peer_err("%pK: fail to allocate wds_entry", soc);
dp_peer_free_peer_ase_list(soc, list);
return;
}
DP_STATS_INC(soc, ast.aged_out, 1);
ase->delete_in_progress = true;
wds_entry->dest_addr = ase->mac_addr.raw;
wds_entry->type = ase->type;
if (dp_peer_state_cmp(peer, DP_PEER_STATE_LOGICAL_DELETE))
wds_entry->delete_in_fw = false;
else
wds_entry->delete_in_fw = true;
dp_peer_debug("ase->type: %d pdev: %u vdev: %u mac_addr: " QDF_MAC_ADDR_FMT " next_hop: %u peer: %u",
ase->type, ase->pdev_id, ase->vdev_id,
QDF_MAC_ADDR_REF(ase->mac_addr.raw),
ase->next_hop, ase->peer_id);
TAILQ_INSERT_TAIL(&list->ase_list, wds_entry, ase_list_elem);
list->num_entries++;
}
dp_peer_info("Total num of entries :%d", list->num_entries);
}
static void
dp_peer_age_multi_ast_entries(struct dp_soc *soc, void *arg,
enum dp_mod_id mod_id)
{
uint8_t i;
struct dp_pdev *pdev = NULL;
struct peer_del_multi_wds_entries wds_list = {0};
TAILQ_INIT(&wds_list.ase_list);
for (i = 0; i < MAX_PDEV_CNT && soc->pdev_list[i]; i++) {
pdev = soc->pdev_list[i];
dp_pdev_iterate_peer(pdev, dp_pdev_build_peer_ase_list,
&wds_list, mod_id);
if (wds_list.num_entries > 0) {
dp_peer_ast_send_multi_wds_del(soc, wds_list.vdev_id,
&wds_list);
dp_peer_free_peer_ase_list(soc, &wds_list);
} else {
dp_peer_debug("No AST entries for pdev:%u",
pdev->pdev_id);
}
}
}
#endif /* WLAN_FEATURE_MULTI_AST_DEL */
static void
dp_peer_age_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg)
{
struct dp_ast_entry *ase, *temp_ase;
struct ast_del_ctxt *del_ctxt = (struct ast_del_ctxt *)arg;
if ((del_ctxt->del_count >= soc->max_ast_ageout_count) &&
!del_ctxt->age) {
return;
}
DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) {
/*
* Do not expire static ast entries and HM WDS entries
*/
if (ase->type != CDP_TXRX_AST_TYPE_WDS &&
ase->type != CDP_TXRX_AST_TYPE_DA)
continue;
if (ase->is_active) {
if (del_ctxt->age)
ase->is_active = FALSE;
continue;
}
if (del_ctxt->del_count < soc->max_ast_ageout_count) {
DP_STATS_INC(soc, ast.aged_out, 1);
dp_peer_del_ast(soc, ase);
del_ctxt->del_count++;
} else {
soc->pending_ageout = true;
if (!del_ctxt->age)
break;
}
}
}
static void
dp_peer_age_mec_entries(struct dp_soc *soc)
{
uint32_t index;
struct dp_mec_entry *mecentry, *mecentry_next;
TAILQ_HEAD(, dp_mec_entry) free_list;
TAILQ_INIT(&free_list);
for (index = 0; index <= soc->mec_hash.mask; index++) {
qdf_spin_lock_bh(&soc->mec_lock);
/*
* Expire MEC entry every n sec.
*/
if (!TAILQ_EMPTY(&soc->mec_hash.bins[index])) {
TAILQ_FOREACH_SAFE(mecentry, &soc->mec_hash.bins[index],
hash_list_elem, mecentry_next) {
if (mecentry->is_active) {
mecentry->is_active = FALSE;
continue;
}
dp_peer_mec_detach_entry(soc, mecentry,
&free_list);
}
}
qdf_spin_unlock_bh(&soc->mec_lock);
}
dp_peer_mec_free_list(soc, &free_list);
}
#ifdef WLAN_FEATURE_MULTI_AST_DEL
static void dp_ast_aging_timer_fn(void *soc_hdl)
{
struct dp_soc *soc = (struct dp_soc *)soc_hdl;
struct ast_del_ctxt del_ctxt = {0};
if (soc->wds_ast_aging_timer_cnt++ >= DP_WDS_AST_AGING_TIMER_CNT) {
del_ctxt.age = true;
soc->wds_ast_aging_timer_cnt = 0;
}
if (soc->pending_ageout || del_ctxt.age) {
soc->pending_ageout = false;
/* AST list access lock */
qdf_spin_lock_bh(&soc->ast_lock);
if (soc->multi_peer_grp_cmd_supported)
dp_peer_age_multi_ast_entries(soc, NULL, DP_MOD_ID_AST);
else
dp_soc_iterate_peer(soc, dp_peer_age_ast_entries,
&del_ctxt, DP_MOD_ID_AST);
qdf_spin_unlock_bh(&soc->ast_lock);
}
/*
* If NSS offload is enabled, the MEC timeout
* will be managed by NSS.
*/
if (qdf_atomic_read(&soc->mec_cnt) &&
!wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx))
dp_peer_age_mec_entries(soc);
if (qdf_atomic_read(&soc->cmn_init_done))
qdf_timer_mod(&soc->ast_aging_timer,
DP_AST_AGING_TIMER_DEFAULT_MS);
}
#else
static void dp_ast_aging_timer_fn(void *soc_hdl)
{
struct dp_soc *soc = (struct dp_soc *)soc_hdl;
struct ast_del_ctxt del_ctxt = {0};
if (soc->wds_ast_aging_timer_cnt++ >= DP_WDS_AST_AGING_TIMER_CNT) {
del_ctxt.age = true;
soc->wds_ast_aging_timer_cnt = 0;
}
if (soc->pending_ageout || del_ctxt.age) {
soc->pending_ageout = false;
/* AST list access lock */
qdf_spin_lock_bh(&soc->ast_lock);
dp_soc_iterate_peer(soc, dp_peer_age_ast_entries,
&del_ctxt, DP_MOD_ID_AST);
qdf_spin_unlock_bh(&soc->ast_lock);
}
/*
* If NSS offload is enabled, the MEC timeout
* will be managed by NSS.
*/
if (qdf_atomic_read(&soc->mec_cnt) &&
!wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx))
dp_peer_age_mec_entries(soc);
if (qdf_atomic_read(&soc->cmn_init_done))
qdf_timer_mod(&soc->ast_aging_timer,
DP_AST_AGING_TIMER_DEFAULT_MS);
}
#endif /* WLAN_FEATURE_MULTI_AST_DEL */
#ifndef IPA_WDS_EASYMESH_FEATURE
void dp_soc_wds_attach(struct dp_soc *soc)
{
if (soc->ast_offload_support)
return;
soc->wds_ast_aging_timer_cnt = 0;
soc->pending_ageout = false;
qdf_timer_init(soc->osdev, &soc->ast_aging_timer,
dp_ast_aging_timer_fn, (void *)soc,
QDF_TIMER_TYPE_WAKE_APPS);
qdf_timer_mod(&soc->ast_aging_timer, DP_AST_AGING_TIMER_DEFAULT_MS);
}
void dp_soc_wds_detach(struct dp_soc *soc)
{
qdf_timer_stop(&soc->ast_aging_timer);
qdf_timer_free(&soc->ast_aging_timer);
}
#else
void dp_soc_wds_attach(struct dp_soc *soc)
{
}
void dp_soc_wds_detach(struct dp_soc *soc)
{
}
#endif
void dp_tx_mec_handler(struct dp_vdev *vdev, uint8_t *status)
{
struct dp_soc *soc;
QDF_STATUS add_mec_status;
uint8_t mac_addr[QDF_MAC_ADDR_SIZE], i;
if (!vdev->mec_enabled)
return;
/* MEC required only in STA mode */
if (vdev->opmode != wlan_op_mode_sta)
return;
soc = vdev->pdev->soc;
for (i = 0; i < QDF_MAC_ADDR_SIZE; i++)
mac_addr[(QDF_MAC_ADDR_SIZE - 1) - i] =
status[(QDF_MAC_ADDR_SIZE - 2) + i];
dp_peer_debug("%pK: MEC add for mac_addr "QDF_MAC_ADDR_FMT,
soc, QDF_MAC_ADDR_REF(mac_addr));
if (qdf_mem_cmp(mac_addr, vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE)) {
add_mec_status = dp_peer_mec_add_entry(soc, vdev, mac_addr);
dp_peer_debug("%pK: MEC add status %d", vdev, add_mec_status);
}
}
#ifndef QCA_HOST_MODE_WIFI_DISABLED
void
dp_rx_da_learn(struct dp_soc *soc,
uint8_t *rx_tlv_hdr,
struct dp_txrx_peer *ta_txrx_peer,
qdf_nbuf_t nbuf)
{
struct dp_peer *base_peer;
/* For HKv2 DA port learing is not needed */
if (qdf_likely(soc->ast_override_support))
return;
if (qdf_unlikely(!ta_txrx_peer))
return;
if (qdf_unlikely(ta_txrx_peer->vdev->opmode != wlan_op_mode_ap))
return;
if (!soc->da_war_enabled)
return;
if (qdf_unlikely(!qdf_nbuf_is_da_valid(nbuf) &&
!qdf_nbuf_is_da_mcbc(nbuf))) {
base_peer = dp_peer_get_ref_by_id(soc, ta_txrx_peer->peer_id,
DP_MOD_ID_AST);
if (base_peer) {
dp_peer_add_ast(soc,
base_peer,
qdf_nbuf_data(nbuf),
CDP_TXRX_AST_TYPE_DA,
DP_AST_FLAGS_HM);
dp_peer_unref_delete(base_peer, DP_MOD_ID_AST);
}
}
}
#ifdef WDS_VENDOR_EXTENSION
QDF_STATUS
dp_txrx_set_wds_rx_policy(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
u_int32_t val)
{
struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
struct dp_peer *peer;
struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
DP_MOD_ID_MISC);
if (!vdev) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("vdev is NULL for vdev_id %d"), vdev_id);
return QDF_STATUS_E_INVAL;
}
peer = dp_vdev_bss_peer_ref_n_get(vdev, DP_MOD_ID_AST);
if (peer) {
peer->txrx_peer->wds_ecm.wds_rx_filter = 1;
peer->txrx_peer->wds_ecm.wds_rx_ucast_4addr =
(val & WDS_POLICY_RX_UCAST_4ADDR) ? 1 : 0;
peer->txrx_peer->wds_ecm.wds_rx_mcast_4addr =
(val & WDS_POLICY_RX_MCAST_4ADDR) ? 1 : 0;
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
}
dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_MISC);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
dp_txrx_peer_wds_tx_policy_update(struct cdp_soc_t *soc, uint8_t vdev_id,
uint8_t *peer_mac, int wds_tx_ucast,
int wds_tx_mcast)
{
struct dp_peer *peer =
dp_peer_get_tgt_peer_hash_find((struct dp_soc *)soc,
peer_mac, 0,
vdev_id,
DP_MOD_ID_AST);
if (!peer) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("peer is NULL for mac" QDF_MAC_ADDR_FMT
" vdev_id %d"), QDF_MAC_ADDR_REF(peer_mac),
vdev_id);
return QDF_STATUS_E_INVAL;
}
if (!peer->txrx_peer) {
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return QDF_STATUS_E_INVAL;
}
if (wds_tx_ucast || wds_tx_mcast) {
peer->txrx_peer->wds_enabled = 1;
peer->txrx_peer->wds_ecm.wds_tx_ucast_4addr = wds_tx_ucast;
peer->txrx_peer->wds_ecm.wds_tx_mcast_4addr = wds_tx_mcast;
} else {
peer->txrx_peer->wds_enabled = 0;
peer->txrx_peer->wds_ecm.wds_tx_ucast_4addr = 0;
peer->txrx_peer->wds_ecm.wds_tx_mcast_4addr = 0;
}
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
"Policy Update set to :\n");
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
"peer->wds_enabled %d\n", peer->wds_enabled);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
"peer->wds_ecm.wds_tx_ucast_4addr %d\n",
peer->txrx_peer->wds_ecm.wds_tx_ucast_4addr);
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
"peer->wds_ecm.wds_tx_mcast_4addr %d\n",
peer->txrx_peer->wds_ecm.wds_tx_mcast_4addr);
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return QDF_STATUS_SUCCESS;
}
int dp_wds_rx_policy_check(uint8_t *rx_tlv_hdr,
struct dp_vdev *vdev,
struct dp_txrx_peer *txrx_peer)
{
struct dp_peer *bss_peer;
int fr_ds, to_ds, rx_3addr, rx_4addr;
int rx_policy_ucast, rx_policy_mcast;
hal_soc_handle_t hal_soc = vdev->pdev->soc->hal_soc;
int rx_mcast = hal_rx_msdu_end_da_is_mcbc_get(hal_soc, rx_tlv_hdr);
if (vdev->opmode == wlan_op_mode_ap) {
bss_peer = dp_vdev_bss_peer_ref_n_get(vdev, DP_MOD_ID_AST);
/* if wds policy check is not enabled on this vdev, accept all frames */
if (bss_peer && !bss_peer->txrx_peer->wds_ecm.wds_rx_filter) {
dp_peer_unref_delete(bss_peer, DP_MOD_ID_AST);
return 1;
}
rx_policy_ucast = bss_peer->txrx_peerwds_ecm.wds_rx_ucast_4addr;
rx_policy_mcast = bss_peer->txrx_peerwds_ecm.wds_rx_mcast_4addr;
dp_peer_unref_delete(bss_peer, DP_MOD_ID_AST);
} else { /* sta mode */
if (!txrx_peer->wds_ecm.wds_rx_filter)
return 1;
rx_policy_ucast = txrx_peer->wds_ecm.wds_rx_ucast_4addr;
rx_policy_mcast = txrx_peer->wds_ecm.wds_rx_mcast_4addr;
}
/* ------------------------------------------------
* self
* peer- rx rx-
* wds ucast mcast dir policy accept note
* ------------------------------------------------
* 1 1 0 11 x1 1 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint met; so, accept
* 1 1 0 01 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop
* 1 1 0 10 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop
* 1 1 0 00 x1 0 bad frame, won't see it
* 1 0 1 11 1x 1 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint met; so, accept
* 1 0 1 01 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop
* 1 0 1 10 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop
* 1 0 1 00 1x 0 bad frame, won't see it
* 1 1 0 11 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop
* 1 1 0 01 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop
* 1 1 0 10 x0 1 AP configured to accept from-ds Rx ucast from wds peers, constraint met; so, accept
* 1 1 0 00 x0 0 bad frame, won't see it
* 1 0 1 11 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop
* 1 0 1 01 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop
* 1 0 1 10 0x 1 AP configured to accept from-ds Rx mcast from wds peers, constraint met; so, accept
* 1 0 1 00 0x 0 bad frame, won't see it
*
* 0 x x 11 xx 0 we only accept td-ds Rx frames from non-wds peers in mode.
* 0 x x 01 xx 1
* 0 x x 10 xx 0
* 0 x x 00 xx 0 bad frame, won't see it
* ------------------------------------------------
*/
fr_ds = hal_rx_mpdu_get_fr_ds(hal_soc, rx_tlv_hdr);
to_ds = hal_rx_mpdu_get_to_ds(hal_soc, rx_tlv_hdr);
rx_3addr = fr_ds ^ to_ds;
rx_4addr = fr_ds & to_ds;
if (vdev->opmode == wlan_op_mode_ap) {
if ((!txrx_peer->wds_enabled && rx_3addr && to_ds) ||
(txrx_peer->wds_enabled && !rx_mcast &&
(rx_4addr == rx_policy_ucast)) ||
(txrx_peer->wds_enabled && rx_mcast &&
(rx_4addr == rx_policy_mcast))) {
return 1;
}
} else { /* sta mode */
if ((!rx_mcast && (rx_4addr == rx_policy_ucast)) ||
(rx_mcast && (rx_4addr == rx_policy_mcast))) {
return 1;
}
}
return 0;
}
#endif
#endif /* QCA_HOST_MODE_WIFI_DISABLED */
#ifdef QCA_PEER_MULTIQ_SUPPORT
void dp_peer_reset_flowq_map(struct dp_peer *peer)
{
int i = 0;
if (!peer)
return;
for (i = 0; i < DP_PEER_AST_FLOWQ_MAX; i++) {
peer->peer_ast_flowq_idx[i].is_valid = false;
peer->peer_ast_flowq_idx[i].valid_tid_mask = false;
peer->peer_ast_flowq_idx[i].ast_idx = DP_INVALID_AST_IDX;
peer->peer_ast_flowq_idx[i].flowQ = DP_INVALID_FLOW_PRIORITY;
}
}
/**
* dp_peer_get_flowid_from_flowmask() - get flow id from flow mask
* @peer: dp peer handle
* @mask: flow mask
*
* Return: flow id
*/
static int dp_peer_get_flowid_from_flowmask(struct dp_peer *peer,
uint8_t mask)
{
if (!peer) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: Invalid peer\n", __func__);
return -1;
}
if (mask & DP_PEER_AST0_FLOW_MASK)
return DP_PEER_AST_FLOWQ_UDP;
else if (mask & DP_PEER_AST1_FLOW_MASK)
return DP_PEER_AST_FLOWQ_NON_UDP;
else if (mask & DP_PEER_AST2_FLOW_MASK)
return DP_PEER_AST_FLOWQ_HI_PRIO;
else if (mask & DP_PEER_AST3_FLOW_MASK)
return DP_PEER_AST_FLOWQ_LOW_PRIO;
return DP_PEER_AST_FLOWQ_MAX;
}
/**
* dp_peer_get_ast_valid() - get ast index valid from mask
* @mask: mask for ast valid bits
* @index: index for an ast
*
* Return: 1 if ast index is valid from mask else 0
*/
static inline bool dp_peer_get_ast_valid(uint8_t mask, uint16_t index)
{
if (index == 0)
return 1;
return ((mask) & (1 << ((index) - 1)));
}
void dp_peer_ast_index_flow_queue_map_create(void *soc_hdl,
bool is_wds, uint16_t peer_id, uint8_t *peer_mac_addr,
struct dp_ast_flow_override_info *ast_info)
{
struct dp_soc *soc = (struct dp_soc *)soc_hdl;
struct dp_peer *peer = NULL;
uint8_t i;
/*
* Ast flow override feature is supported
* only for connected client
*/
if (is_wds)
return;
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_AST);
if (!peer) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: Invalid peer\n", __func__);
return;
}
/* Valid only in AP mode */
if (peer->vdev->opmode != wlan_op_mode_ap) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: Peer ast flow map not in STA mode\n", __func__);
goto end;
}
/* Making sure the peer is for this mac address */
if (!qdf_is_macaddr_equal((struct qdf_mac_addr *)peer_mac_addr,
(struct qdf_mac_addr *)peer->mac_addr.raw)) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: Peer mac address mismatch\n", __func__);
goto end;
}
/* Ast entry flow mapping not valid for self peer map */
if (qdf_is_macaddr_equal((struct qdf_mac_addr *)peer_mac_addr,
(struct qdf_mac_addr *)peer->vdev->mac_addr.raw)) {
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"%s: Ast flow mapping not valid for self peer \n", __func__);
goto end;
}
/* Fill up ast index <---> flow id mapping table for this peer */
for (i = 0; i < DP_MAX_AST_INDEX_PER_PEER; i++) {
/* Check if this ast index is valid */
peer->peer_ast_flowq_idx[i].is_valid =
dp_peer_get_ast_valid(ast_info->ast_valid_mask, i);
if (!peer->peer_ast_flowq_idx[i].is_valid)
continue;
/* Get the flow queue id which is mapped to this ast index */
peer->peer_ast_flowq_idx[i].flowQ =
dp_peer_get_flowid_from_flowmask(peer,
ast_info->ast_flow_mask[i]);
/*
* Update tid valid mask only if flow id HIGH or
* Low priority
*/
if (peer->peer_ast_flowq_idx[i].flowQ ==
DP_PEER_AST_FLOWQ_HI_PRIO) {
peer->peer_ast_flowq_idx[i].valid_tid_mask =
ast_info->tid_valid_hi_pri_mask;
} else if (peer->peer_ast_flowq_idx[i].flowQ ==
DP_PEER_AST_FLOWQ_LOW_PRIO) {
peer->peer_ast_flowq_idx[i].valid_tid_mask =
ast_info->tid_valid_low_pri_mask;
}
/* Save the ast index for this entry */
peer->peer_ast_flowq_idx[i].ast_idx = ast_info->ast_idx[i];
}
if (soc->cdp_soc.ol_ops->peer_ast_flowid_map) {
soc->cdp_soc.ol_ops->peer_ast_flowid_map(
soc->ctrl_psoc, peer->peer_id,
peer->vdev->vdev_id, peer_mac_addr);
}
end:
/* Release peer reference */
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
}
int dp_peer_find_ast_index_by_flowq_id(struct cdp_soc_t *soc,
uint16_t vdev_id, uint8_t *peer_mac_addr,
uint8_t flow_id, uint8_t tid)
{
struct dp_peer *peer = NULL;
uint8_t i;
uint16_t ast_index;
if (flow_id >= DP_PEER_AST_FLOWQ_MAX) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"Invalid Flow ID %d\n", flow_id);
return -1;
}
peer = dp_peer_find_hash_find((struct dp_soc *)soc,
peer_mac_addr, 0, vdev_id,
DP_MOD_ID_AST);
if (!peer) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: Invalid peer\n", __func__);
return -1;
}
/*
* Loop over the ast entry <----> flow-id mapping to find
* which ast index entry has this flow queue id enabled.
*/
for (i = 0; i < DP_PEER_AST_FLOWQ_MAX; i++) {
if (peer->peer_ast_flowq_idx[i].flowQ == flow_id)
/*
* Found the matching index for this flow id
*/
break;
}
/*
* No match found for this flow id
*/
if (i == DP_PEER_AST_FLOWQ_MAX) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: ast index not found for flow %d\n", __func__, flow_id);
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return -1;
}
/* Check whether this ast entry is valid */
if (!peer->peer_ast_flowq_idx[i].is_valid) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: ast index is invalid for flow %d\n", __func__, flow_id);
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return -1;
}
if (flow_id == DP_PEER_AST_FLOWQ_HI_PRIO ||
flow_id == DP_PEER_AST_FLOWQ_LOW_PRIO) {
/*
* check if this tid is valid for Hi
* and Low priority flow id
*/
if ((peer->peer_ast_flowq_idx[i].valid_tid_mask
& (1 << tid))) {
/* Release peer reference */
ast_index = peer->peer_ast_flowq_idx[i].ast_idx;
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return ast_index;
} else {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
"%s: TID %d is not valid for flow %d\n",
__func__, tid, flow_id);
/*
* TID is not valid for this flow
* Return -1
*/
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return -1;
}
}
/*
* TID valid check not required for
* UDP/NON UDP flow id
*/
ast_index = peer->peer_ast_flowq_idx[i].ast_idx;
dp_peer_unref_delete(peer, DP_MOD_ID_AST);
return ast_index;
}
#endif
void dp_hmwds_ast_add_notify(struct dp_peer *peer,
uint8_t *mac_addr,
enum cdp_txrx_ast_entry_type type,
QDF_STATUS err,
bool is_peer_map)
{
struct dp_vdev *dp_vdev = peer->vdev;
struct dp_pdev *dp_pdev = dp_vdev->pdev;
struct cdp_peer_hmwds_ast_add_status add_status;
/* Ignore ast types other than HM */
if ((type != CDP_TXRX_AST_TYPE_WDS_HM) &&
(type != CDP_TXRX_AST_TYPE_WDS_HM_SEC))
return;
/* existing ast delete in progress, will be attempted
* to add again after delete is complete. Send status then.
*/
if (err == QDF_STATUS_E_AGAIN)
return;
/* peer map pending, notify actual status
* when peer map is received.
*/
if (!is_peer_map && (err == QDF_STATUS_SUCCESS))
return;
qdf_mem_zero(&add_status, sizeof(add_status));
add_status.vdev_id = dp_vdev->vdev_id;
/* For type CDP_TXRX_AST_TYPE_WDS_HM_SEC dp_peer_add_ast()
* returns QDF_STATUS_E_FAILURE as it is host only entry.
* In such cases set err as success. Also err code set to
* QDF_STATUS_E_ALREADY indicates entry already exist in
* such cases set err as success too. Any other error code
* is actual error.
*/
if (((type == CDP_TXRX_AST_TYPE_WDS_HM_SEC) &&
(err == QDF_STATUS_E_FAILURE)) ||
(err == QDF_STATUS_E_ALREADY)) {
err = QDF_STATUS_SUCCESS;
}
add_status.status = err;
qdf_mem_copy(add_status.peer_mac, peer->mac_addr.raw,
QDF_MAC_ADDR_SIZE);
qdf_mem_copy(add_status.ast_mac, mac_addr,
QDF_MAC_ADDR_SIZE);
#ifdef WDI_EVENT_ENABLE
dp_wdi_event_handler(WDI_EVENT_HMWDS_AST_ADD_STATUS, dp_pdev->soc,
(void *)&add_status, 0,
WDI_NO_VAL, dp_pdev->pdev_id);
#endif
}
#if defined(QCA_SUPPORT_LATENCY_CAPTURE) || \
defined(QCA_TX_CAPTURE_SUPPORT) || \
defined(QCA_MCOPY_SUPPORT)
#ifdef FEATURE_PERPKT_INFO
QDF_STATUS
dp_get_completion_indication_for_stack(struct dp_soc *soc,
struct dp_pdev *pdev,
struct dp_txrx_peer *txrx_peer,
struct hal_tx_completion_status *ts,
qdf_nbuf_t netbuf,
uint64_t time_latency)
{
struct tx_capture_hdr *ppdu_hdr;
uint16_t peer_id = ts->peer_id;
uint32_t ppdu_id = ts->ppdu_id;
uint8_t first_msdu = ts->first_msdu;
uint8_t last_msdu = ts->last_msdu;
uint32_t txcap_hdr_size = sizeof(struct tx_capture_hdr);
struct dp_peer *peer;
if (qdf_unlikely(!dp_monitor_is_enable_tx_sniffer(pdev) &&
!dp_monitor_is_enable_mcopy_mode(pdev) &&
!pdev->latency_capture_enable))
return QDF_STATUS_E_NOSUPPORT;
if (!txrx_peer) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("txrx_peer is NULL"));
return QDF_STATUS_E_INVAL;
}
/* If mcopy is enabled and mcopy_mode is M_COPY deliver 1st MSDU
* per PPDU. If mcopy_mode is M_COPY_EXTENDED deliver 1st MSDU
* for each MPDU
*/
if (dp_monitor_mcopy_check_deliver(pdev,
peer_id,
ppdu_id,
first_msdu) != QDF_STATUS_SUCCESS)
return QDF_STATUS_E_INVAL;
if (qdf_unlikely(qdf_nbuf_headroom(netbuf) < txcap_hdr_size)) {
netbuf = qdf_nbuf_realloc_headroom(netbuf, txcap_hdr_size);
if (!netbuf) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("No headroom"));
return QDF_STATUS_E_NOMEM;
}
}
if (!qdf_nbuf_push_head(netbuf, txcap_hdr_size)) {
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
FL("No headroom"));
return QDF_STATUS_E_NOMEM;
}
ppdu_hdr = (struct tx_capture_hdr *)qdf_nbuf_data(netbuf);
qdf_mem_copy(ppdu_hdr->ta, txrx_peer->vdev->mac_addr.raw,
QDF_MAC_ADDR_SIZE);
peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_TX_COMP);
if (peer) {
qdf_mem_copy(ppdu_hdr->ra, peer->mac_addr.raw,
QDF_MAC_ADDR_SIZE);
dp_peer_unref_delete(peer, DP_MOD_ID_TX_COMP);
}
ppdu_hdr->ppdu_id = ppdu_id;
ppdu_hdr->peer_id = peer_id;
ppdu_hdr->first_msdu = first_msdu;
ppdu_hdr->last_msdu = last_msdu;
if (qdf_unlikely(pdev->latency_capture_enable)) {
ppdu_hdr->tsf = ts->tsf;
ppdu_hdr->time_latency = (uint32_t)time_latency;
}
return QDF_STATUS_SUCCESS;
}
void dp_send_completion_to_stack(struct dp_soc *soc, struct dp_pdev *pdev,
uint16_t peer_id, uint32_t ppdu_id,
qdf_nbuf_t netbuf)
{
dp_wdi_event_handler(WDI_EVENT_TX_DATA, soc,
netbuf, peer_id,
WDI_NO_VAL, pdev->pdev_id);
}
#endif
#endif