From b34c7b7c45e42326de83a91aa1e60d5f1d5e4321 Mon Sep 17 00:00:00 2001 From: karuna Date: Thu, 9 Mar 2017 13:05:15 +0530 Subject: [PATCH 1/5] qcacmn: Add print functions to print HTT EXT TLVS Read the TAG type from the buffer and call the corresponding TLV display function CRs-Fixed: 1114641 Change-Id: Ifec04b87af84229754f598fffa689979ff253f12 --- dp/wifi3.0/dp_stats.c | 2814 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 2687 insertions(+), 127 deletions(-) diff --git a/dp/wifi3.0/dp_stats.c b/dp/wifi3.0/dp_stats.c index 48594841ac40..6ca0df8535d0 100644 --- a/dp/wifi3.0/dp_stats.c +++ b/dp/wifi3.0/dp_stats.c @@ -22,155 +22,160 @@ #define DP_MAX_STRING_LEN 500 -/* these values are fixed in the next gerrit */ -#define DP_HTT_DATA_LEN 1 -#define DP_HTT_URRN_STATS_LEN 1 -#define DP_HTT_FLUSH_ERRS_LEN 1 -#define DP_HTT_SIFS_STATUS_LEN 1 -#define DP_HTT_PHY_ERRS_LEN 1 #define DP_HTT_HW_INTR_NAME_LEN HTT_STATS_MAX_HW_INTR_NAME_LEN #define DP_HTT_HW_MODULE_NAME_LEN HTT_STATS_MAX_HW_MODULE_NAME_LEN #define DP_HTT_COUNTER_NAME_LEN HTT_MAX_COUNTER_NAME -#define DP_HTT_PEER_DETAILS_LEN 1 -#define DP_HTT_MU_MIMO_SCH_STATS_TLV_LEN 1 -#define DP_HTT_MU_MIMO_MPDU_STATS_TLV_LEN 1 -#define DP_HTT_DIFS_LATENCY_HIST_LEN 1 -#define DP_HTT_CMD_RESULT_LEN 1 -#define DP_HTT_CMD_STALL_STATUS_LEN 1 -#define DP_HTT_FES_RESULT_LEN 1 -#define DP_HTT_SCHED_CMD_POSTED_LEN 1 -#define DP_HTT_SCHED_CMD_REAPED_LEN 1 -#define DP_HTT_GEN_MPDU_END_REASON_LEN 1 -#define DP_HTT_LIST_MPDU_END_REASON_LEN 1 -#define DP_HTT_LIST_MPDU_CNT_HIST_LEN 1 #define DP_HTT_LOW_WM_HIT_COUNT_LEN HTT_STATS_LOW_WM_BINS #define DP_HTT_HIGH_WM_HIT_COUNT_LEN HTT_STATS_HIGH_WM_BINS -#define DP_HTT_DWORDS_USED_BY_USER_N_LEN 1 #define DP_HTT_TX_MCS_LEN HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_TX_SU_MCS_LEN HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_TX_MU_MCS_LEN HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_TX_NSS_LEN HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS #define DP_HTT_TX_BW_LEN HTT_TX_PDEV_STATS_NUM_BW_COUNTERS -#define DP_HTT_TX_STBC_LEN HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_TX_PREAM_LEN HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES -#define DP_HTT_TX_GI_LEN HTT_TX_PDEV_STATS_NUM_GI_COUNTERS +#define DP_HTT_TX_PDEV_GI_LEN HTT_TX_PDEV_STATS_NUM_GI_COUNTERS #define DP_HTT_TX_DCM_LEN HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS #define DP_HTT_RX_MCS_LEN HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_RX_NSS_LEN HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS #define DP_HTT_RX_DCM_LEN HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS -#define DP_HTT_RX_STBC_LEN HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS #define DP_HTT_RX_BW_LEN HTT_RX_PDEV_STATS_NUM_BW_COUNTERS #define DP_HTT_RX_PREAM_LEN HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES #define DP_HTT_RSSI_CHAIN_LEN HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS #define DP_HTT_RX_GI_LEN HTT_RX_PDEV_STATS_NUM_GI_COUNTERS -#define DP_HTT_REFILL_RING_EMPTY_CNT_LEN 1 -#define DP_HTT_REFILL_RING_NUM_REFILL_LEN 1 #define DP_HTT_FW_RING_MGMT_SUBTYPE_LEN HTT_STATS_SUBTYPE_MAX #define DP_HTT_FW_RING_CTRL_SUBTYPE_LEN HTT_STATS_SUBTYPE_MAX #define DP_HTT_FW_RING_MPDU_ERR_LEN HTT_RX_STATS_RXDMA_MAX_ERR -#define DP_HTT_FW_MPDU_DROP_LEN 1 #define DP_HTT_TID_NAME_LEN MAX_HTT_TID_NAME +#define DP_HTT_PEER_NUM_SS HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS +#define DP_HTT_PDEV_TX_GI_LEN HTT_TX_PDEV_STATS_NUM_GI_COUNTERS -/* TODO:Below stat function is for initial testing - * Further functions will be added after reviews on the FW side are complete +/* + * dp_print_stats_string_tlv: display htt_stats_string_tlv + * @tag_buf: buffer containing the tlv htt_stats_string_tlv + * + * return:void */ +static inline void dp_print_stats_string_tlv(uint32_t *tag_buf) +{ + htt_stats_string_tlv *dp_stats_buf = + (htt_stats_string_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char data[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); -/** + DP_TRACE_STATS(FATAL, "HTT_STATS_STRING_TLV:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&data[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->data[i]); + } + DP_TRACE_STATS(FATAL, "data = %s\n", data); +} + +/* * dp_print_tx_pdev_stats_cmn_tlv: display htt_tx_pdev_stats_cmn_tlv - * @dp_htt_tag:pointer to structure htt_tx_pdev_stats_cmn_tlv + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_cmn_tlv * * return:void */ static inline void dp_print_tx_pdev_stats_cmn_tlv(uint32_t *tag_buf) { - htt_tx_pdev_stats_cmn_tlv *dp_htt_tag = + htt_tx_pdev_stats_cmn_tlv *dp_stats_buf = (htt_tx_pdev_stats_cmn_tlv *)tag_buf; - DP_TRACE_STATS(NONE, "Pdev Stats:\n"); - DP_TRACE_STATS(NONE, "mac_id__word = %d", - dp_htt_tag->mac_id__word); - DP_TRACE_STATS(NONE, "hw_queued = %d", - dp_htt_tag->hw_queued); - DP_TRACE_STATS(NONE, "hw_reaped = %d", - dp_htt_tag->hw_reaped); - DP_TRACE_STATS(NONE, "underrun = %d", - dp_htt_tag->underrun); - DP_TRACE_STATS(NONE, "hw_paused = %d", - dp_htt_tag->hw_paused); - DP_TRACE_STATS(NONE, "hw_flush = %d", - dp_htt_tag->hw_flush); - DP_TRACE_STATS(NONE, "hw_filt = %d", - dp_htt_tag->hw_filt); - DP_TRACE_STATS(NONE, "tx_abort = %d", - dp_htt_tag->tx_abort); - DP_TRACE_STATS(NONE, "mpdu_requeued = %d", - dp_htt_tag->mpdu_requed); - DP_TRACE_STATS(NONE, "tx_xretry = %d", - dp_htt_tag->tx_xretry); - DP_TRACE_STATS(NONE, "data_rc = %d", - dp_htt_tag->data_rc); - DP_TRACE_STATS(NONE, "mpdu_dropped_xretry = %d", - dp_htt_tag->mpdu_dropped_xretry); - DP_TRACE_STATS(NONE, "illegal_rate_phy_err = %d", - dp_htt_tag->illgl_rate_phy_err); - DP_TRACE_STATS(NONE, "cont_xretry = %d", - dp_htt_tag->cont_xretry); - DP_TRACE_STATS(NONE, "tx_timeout = %d", - dp_htt_tag->tx_timeout); - DP_TRACE_STATS(NONE, "pdev_resets = %d", - dp_htt_tag->pdev_resets); - DP_TRACE_STATS(NONE, "phy_underrun = %d", - dp_htt_tag->phy_underrun); - DP_TRACE_STATS(NONE, "txop_ovf = %d", - dp_htt_tag->txop_ovf); - DP_TRACE_STATS(NONE, "seq_posted = %d", - dp_htt_tag->seq_posted); - DP_TRACE_STATS(NONE, "seq_failed_queueing = %d", - dp_htt_tag->seq_failed_queueing); - DP_TRACE_STATS(NONE, "seq_completed = %d", - dp_htt_tag->seq_completed); - DP_TRACE_STATS(NONE, "seq_restarted = %d", - dp_htt_tag->seq_restarted); - DP_TRACE_STATS(NONE, "mu_seq_posted = %d", - dp_htt_tag->mu_seq_posted); - DP_TRACE_STATS(NONE, "mpdu_count_tqm = %d", - dp_htt_tag->mpdu_count_tqm); - DP_TRACE_STATS(NONE, "msdu_count_tqm = %d", - dp_htt_tag->msdu_count_tqm); - DP_TRACE_STATS(NONE, "mpdu_removed_tqm = %d", - dp_htt_tag->mpdu_removed_tqm); - DP_TRACE_STATS(NONE, "msdu_removed_tqm = %d", - dp_htt_tag->msdu_removed_tqm); - DP_TRACE_STATS(NONE, "mpdus_sw_flush = %d", - dp_htt_tag->mpdus_sw_flush); - DP_TRACE_STATS(NONE, "mpdus_hw_filter = %d", - dp_htt_tag->mpdus_hw_filter); - DP_TRACE_STATS(NONE, "mpdus_truncated = %d", - dp_htt_tag->mpdus_truncated); - DP_TRACE_STATS(NONE, "mpdus_ack_failed = %d", - dp_htt_tag->mpdus_ack_failed); - DP_TRACE_STATS(NONE, "mpdus_expired = %d", - dp_htt_tag->mpdus_expired); - DP_TRACE_STATS(NONE, "mpdus_seq_hw_retry = %d", - dp_htt_tag->mpdus_seq_hw_retry); - DP_TRACE_STATS(NONE, "ack_tlv_proc = %d", - dp_htt_tag->ack_tlv_proc); - DP_TRACE_STATS(NONE, "coex_abort_mpdu_cnt_valid = %d", - dp_htt_tag-> - coex_abort_mpdu_cnt_valid); - DP_TRACE_STATS(NONE, "coex_abort_mpdu_cnt = %d", - dp_htt_tag->coex_abort_mpdu_cnt); + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "hw_queued = %d", + dp_stats_buf->hw_queued); + DP_TRACE_STATS(FATAL, "hw_reaped = %d", + dp_stats_buf->hw_reaped); + DP_TRACE_STATS(FATAL, "underrun = %d", + dp_stats_buf->underrun); + DP_TRACE_STATS(FATAL, "hw_paused = %d", + dp_stats_buf->hw_paused); + DP_TRACE_STATS(FATAL, "hw_flush = %d", + dp_stats_buf->hw_flush); + DP_TRACE_STATS(FATAL, "hw_filt = %d", + dp_stats_buf->hw_filt); + DP_TRACE_STATS(FATAL, "tx_abort = %d", + dp_stats_buf->tx_abort); + DP_TRACE_STATS(FATAL, "mpdu_requeued = %d", + dp_stats_buf->mpdu_requed); + DP_TRACE_STATS(FATAL, "tx_xretry = %d", + dp_stats_buf->tx_xretry); + DP_TRACE_STATS(FATAL, "data_rc = %d", + dp_stats_buf->data_rc); + DP_TRACE_STATS(FATAL, "mpdu_dropped_xretry = %d", + dp_stats_buf->mpdu_dropped_xretry); + DP_TRACE_STATS(FATAL, "illegal_rate_phy_err = %d", + dp_stats_buf->illgl_rate_phy_err); + DP_TRACE_STATS(FATAL, "cont_xretry = %d", + dp_stats_buf->cont_xretry); + DP_TRACE_STATS(FATAL, "tx_timeout = %d", + dp_stats_buf->tx_timeout); + DP_TRACE_STATS(FATAL, "pdev_resets = %d", + dp_stats_buf->pdev_resets); + DP_TRACE_STATS(FATAL, "phy_underrun = %d", + dp_stats_buf->phy_underrun); + DP_TRACE_STATS(FATAL, "txop_ovf = %d", + dp_stats_buf->txop_ovf); + DP_TRACE_STATS(FATAL, "seq_posted = %d", + dp_stats_buf->seq_posted); + DP_TRACE_STATS(FATAL, "seq_failed_queueing = %d", + dp_stats_buf->seq_failed_queueing); + DP_TRACE_STATS(FATAL, "seq_completed = %d", + dp_stats_buf->seq_completed); + DP_TRACE_STATS(FATAL, "seq_restarted = %d", + dp_stats_buf->seq_restarted); + DP_TRACE_STATS(FATAL, "mu_seq_posted = %d", + dp_stats_buf->mu_seq_posted); + DP_TRACE_STATS(FATAL, "seq_switch_hw_paused = %d", + dp_stats_buf->seq_switch_hw_paused); + DP_TRACE_STATS(FATAL, "next_seq_posted_dsr = %d", + dp_stats_buf->next_seq_posted_dsr); + DP_TRACE_STATS(FATAL, "seq_posted_isr = %d", + dp_stats_buf->seq_posted_isr); + DP_TRACE_STATS(FATAL, "seq_ctrl_cached = %d", + dp_stats_buf->seq_ctrl_cached); + DP_TRACE_STATS(FATAL, "mpdu_count_tqm = %d", + dp_stats_buf->mpdu_count_tqm); + DP_TRACE_STATS(FATAL, "msdu_count_tqm = %d", + dp_stats_buf->msdu_count_tqm); + DP_TRACE_STATS(FATAL, "mpdu_removed_tqm = %d", + dp_stats_buf->mpdu_removed_tqm); + DP_TRACE_STATS(FATAL, "msdu_removed_tqm = %d", + dp_stats_buf->msdu_removed_tqm); + DP_TRACE_STATS(FATAL, "mpdus_sw_flush = %d", + dp_stats_buf->mpdus_sw_flush); + DP_TRACE_STATS(FATAL, "mpdus_hw_filter = %d", + dp_stats_buf->mpdus_hw_filter); + DP_TRACE_STATS(FATAL, "mpdus_truncated = %d", + dp_stats_buf->mpdus_truncated); + DP_TRACE_STATS(FATAL, "mpdus_ack_failed = %d", + dp_stats_buf->mpdus_ack_failed); + DP_TRACE_STATS(FATAL, "mpdus_expired = %d", + dp_stats_buf->mpdus_expired); + DP_TRACE_STATS(FATAL, "mpdus_seq_hw_retry = %d", + dp_stats_buf->mpdus_seq_hw_retry); + DP_TRACE_STATS(FATAL, "ack_tlv_proc = %d", + dp_stats_buf->ack_tlv_proc); + DP_TRACE_STATS(FATAL, "coex_abort_mpdu_cnt_valid = %d", + dp_stats_buf->coex_abort_mpdu_cnt_valid); + DP_TRACE_STATS(FATAL, "coex_abort_mpdu_cnt = %d\n", + dp_stats_buf->coex_abort_mpdu_cnt); } -/** +/* * dp_print_tx_pdev_stats_urrn_tlv_v: display htt_tx_pdev_stats_urrn_tlv_v - * @tag_buf: buffer containing the tlv + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_urrn_tlv_v * * return:void */ static inline void dp_print_tx_pdev_stats_urrn_tlv_v(uint32_t *tag_buf) { - htt_tx_pdev_stats_urrn_tlv_v *dp_htt_tag = + htt_tx_pdev_stats_urrn_tlv_v *dp_stats_buf = (htt_tx_pdev_stats_urrn_tlv_v *)tag_buf; uint8_t i; uint16_t index = 0; @@ -178,65 +183,2369 @@ static inline void dp_print_tx_pdev_stats_urrn_tlv_v(uint32_t *tag_buf) uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_MAX_URRN_STATS); - DP_TRACE_STATS(NONE, "Pdev Underun Stats:\n"); - for (i = 0; i < tag_len; i++) { + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_URRN_TLV_V:"); + for (i = 0; i < tag_len; i++) { index += qdf_snprint(&urrn_stats[index], - DP_MAX_STRING_LEN - index, " %d,", - dp_htt_tag->urrn_stats[i]); + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->urrn_stats[i]); } - DP_TRACE_STATS(NONE, "urrn_stats = %s", urrn_stats); + DP_TRACE_STATS(FATAL, "urrn_stats = %s\n", urrn_stats); } /* * dp_print_tx_pdev_stats_flush_tlv_v: display htt_tx_pdev_stats_flush_tlv_v - * @tag_buf: buffer containing the tlv * + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_flush_tlv_v + * * return:void */ static inline void dp_print_tx_pdev_stats_flush_tlv_v(uint32_t *tag_buf) { - htt_tx_pdev_stats_flush_tlv_v *dp_htt_tag = + htt_tx_pdev_stats_flush_tlv_v *dp_stats_buf = (htt_tx_pdev_stats_flush_tlv_v *)tag_buf; uint8_t i; - uint8_t index = 0; + uint16_t index = 0; char flush_errs[DP_MAX_STRING_LEN]; uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_MAX_FLUSH_REASON_STATS); - DP_TRACE_STATS(NONE, "Pdev Flush Stats:\n"); + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_FLUSH_TLV_V:"); for (i = 0; i < tag_len; i++) { index += qdf_snprint(&flush_errs[index], - DP_MAX_STRING_LEN - index, " %d,", - dp_htt_tag->flush_errs[i]); + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->flush_errs[i]); } - DP_TRACE_STATS(NONE, "flush_errs = %s ", flush_errs); + DP_TRACE_STATS(FATAL, "flush_errs = %s\n", flush_errs); } /* * dp_print_tx_pdev_stats_sifs_tlv_v: display htt_tx_pdev_stats_sifs_tlv_v - * @tag_buf: buffer containing the tlv * + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_sifs_tlv_v + * * return:void */ static inline void dp_print_tx_pdev_stats_sifs_tlv_v(uint32_t *tag_buf) { - htt_tx_pdev_stats_sifs_tlv_v *dp_htt_tag = + htt_tx_pdev_stats_sifs_tlv_v *dp_stats_buf = (htt_tx_pdev_stats_sifs_tlv_v *)tag_buf; uint8_t i; - uint8_t index = 0; + uint16_t index = 0; char sifs_status[DP_MAX_STRING_LEN]; uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_MAX_SIFS_BURST_STATS); - DP_TRACE_STATS(NONE, "Pdev SIFS Stats:\n"); + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_SIFS_TLV_V:"); for (i = 0; i < tag_len; i++) { index += qdf_snprint(&sifs_status[index], - DP_MAX_STRING_LEN - index, " %d,", - dp_htt_tag->sifs_status[i]); + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->sifs_status[i]); } - DP_TRACE_STATS(NONE, "sifs_status = %s ", sifs_status); + DP_TRACE_STATS(FATAL, "sifs_status = %s\n", sifs_status); } -/** +/* + * dp_print_tx_pdev_stats_phy_err_tlv_v: display htt_tx_pdev_stats_phy_err_tlv_v + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_phy_err_tlv_v + * + * return:void + */ +static inline void dp_print_tx_pdev_stats_phy_err_tlv_v(uint32_t *tag_buf) +{ + htt_tx_pdev_stats_phy_err_tlv_v *dp_stats_buf = + (htt_tx_pdev_stats_phy_err_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char phy_errs[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_MAX_PHY_ERR_STATS); + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_PHY_ERR_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&phy_errs[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->phy_errs[i]); + } + DP_TRACE_STATS(FATAL, "phy_errs = %s\n", phy_errs); +} + +/* + * dp_print_hw_stats_intr_misc_tlv: display htt_hw_stats_intr_misc_tlv + * @tag_buf: buffer containing the tlv htt_hw_stats_intr_misc_tlv + * + * return:void + */ +static inline void dp_print_hw_stats_intr_misc_tlv(uint32_t *tag_buf) +{ + htt_hw_stats_intr_misc_tlv *dp_stats_buf = + (htt_hw_stats_intr_misc_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char hw_intr_name[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_HW_STATS_INTR_MISC_TLV:"); + for (i = 0; i < DP_HTT_HW_INTR_NAME_LEN; i++) { + index += qdf_snprint(&hw_intr_name[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->hw_intr_name[i]); + } + DP_TRACE_STATS(FATAL, "hw_intr_name = %s ", hw_intr_name); + DP_TRACE_STATS(FATAL, "mask = %d", + dp_stats_buf->mask); + DP_TRACE_STATS(FATAL, "count = %d\n", + dp_stats_buf->count); +} + +/* + * dp_print_hw_stats_wd_timeout_tlv: display htt_hw_stats_wd_timeout_tlv + * @tag_buf: buffer containing the tlv htt_hw_stats_wd_timeout_tlv + * + * return:void + */ +static inline void dp_print_hw_stats_wd_timeout_tlv(uint32_t *tag_buf) +{ + htt_hw_stats_wd_timeout_tlv *dp_stats_buf = + (htt_hw_stats_wd_timeout_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char hw_module_name[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_HW_STATS_WD_TIMEOUT_TLV:"); + for (i = 0; i < DP_HTT_HW_MODULE_NAME_LEN; i++) { + index += qdf_snprint(&hw_module_name[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->hw_module_name[i]); + } + DP_TRACE_STATS(FATAL, "hw_module_name = %s ", hw_module_name); + DP_TRACE_STATS(FATAL, "count = %d", + dp_stats_buf->count); +} + +/* + * dp_print_hw_stats_pdev_errs_tlv: display htt_hw_stats_pdev_errs_tlv + * @tag_buf: buffer containing the tlv htt_hw_stats_pdev_errs_tlv + * + * return:void + */ +static inline void dp_print_hw_stats_pdev_errs_tlv(uint32_t *tag_buf) +{ + htt_hw_stats_pdev_errs_tlv *dp_stats_buf = + (htt_hw_stats_pdev_errs_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_HW_STATS_PDEV_ERRS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "tx_abort = %d", + dp_stats_buf->tx_abort); + DP_TRACE_STATS(FATAL, "tx_abort_fail_count = %d", + dp_stats_buf->tx_abort_fail_count); + DP_TRACE_STATS(FATAL, "rx_abort = %d", + dp_stats_buf->rx_abort); + DP_TRACE_STATS(FATAL, "rx_abort_fail_count = %d", + dp_stats_buf->rx_abort_fail_count); + DP_TRACE_STATS(FATAL, "warm_reset = %d", + dp_stats_buf->warm_reset); + DP_TRACE_STATS(FATAL, "cold_reset = %d", + dp_stats_buf->cold_reset); + DP_TRACE_STATS(FATAL, "tx_flush = %d", + dp_stats_buf->tx_flush); + DP_TRACE_STATS(FATAL, "tx_glb_reset = %d", + dp_stats_buf->tx_glb_reset); + DP_TRACE_STATS(FATAL, "tx_txq_reset = %d", + dp_stats_buf->tx_txq_reset); + DP_TRACE_STATS(FATAL, "rx_timeout_reset = %d\n", + dp_stats_buf->rx_timeout_reset); +} + +/* + * dp_print_msdu_flow_stats_tlv: display htt_msdu_flow_stats_tlv + * @tag_buf: buffer containing the tlv htt_msdu_flow_stats_tlv + * + * return:void + */ +static inline void dp_print_msdu_flow_stats_tlv(uint32_t *tag_buf) +{ + htt_msdu_flow_stats_tlv *dp_stats_buf = + (htt_msdu_flow_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_MSDU_FLOW_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "last_update_timestamp = %d", + dp_stats_buf->last_update_timestamp); + DP_TRACE_STATS(FATAL, "last_add_timestamp = %d", + dp_stats_buf->last_add_timestamp); + DP_TRACE_STATS(FATAL, "last_remove_timestamp = %d", + dp_stats_buf->last_remove_timestamp); + DP_TRACE_STATS(FATAL, "total_processed_msdu_count = %d", + dp_stats_buf->total_processed_msdu_count); + DP_TRACE_STATS(FATAL, "cur_msdu_count_in_flowq = %d", + dp_stats_buf->cur_msdu_count_in_flowq); + DP_TRACE_STATS(FATAL, "sw_peer_id = %d", + dp_stats_buf->sw_peer_id); + DP_TRACE_STATS(FATAL, "tx_flow_no__tid_num__drop_rule = %d\n", + dp_stats_buf->tx_flow_no__tid_num__drop_rule); +} + +/* + * dp_print_tx_tid_stats_tlv: display htt_tx_tid_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_tid_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_tid_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_tid_stats_tlv *dp_stats_buf = + (htt_tx_tid_stats_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char tid_name[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_TX_TID_STATS_TLV:"); + for (i = 0; i < DP_HTT_TID_NAME_LEN; i++) { + index += qdf_snprint(&tid_name[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tid_name[i]); + } + DP_TRACE_STATS(FATAL, "tid_name = %s ", tid_name); + DP_TRACE_STATS(FATAL, "sw_peer_id__tid_num = %d", + dp_stats_buf->sw_peer_id__tid_num); + DP_TRACE_STATS(FATAL, "num_sched_pending__num_ppdu_in_hwq = %d", + dp_stats_buf->num_sched_pending__num_ppdu_in_hwq); + DP_TRACE_STATS(FATAL, "tid_flags = %d", + dp_stats_buf->tid_flags); + DP_TRACE_STATS(FATAL, "hw_queued = %d", + dp_stats_buf->hw_queued); + DP_TRACE_STATS(FATAL, "hw_reaped = %d", + dp_stats_buf->hw_reaped); + DP_TRACE_STATS(FATAL, "mpdus_hw_filter = %d", + dp_stats_buf->mpdus_hw_filter); + DP_TRACE_STATS(FATAL, "qdepth_bytes = %d", + dp_stats_buf->qdepth_bytes); + DP_TRACE_STATS(FATAL, "qdepth_num_msdu = %d", + dp_stats_buf->qdepth_num_msdu); + DP_TRACE_STATS(FATAL, "qdepth_num_mpdu = %d", + dp_stats_buf->qdepth_num_mpdu); + DP_TRACE_STATS(FATAL, "last_scheduled_tsmp = %d", + dp_stats_buf->last_scheduled_tsmp); + DP_TRACE_STATS(FATAL, "pause_module_id = %d", + dp_stats_buf->pause_module_id); + DP_TRACE_STATS(FATAL, "block_module_id = %d\n", + dp_stats_buf->block_module_id); +} + +/* + * dp_print_rx_tid_stats_tlv: display htt_rx_tid_stats_tlv + * @tag_buf: buffer containing the tlv htt_rx_tid_stats_tlv + * + * return:void + */ +static inline void dp_print_rx_tid_stats_tlv(uint32_t *tag_buf) +{ + htt_rx_tid_stats_tlv *dp_stats_buf = + (htt_rx_tid_stats_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char tid_name[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_RX_TID_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "sw_peer_id__tid_num = %d", + dp_stats_buf->sw_peer_id__tid_num); + for (i = 0; i < DP_HTT_TID_NAME_LEN; i++) { + index += qdf_snprint(&tid_name[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tid_name[i]); + } + DP_TRACE_STATS(FATAL, "tid_name = %s ", tid_name); + DP_TRACE_STATS(FATAL, "dup_in_reorder = %d", + dp_stats_buf->dup_in_reorder); + DP_TRACE_STATS(FATAL, "dup_past_outside_window = %d", + dp_stats_buf->dup_past_outside_window); + DP_TRACE_STATS(FATAL, "dup_past_within_window = %d", + dp_stats_buf->dup_past_within_window); + DP_TRACE_STATS(FATAL, "rxdesc_err_decrypt = %d\n", + dp_stats_buf->rxdesc_err_decrypt); +} + +/* + * dp_print_counter_tlv: display htt_counter_tlv + * @tag_buf: buffer containing the tlv htt_counter_tlv + * + * return:void + */ +static inline void dp_print_counter_tlv(uint32_t *tag_buf) +{ + htt_counter_tlv *dp_stats_buf = + (htt_counter_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char counter_name[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_COUNTER_TLV:"); + for (i = 0; i < DP_HTT_COUNTER_NAME_LEN; i++) { + index += qdf_snprint(&counter_name[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->counter_name[i]); + } + DP_TRACE_STATS(FATAL, "counter_name = %s ", counter_name); + DP_TRACE_STATS(FATAL, "count = %d\n", + dp_stats_buf->count); +} + +/* + * dp_print_peer_stats_cmn_tlv: display htt_peer_stats_cmn_tlv + * @tag_buf: buffer containing the tlv htt_peer_stats_cmn_tlv + * + * return:void + */ +static inline void dp_print_peer_stats_cmn_tlv(uint32_t *tag_buf) +{ + htt_peer_stats_cmn_tlv *dp_stats_buf = + (htt_peer_stats_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_PEER_STATS_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "ppdu_cnt = %d", + dp_stats_buf->ppdu_cnt); + DP_TRACE_STATS(FATAL, "mpdu_cnt = %d", + dp_stats_buf->mpdu_cnt); + DP_TRACE_STATS(FATAL, "msdu_cnt = %d", + dp_stats_buf->msdu_cnt); + DP_TRACE_STATS(FATAL, "pause_bitmap = %d", + dp_stats_buf->pause_bitmap); + DP_TRACE_STATS(FATAL, "block_bitmap = %d", + dp_stats_buf->block_bitmap); + DP_TRACE_STATS(FATAL, "current_timestamp = %d\n", + dp_stats_buf->current_timestamp); +} + +/* + * dp_print_peer_details_tlv: display htt_peer_details_tlv + * @tag_buf: buffer containing the tlv htt_peer_details_tlv + * + * return:void + */ +static inline void dp_print_peer_details_tlv(uint32_t *tag_buf) +{ + htt_peer_details_tlv *dp_stats_buf = + (htt_peer_details_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_PEER_DETAILS_TLV:"); + DP_TRACE_STATS(FATAL, "peer_type = %d", + dp_stats_buf->peer_type); + DP_TRACE_STATS(FATAL, "sw_peer_id = %d", + dp_stats_buf->sw_peer_id); + DP_TRACE_STATS(FATAL, "vdev_pdev_ast_idx = %d", + dp_stats_buf->vdev_pdev_ast_idx); + DP_TRACE_STATS(FATAL, "mac_addr(upper 4 bytes) = %d", + dp_stats_buf->mac_addr.mac_addr31to0); + DP_TRACE_STATS(FATAL, "mac_addr(lower 2 bytes) = %d", + dp_stats_buf->mac_addr.mac_addr47to32); + DP_TRACE_STATS(FATAL, "peer_flags = %d", + dp_stats_buf->peer_flags); + DP_TRACE_STATS(FATAL, "qpeer_flags = %d\n", + dp_stats_buf->qpeer_flags); +} + +/* + * dp_print_tx_peer_rate_stats_tlv: display htt_tx_peer_rate_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_peer_rate_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_peer_rate_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_peer_rate_stats_tlv *dp_stats_buf = + (htt_tx_peer_rate_stats_tlv *)tag_buf; + uint8_t i, j; + uint16_t index = 0; + char str_buf[DP_MAX_STRING_LEN]; + char *tx_gi[HTT_TX_PEER_STATS_NUM_GI_COUNTERS]; + + for (i = 0; i < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; i++) + tx_gi[i] = (char *)qdf_mem_malloc(DP_MAX_STRING_LEN); + + DP_TRACE_STATS(FATAL, "HTT_TX_PEER_RATE_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "tx_ldpc = %d", + dp_stats_buf->tx_ldpc); + DP_TRACE_STATS(FATAL, "rts_cnt = %d", + dp_stats_buf->rts_cnt); + DP_TRACE_STATS(FATAL, "ack_rssi = %d", + dp_stats_buf->ack_rssi); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_SU_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_su_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_su_mcs = %s ", str_buf); + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_MU_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_mu_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_mu_mcs = %s ", str_buf); + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_NSS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_nss[i]); + } + DP_TRACE_STATS(FATAL, "tx_nss = %s ", str_buf); + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_BW_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_bw[i]); + } + DP_TRACE_STATS(FATAL, "tx_bw = %s ", str_buf); + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_stbc[i]); + } + DP_TRACE_STATS(FATAL, "tx_stbc = %s ", str_buf); + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + + for (i = 0; i < DP_HTT_TX_PREAM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_pream[i]); + } + DP_TRACE_STATS(FATAL, "tx_pream = %s ", str_buf); + + for (j = 0; j < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; j++) { + index = 0; + for (i = 0; i < HTT_TX_PEER_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&tx_gi[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->tx_gi[j][i]); + } + DP_TRACE_STATS(FATAL, "tx_gi[%d] = %s ", j, tx_gi[j]); + } + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_DCM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_dcm[i]); + } + DP_TRACE_STATS(FATAL, "tx_dcm = %s\n", str_buf); + for (i = 0; i < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; i++) + qdf_mem_free(tx_gi[i]); +} + +/* + * dp_print_rx_peer_rate_stats_tlv: display htt_rx_peer_rate_stats_tlv + * @tag_buf: buffer containing the tlv htt_rx_peer_rate_stats_tlv + * + * return:void + */ +static inline void dp_print_rx_peer_rate_stats_tlv(uint32_t *tag_buf) +{ + htt_rx_peer_rate_stats_tlv *dp_stats_buf = + (htt_rx_peer_rate_stats_tlv *)tag_buf; + uint8_t i, j; + uint16_t index = 0; + char *rssi_chain[DP_HTT_PEER_NUM_SS]; + char *rx_gi[HTT_RX_PEER_STATS_NUM_GI_COUNTERS]; + char str_buf[DP_MAX_STRING_LEN]; + + for (i = 0; i < DP_HTT_PEER_NUM_SS; i++) + rssi_chain[i] = qdf_mem_malloc(DP_MAX_STRING_LEN); + for (i = 0; i < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; i++) + rx_gi[i] = qdf_mem_malloc(DP_MAX_STRING_LEN); + + DP_TRACE_STATS(FATAL, "HTT_RX_PEER_RATE_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "nsts = %d", + dp_stats_buf->nsts); + DP_TRACE_STATS(FATAL, "rx_ldpc = %d", + dp_stats_buf->rx_ldpc); + DP_TRACE_STATS(FATAL, "rts_cnt = %d", + dp_stats_buf->rts_cnt); + DP_TRACE_STATS(FATAL, "rssi_mgmt = %d", + dp_stats_buf->rssi_mgmt); + DP_TRACE_STATS(FATAL, "rssi_data = %d", + dp_stats_buf->rssi_data); + DP_TRACE_STATS(FATAL, "rssi_comb = %d", + dp_stats_buf->rssi_comb); + + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_mcs[i]); + } + DP_TRACE_STATS(FATAL, "rx_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_NSS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_nss[i]); + } + DP_TRACE_STATS(FATAL, "rx_nss = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_DCM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_dcm[i]); + } + DP_TRACE_STATS(FATAL, "rx_dcm = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_stbc[i]); + } + DP_TRACE_STATS(FATAL, "rx_stbc = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_BW_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_bw[i]); + } + DP_TRACE_STATS(FATAL, "rx_bw = %s ", str_buf); + + for (j = 0; j < DP_HTT_PEER_NUM_SS; j++) { + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + index = 0; + for (i = 0; i < HTT_RX_PEER_STATS_NUM_BW_COUNTERS; i++) { + index += qdf_snprint(&rssi_chain[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->rssi_chain[j][i]); + } + DP_TRACE_STATS(FATAL, "rssi_chain[%d] = %s ", j, rssi_chain[j]); + } + + for (j = 0; j < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; j++) { + index = 0; + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&rx_gi[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->rx_gi[j][i]); + } + DP_TRACE_STATS(FATAL, "rx_gi[%d] = %s ", j, rx_gi[j]); + } + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_PREAM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_pream[i]); + } + DP_TRACE_STATS(FATAL, "rx_pream = %s\n", str_buf); + + for (i = 0; i < DP_HTT_PEER_NUM_SS; i++) + qdf_mem_free(rssi_chain[i]); + for (i = 0; i < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; i++) + qdf_mem_free(rx_gi[i]); +} + +/* + * dp_print_tx_hwq_mu_mimo_sch_stats_tlv: display htt_tx_hwq_mu_mimo_sch_stats + * @tag_buf: buffer containing the tlv htt_tx_hwq_mu_mimo_sch_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_hwq_mu_mimo_sch_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_hwq_mu_mimo_sch_stats_tlv *dp_stats_buf = + (htt_tx_hwq_mu_mimo_sch_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_MU_MIMO_SCH_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mu_mimo_sch_posted = %d", + dp_stats_buf->mu_mimo_sch_posted); + DP_TRACE_STATS(FATAL, "mu_mimo_sch_failed = %d", + dp_stats_buf->mu_mimo_sch_failed); + DP_TRACE_STATS(FATAL, "mu_mimo_ppdu_posted = %d\n", + dp_stats_buf->mu_mimo_ppdu_posted); +} + +/* + * dp_print_tx_hwq_mu_mimo_mpdu_stats_tlv: display htt_tx_hwq_mu_mimo_mpdu_stats + * @tag_buf: buffer containing the tlv htt_tx_hwq_mu_mimo_mpdu_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_hwq_mu_mimo_mpdu_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_hwq_mu_mimo_mpdu_stats_tlv *dp_stats_buf = + (htt_tx_hwq_mu_mimo_mpdu_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_MU_MIMO_MPDU_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_queued_usr = %d", + dp_stats_buf->mu_mimo_mpdus_queued_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_tried_usr = %d", + dp_stats_buf->mu_mimo_mpdus_tried_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_failed_usr = %d", + dp_stats_buf->mu_mimo_mpdus_failed_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_requeued_usr = %d", + dp_stats_buf->mu_mimo_mpdus_requeued_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_err_no_ba_usr = %d", + dp_stats_buf->mu_mimo_err_no_ba_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdu_underrun_usr = %d", + dp_stats_buf->mu_mimo_mpdu_underrun_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_ampdu_underrun_usr = %d\n", + dp_stats_buf->mu_mimo_ampdu_underrun_usr); +} + +/* + * dp_print_tx_hwq_mu_mimo_cmn_stats_tlv: display htt_tx_hwq_mu_mimo_cmn_stats + * @tag_buf: buffer containing the tlv htt_tx_hwq_mu_mimo_cmn_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_hwq_mu_mimo_cmn_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_hwq_mu_mimo_cmn_stats_tlv *dp_stats_buf = + (htt_tx_hwq_mu_mimo_cmn_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_MU_MIMO_CMN_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__hwq_id__word = %d\n", + dp_stats_buf->mac_id__hwq_id__word); +} + +/* + * dp_print_tx_hwq_stats_cmn_tlv: display htt_tx_hwq_stats_cmn_tlv + * @tag_buf: buffer containing the tlv htt_tx_hwq_stats_cmn_tlv + * + * return:void + */ +static inline void dp_print_tx_hwq_stats_cmn_tlv(uint32_t *tag_buf) +{ + htt_tx_hwq_stats_cmn_tlv *dp_stats_buf = + (htt_tx_hwq_stats_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_STATS_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__hwq_id__word = %d", + dp_stats_buf->mac_id__hwq_id__word); + DP_TRACE_STATS(FATAL, "xretry = %d", + dp_stats_buf->xretry); + DP_TRACE_STATS(FATAL, "underrun_cnt = %d", + dp_stats_buf->underrun_cnt); + DP_TRACE_STATS(FATAL, "flush_cnt = %d", + dp_stats_buf->flush_cnt); + DP_TRACE_STATS(FATAL, "filt_cnt = %d", + dp_stats_buf->filt_cnt); + DP_TRACE_STATS(FATAL, "null_mpdu_bmap = %d", + dp_stats_buf->null_mpdu_bmap); + DP_TRACE_STATS(FATAL, "user_ack_failure = %d", + dp_stats_buf->user_ack_failure); + DP_TRACE_STATS(FATAL, "ack_tlv_proc = %d", + dp_stats_buf->ack_tlv_proc); + DP_TRACE_STATS(FATAL, "sched_id_proc = %d", + dp_stats_buf->sched_id_proc); + DP_TRACE_STATS(FATAL, "null_mpdu_tx_count = %d", + dp_stats_buf->null_mpdu_tx_count); + DP_TRACE_STATS(FATAL, "mpdu_bmap_not_recvd = %d", + dp_stats_buf->mpdu_bmap_not_recvd); + DP_TRACE_STATS(FATAL, "num_bar = %d", + dp_stats_buf->num_bar); + DP_TRACE_STATS(FATAL, "rts = %d", + dp_stats_buf->rts); + DP_TRACE_STATS(FATAL, "cts2self = %d", + dp_stats_buf->cts2self); + DP_TRACE_STATS(FATAL, "qos_null = %d", + dp_stats_buf->qos_null); + DP_TRACE_STATS(FATAL, "mpdu_tried_cnt = %d", + dp_stats_buf->mpdu_tried_cnt); + DP_TRACE_STATS(FATAL, "mpdu_queued_cnt = %d", + dp_stats_buf->mpdu_queued_cnt); + DP_TRACE_STATS(FATAL, "mpdu_ack_fail_cnt = %d", + dp_stats_buf->mpdu_ack_fail_cnt); + DP_TRACE_STATS(FATAL, "mpdu_filt_cnt = %d", + dp_stats_buf->mpdu_filt_cnt); + DP_TRACE_STATS(FATAL, "false_mpdu_ack_count = %d\n", + dp_stats_buf->false_mpdu_ack_count); +} + +/* + * dp_print_tx_hwq_difs_latency_stats_tlv_v: display + * htt_tx_hwq_difs_latency_stats_tlv_v + * @tag_buf: buffer containing the tlv htt_tx_hwq_difs_latency_stats_tlv_v + * + *return:void + */ +static inline void dp_print_tx_hwq_difs_latency_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_hwq_difs_latency_stats_tlv_v *dp_stats_buf = + (htt_tx_hwq_difs_latency_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char difs_latency_hist[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, + (uint32_t)HTT_TX_HWQ_MAX_DIFS_LATENCY_BINS) - 1; + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_DIFS_LATENCY_STATS_TLV_V:"); + DP_TRACE_STATS(FATAL, "hist_intvl = %d", + dp_stats_buf->hist_intvl); + + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&difs_latency_hist[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->difs_latency_hist[i]); + } + DP_TRACE_STATS(FATAL, "difs_latency_hist = %s\n", difs_latency_hist); +} + +/* + * dp_print_tx_hwq_cmd_result_stats_tlv_v: display htt_tx_hwq_cmd_result_stats + * @tag_buf: buffer containing the tlv htt_tx_hwq_cmd_result_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_hwq_cmd_result_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_hwq_cmd_result_stats_tlv_v *dp_stats_buf = + (htt_tx_hwq_cmd_result_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char cmd_result[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_HWQ_MAX_CMD_RESULT_STATS); + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_CMD_RESULT_STATS_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&cmd_result[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->cmd_result[i]); + } + DP_TRACE_STATS(FATAL, "cmd_result = %s ", cmd_result); +} + +/* + * dp_print_tx_hwq_cmd_stall_stats_tlv_v: display htt_tx_hwq_cmd_stall_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_hwq_cmd_stall_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_hwq_cmd_stall_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_hwq_cmd_stall_stats_tlv_v *dp_stats_buf = + (htt_tx_hwq_cmd_stall_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char cmd_stall_status[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_HWQ_MAX_CMD_STALL_STATS); + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_CMD_STALL_STATS_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&cmd_stall_status[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->cmd_stall_status[i]); + } + DP_TRACE_STATS(FATAL, "cmd_stall_status = %s\n", cmd_stall_status); +} + +/* + * dp_print_tx_hwq_fes_result_stats_tlv_v: display htt_tx_hwq_fes_result_stats + * @tag_buf: buffer containing the tlv htt_tx_hwq_fes_result_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_hwq_fes_result_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_hwq_fes_result_stats_tlv_v *dp_stats_buf = + (htt_tx_hwq_fes_result_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char fes_result[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_HWQ_MAX_FES_RESULT_STATS); + + DP_TRACE_STATS(FATAL, "HTT_TX_HWQ_FES_RESULT_STATS_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&fes_result[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->fes_result[i]); + } + DP_TRACE_STATS(FATAL, "fes_result = %s ", fes_result); +} + +/* + * dp_print_tx_selfgen_cmn_stats_tlv: display htt_tx_selfgen_cmn_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_selfgen_cmn_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_selfgen_cmn_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_selfgen_cmn_stats_tlv *dp_stats_buf = + (htt_tx_selfgen_cmn_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_SELFGEN_CMN_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "su_bar = %d", + dp_stats_buf->su_bar); + DP_TRACE_STATS(FATAL, "rts = %d", + dp_stats_buf->rts); + DP_TRACE_STATS(FATAL, "cts2self = %d", + dp_stats_buf->cts2self); + DP_TRACE_STATS(FATAL, "qos_null = %d", + dp_stats_buf->qos_null); + DP_TRACE_STATS(FATAL, "delayed_bar_1 = %d", + dp_stats_buf->delayed_bar_1); + DP_TRACE_STATS(FATAL, "delayed_bar_2 = %d", + dp_stats_buf->delayed_bar_2); + DP_TRACE_STATS(FATAL, "delayed_bar_3 = %d", + dp_stats_buf->delayed_bar_3); + DP_TRACE_STATS(FATAL, "delayed_bar_4 = %d", + dp_stats_buf->delayed_bar_4); + DP_TRACE_STATS(FATAL, "delayed_bar_5 = %d", + dp_stats_buf->delayed_bar_5); + DP_TRACE_STATS(FATAL, "delayed_bar_6 = %d", + dp_stats_buf->delayed_bar_6); + DP_TRACE_STATS(FATAL, "delayed_bar_7 = %d\n", + dp_stats_buf->delayed_bar_7); +} + +/* + * dp_print_tx_selfgen_ac_stats_tlv: display htt_tx_selfgen_ac_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_selfgen_ac_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_selfgen_ac_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_selfgen_ac_stats_tlv *dp_stats_buf = + (htt_tx_selfgen_ac_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_SELFGEN_AC_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "ac_su_ndpa = %d", + dp_stats_buf->ac_su_ndpa); + DP_TRACE_STATS(FATAL, "ac_su_ndp = %d", + dp_stats_buf->ac_su_ndp); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_ndpa = %d", + dp_stats_buf->ac_mu_mimo_ndpa); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_ndp = %d", + dp_stats_buf->ac_mu_mimo_ndp); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brpoll_1 = %d", + dp_stats_buf->ac_mu_mimo_brpoll_1); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brpoll_2 = %d", + dp_stats_buf->ac_mu_mimo_brpoll_2); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brpoll_3 = %d\n", + dp_stats_buf->ac_mu_mimo_brpoll_3); +} + +/* + * dp_print_tx_selfgen_ax_stats_tlv: display htt_tx_selfgen_ax_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_selfgen_ax_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_selfgen_ax_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_selfgen_ax_stats_tlv *dp_stats_buf = + (htt_tx_selfgen_ax_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_SELFGEN_AX_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "ax_su_ndpa = %d", + dp_stats_buf->ax_su_ndpa); + DP_TRACE_STATS(FATAL, "ax_su_ndp = %d", + dp_stats_buf->ax_su_ndp); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_ndpa = %d", + dp_stats_buf->ax_mu_mimo_ndpa); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_ndp = %d", + dp_stats_buf->ax_mu_mimo_ndp); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_1 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_1); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_2 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_2); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_3 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_3); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_4 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_4); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_5 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_5); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_6 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_6); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brpoll_7 = %d", + dp_stats_buf->ax_mu_mimo_brpoll_7); + DP_TRACE_STATS(FATAL, "ax_basic_trigger = %d", + dp_stats_buf->ax_basic_trigger); + DP_TRACE_STATS(FATAL, "ax_bsr_trigger = %d", + dp_stats_buf->ax_bsr_trigger); + DP_TRACE_STATS(FATAL, "ax_mu_bar_trigger = %d", + dp_stats_buf->ax_mu_bar_trigger); + DP_TRACE_STATS(FATAL, "ax_mu_rts_trigger = %d\n", + dp_stats_buf->ax_mu_rts_trigger); +} + +/* + * dp_print_tx_selfgen_ac_err_stats_tlv: display htt_tx_selfgen_ac_err_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_selfgen_ac_err_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_selfgen_ac_err_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_selfgen_ac_err_stats_tlv *dp_stats_buf = + (htt_tx_selfgen_ac_err_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "ac_su_ndp_err = %d", + dp_stats_buf->ac_su_ndp_err); + DP_TRACE_STATS(FATAL, "ac_su_ndpa_err = %d", + dp_stats_buf->ac_su_ndpa_err); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_ndpa_err = %d", + dp_stats_buf->ac_mu_mimo_ndpa_err); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_ndp_err = %d", + dp_stats_buf->ac_mu_mimo_ndp_err); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brp1_err = %d", + dp_stats_buf->ac_mu_mimo_brp1_err); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brp2_err = %d", + dp_stats_buf->ac_mu_mimo_brp2_err); + DP_TRACE_STATS(FATAL, "ac_mu_mimo_brp3_err = %d\n", + dp_stats_buf->ac_mu_mimo_brp3_err); +} + +/* + * dp_print_tx_selfgen_ax_err_stats_tlv: display htt_tx_selfgen_ax_err_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_selfgen_ax_err_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_selfgen_ax_err_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_selfgen_ax_err_stats_tlv *dp_stats_buf = + (htt_tx_selfgen_ax_err_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "ax_su_ndp_err = %d", + dp_stats_buf->ax_su_ndp_err); + DP_TRACE_STATS(FATAL, "ax_su_ndpa_err = %d", + dp_stats_buf->ax_su_ndpa_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_ndpa_err = %d", + dp_stats_buf->ax_mu_mimo_ndpa_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_ndp_err = %d", + dp_stats_buf->ax_mu_mimo_ndp_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp1_err = %d", + dp_stats_buf->ax_mu_mimo_brp1_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp2_err = %d", + dp_stats_buf->ax_mu_mimo_brp2_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp3_err = %d", + dp_stats_buf->ax_mu_mimo_brp3_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp4_err = %d", + dp_stats_buf->ax_mu_mimo_brp4_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp5_err = %d", + dp_stats_buf->ax_mu_mimo_brp5_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp6_err = %d", + dp_stats_buf->ax_mu_mimo_brp6_err); + DP_TRACE_STATS(FATAL, "ax_mu_mimo_brp7_err = %d", + dp_stats_buf->ax_mu_mimo_brp7_err); + DP_TRACE_STATS(FATAL, "ax_basic_trigger_err = %d", + dp_stats_buf->ax_basic_trigger_err); + DP_TRACE_STATS(FATAL, "ax_bsr_trigger_err = %d", + dp_stats_buf->ax_bsr_trigger_err); + DP_TRACE_STATS(FATAL, "ax_mu_bar_trigger_err = %d", + dp_stats_buf->ax_mu_bar_trigger_err); + DP_TRACE_STATS(FATAL, "ax_mu_rts_trigger_err = %d\n", + dp_stats_buf->ax_mu_rts_trigger_err); +} + +/* + * dp_print_tx_pdev_mu_mimo_sch_stats_tlv: display htt_tx_pdev_mu_mimo_sch_stats + * @tag_buf: buffer containing the tlv htt_tx_pdev_mu_mimo_sch_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_pdev_mu_mimo_sch_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_pdev_mu_mimo_sch_stats_tlv *dp_stats_buf = + (htt_tx_pdev_mu_mimo_sch_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mu_mimo_sch_posted = %d", + dp_stats_buf->mu_mimo_sch_posted); + DP_TRACE_STATS(FATAL, "mu_mimo_sch_failed = %d", + dp_stats_buf->mu_mimo_sch_failed); + DP_TRACE_STATS(FATAL, "mu_mimo_ppdu_posted = %d\n", + dp_stats_buf->mu_mimo_ppdu_posted); +} + +/* + * dp_print_tx_pdev_mu_mimo_mpdu_stats_tlv: display + * htt_tx_pdev_mu_mimo_mpdu_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_pdev_mu_mimo_mpdu_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_pdev_mu_mimo_mpdu_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_pdev_mu_mimo_mpdu_stats_tlv *dp_stats_buf = + (htt_tx_pdev_mu_mimo_mpdu_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_MU_MIMO_MPDU_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_queued_usr = %d", + dp_stats_buf->mu_mimo_mpdus_queued_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_tried_usr = %d", + dp_stats_buf->mu_mimo_mpdus_tried_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_failed_usr = %d", + dp_stats_buf->mu_mimo_mpdus_failed_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdus_requeued_usr = %d", + dp_stats_buf->mu_mimo_mpdus_requeued_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_err_no_ba_usr = %d", + dp_stats_buf->mu_mimo_err_no_ba_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_mpdu_underrun_usr = %d", + dp_stats_buf->mu_mimo_mpdu_underrun_usr); + DP_TRACE_STATS(FATAL, "mu_mimo_ampdu_underrun_usr = %d\n", + dp_stats_buf->mu_mimo_ampdu_underrun_usr); +} + +/* + * dp_print_sched_txq_cmd_posted_tlv_v: display htt_sched_txq_cmd_posted_tlv_v + * @tag_buf: buffer containing the tlv htt_sched_txq_cmd_posted_tlv_v + * + * return:void + */ +static inline void dp_print_sched_txq_cmd_posted_tlv_v(uint32_t *tag_buf) +{ + htt_sched_txq_cmd_posted_tlv_v *dp_stats_buf = + (htt_sched_txq_cmd_posted_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char sched_cmd_posted[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_SCHED_TX_MODE_MAX); + + DP_TRACE_STATS(FATAL, "HTT_SCHED_TXQ_CMD_POSTED_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&sched_cmd_posted[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->sched_cmd_posted[i]); + } + DP_TRACE_STATS(FATAL, "sched_cmd_posted = %s\n", sched_cmd_posted); +} + +/* + * dp_print_sched_txq_cmd_reaped_tlv_v: display htt_sched_txq_cmd_reaped_tlv_v + * @tag_buf: buffer containing the tlv htt_sched_txq_cmd_reaped_tlv_v + * + * return:void + */ +static inline void dp_print_sched_txq_cmd_reaped_tlv_v(uint32_t *tag_buf) +{ + htt_sched_txq_cmd_reaped_tlv_v *dp_stats_buf = + (htt_sched_txq_cmd_reaped_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char sched_cmd_reaped[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_SCHED_TX_MODE_MAX); + + DP_TRACE_STATS(FATAL, "HTT_SCHED_TXQ_CMD_REAPED_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&sched_cmd_reaped[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->sched_cmd_reaped[i]); + } + DP_TRACE_STATS(FATAL, "sched_cmd_reaped = %s\n", sched_cmd_reaped); +} + +/* + * dp_print_tx_pdev_stats_sched_per_txq_tlv: display + * htt_tx_pdev_stats_sched_per_txq_tlv + * @tag_buf: buffer containing the tlv htt_tx_pdev_stats_sched_per_txq_tlv + * + * return:void + */ +static inline void dp_print_tx_pdev_stats_sched_per_txq_tlv(uint32_t *tag_buf) +{ + htt_tx_pdev_stats_sched_per_txq_tlv *dp_stats_buf = + (htt_tx_pdev_stats_sched_per_txq_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__txq_id__word = %d", + dp_stats_buf->mac_id__txq_id__word); + DP_TRACE_STATS(FATAL, "sched_policy = %d", + dp_stats_buf->sched_policy); + DP_TRACE_STATS(FATAL, "last_sched_cmd_posted_timestamp = %d", + dp_stats_buf->last_sched_cmd_posted_timestamp); + DP_TRACE_STATS(FATAL, "last_sched_cmd_compl_timestamp = %d", + dp_stats_buf->last_sched_cmd_compl_timestamp); + DP_TRACE_STATS(FATAL, "sched_2_tac_lwm_count = %d", + dp_stats_buf->sched_2_tac_lwm_count); + DP_TRACE_STATS(FATAL, "sched_2_tac_ring_full = %d", + dp_stats_buf->sched_2_tac_ring_full); + DP_TRACE_STATS(FATAL, "sched_cmd_post_failure = %d", + dp_stats_buf->sched_cmd_post_failure); + DP_TRACE_STATS(FATAL, "num_active_tids = %d", + dp_stats_buf->num_active_tids); + DP_TRACE_STATS(FATAL, "num_ps_schedules = %d", + dp_stats_buf->num_ps_schedules); + DP_TRACE_STATS(FATAL, "sched_cmds_pending = %d", + dp_stats_buf->sched_cmds_pending); + DP_TRACE_STATS(FATAL, "num_tid_register = %d", + dp_stats_buf->num_tid_register); + DP_TRACE_STATS(FATAL, "num_tid_unregister = %d", + dp_stats_buf->num_tid_unregister); + DP_TRACE_STATS(FATAL, "num_qstats_queried = %d", + dp_stats_buf->num_qstats_queried); + DP_TRACE_STATS(FATAL, "qstats_update_pending = %d", + dp_stats_buf->qstats_update_pending); + DP_TRACE_STATS(FATAL, "last_qstats_query_timestamp = %d", + dp_stats_buf->last_qstats_query_timestamp); + DP_TRACE_STATS(FATAL, "num_tqm_cmdq_full = %d", + dp_stats_buf->num_tqm_cmdq_full); + DP_TRACE_STATS(FATAL, "num_de_sched_algo_trigger = %d", + dp_stats_buf->num_de_sched_algo_trigger); + DP_TRACE_STATS(FATAL, "num_rt_sched_algo_trigger = %d", + dp_stats_buf->num_rt_sched_algo_trigger); + DP_TRACE_STATS(FATAL, "num_tqm_sched_algo_trigger = %d", + dp_stats_buf->num_tqm_sched_algo_trigger); + DP_TRACE_STATS(FATAL, "notify_sched = %d\n", + dp_stats_buf->notify_sched); +} + +/* + * dp_print_stats_tx_sched_cmn_tlv: display htt_stats_tx_sched_cmn_tlv + * @tag_buf: buffer containing the tlv htt_stats_tx_sched_cmn_tlv + * + * return:void + */ +static inline void dp_print_stats_tx_sched_cmn_tlv(uint32_t *tag_buf) +{ + htt_stats_tx_sched_cmn_tlv *dp_stats_buf = + (htt_stats_tx_sched_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_STATS_TX_SCHED_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "current_timestamp = %d\n", + dp_stats_buf->current_timestamp); +} + +/* + * dp_print_tx_tqm_gen_mpdu_stats_tlv_v: display htt_tx_tqm_gen_mpdu_stats_tlv_v + * @tag_buf: buffer containing the tlv htt_tx_tqm_gen_mpdu_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_tqm_gen_mpdu_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_tqm_gen_mpdu_stats_tlv_v *dp_stats_buf = + (htt_tx_tqm_gen_mpdu_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char gen_mpdu_end_reason[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, + (uint32_t)HTT_TX_TQM_MAX_GEN_MPDU_END_REASON); + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_GEN_MPDU_STATS_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&gen_mpdu_end_reason[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->gen_mpdu_end_reason[i]); + } + DP_TRACE_STATS(FATAL, "gen_mpdu_end_reason = %s\n", gen_mpdu_end_reason); +} + +/* + * dp_print_tx_tqm_list_mpdu_stats_tlv_v: display htt_tx_tqm_list_mpdu_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_tqm_list_mpdu_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_tqm_list_mpdu_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_tqm_list_mpdu_stats_tlv_v *dp_stats_buf = + (htt_tx_tqm_list_mpdu_stats_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char list_mpdu_end_reason[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, + (uint32_t)HTT_TX_TQM_MAX_LIST_MPDU_END_REASON); + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_LIST_MPDU_STATS_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&list_mpdu_end_reason[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->list_mpdu_end_reason[i]); + } + DP_TRACE_STATS(FATAL, "list_mpdu_end_reason = %s\n", + list_mpdu_end_reason); +} + +/* + * dp_print_tx_tqm_list_mpdu_cnt_tlv_v: display htt_tx_tqm_list_mpdu_cnt_tlv_v + * @tag_buf: buffer containing the tlv htt_tx_tqm_list_mpdu_cnt_tlv_v + * + * return:void + */ +static inline void dp_print_tx_tqm_list_mpdu_cnt_tlv_v(uint32_t *tag_buf) +{ + htt_tx_tqm_list_mpdu_cnt_tlv_v *dp_stats_buf = + (htt_tx_tqm_list_mpdu_cnt_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char list_mpdu_cnt_hist[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, + (uint32_t)HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS); + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&list_mpdu_cnt_hist[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->list_mpdu_cnt_hist[i]); + } + DP_TRACE_STATS(FATAL, "list_mpdu_cnt_hist = %s\n", list_mpdu_cnt_hist); +} + +/* + * dp_print_tx_tqm_pdev_stats_tlv_v: display htt_tx_tqm_pdev_stats_tlv_v + * @tag_buf: buffer containing the tlv htt_tx_tqm_pdev_stats_tlv_v + * + * return:void + */ +static inline void dp_print_tx_tqm_pdev_stats_tlv_v(uint32_t *tag_buf) +{ + htt_tx_tqm_pdev_stats_tlv_v *dp_stats_buf = + (htt_tx_tqm_pdev_stats_tlv_v *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_PDEV_STATS_TLV_V:"); + DP_TRACE_STATS(FATAL, "msdu_count = %d", + dp_stats_buf->msdu_count); + DP_TRACE_STATS(FATAL, "mpdu_count = %d", + dp_stats_buf->mpdu_count); + DP_TRACE_STATS(FATAL, "remove_msdu = %d", + dp_stats_buf->remove_msdu); + DP_TRACE_STATS(FATAL, "remove_mpdu = %d", + dp_stats_buf->remove_mpdu); + DP_TRACE_STATS(FATAL, "remove_msdu_ttl = %d", + dp_stats_buf->remove_msdu_ttl); + DP_TRACE_STATS(FATAL, "send_bar = %d", + dp_stats_buf->send_bar); + DP_TRACE_STATS(FATAL, "bar_sync = %d", + dp_stats_buf->bar_sync); + DP_TRACE_STATS(FATAL, "notify_mpdu = %d", + dp_stats_buf->notify_mpdu); + DP_TRACE_STATS(FATAL, "sync_cmd = %d", + dp_stats_buf->sync_cmd); + DP_TRACE_STATS(FATAL, "write_cmd = %d", + dp_stats_buf->write_cmd); + DP_TRACE_STATS(FATAL, "hwsch_trigger = %d", + dp_stats_buf->hwsch_trigger); + DP_TRACE_STATS(FATAL, "ack_tlv_proc = %d", + dp_stats_buf->ack_tlv_proc); + DP_TRACE_STATS(FATAL, "gen_mpdu_cmd = %d", + dp_stats_buf->gen_mpdu_cmd); + DP_TRACE_STATS(FATAL, "gen_list_cmd = %d", + dp_stats_buf->gen_list_cmd); + DP_TRACE_STATS(FATAL, "remove_mpdu_cmd = %d", + dp_stats_buf->remove_mpdu_cmd); + DP_TRACE_STATS(FATAL, "remove_mpdu_tried_cmd = %d", + dp_stats_buf->remove_mpdu_tried_cmd); + DP_TRACE_STATS(FATAL, "mpdu_queue_stats_cmd = %d", + dp_stats_buf->mpdu_queue_stats_cmd); + DP_TRACE_STATS(FATAL, "mpdu_head_info_cmd = %d", + dp_stats_buf->mpdu_head_info_cmd); + DP_TRACE_STATS(FATAL, "msdu_flow_stats_cmd = %d", + dp_stats_buf->msdu_flow_stats_cmd); + DP_TRACE_STATS(FATAL, "remove_msdu_cmd = %d", + dp_stats_buf->remove_msdu_cmd); + DP_TRACE_STATS(FATAL, "remove_msdu_ttl_cmd = %d", + dp_stats_buf->remove_msdu_ttl_cmd); + DP_TRACE_STATS(FATAL, "flush_cache_cmd = %d", + dp_stats_buf->flush_cache_cmd); + DP_TRACE_STATS(FATAL, "update_mpduq_cmd = %d", + dp_stats_buf->update_mpduq_cmd); + DP_TRACE_STATS(FATAL, "enqueue = %d", + dp_stats_buf->enqueue); + DP_TRACE_STATS(FATAL, "enqueue_notify = %d", + dp_stats_buf->enqueue_notify); + DP_TRACE_STATS(FATAL, "notify_mpdu_at_head = %d", + dp_stats_buf->notify_mpdu_at_head); + DP_TRACE_STATS(FATAL, "notify_mpdu_state_valid = %d\n", + dp_stats_buf->notify_mpdu_state_valid); +} + +/* + * dp_print_tx_tqm_cmn_stats_tlv: display htt_tx_tqm_cmn_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_tqm_cmn_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_tqm_cmn_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_tqm_cmn_stats_tlv *dp_stats_buf = + (htt_tx_tqm_cmn_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_CMN_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "max_cmdq_id = %d", + dp_stats_buf->max_cmdq_id); + DP_TRACE_STATS(FATAL, "list_mpdu_cnt_hist_intvl = %d", + dp_stats_buf->list_mpdu_cnt_hist_intvl); + DP_TRACE_STATS(FATAL, "add_msdu = %d", + dp_stats_buf->add_msdu); + DP_TRACE_STATS(FATAL, "q_empty = %d", + dp_stats_buf->q_empty); + DP_TRACE_STATS(FATAL, "q_not_empty = %d", + dp_stats_buf->q_not_empty); + DP_TRACE_STATS(FATAL, "drop_notification = %d", + dp_stats_buf->drop_notification); + DP_TRACE_STATS(FATAL, "desc_threshold = %d\n", + dp_stats_buf->desc_threshold); +} + +/* + * dp_print_tx_tqm_error_stats_tlv: display htt_tx_tqm_error_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_tqm_error_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_tqm_error_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_tqm_error_stats_tlv *dp_stats_buf = + (htt_tx_tqm_error_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_ERROR_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "q_empty_failure = %d", + dp_stats_buf->q_empty_failure); + DP_TRACE_STATS(FATAL, "q_not_empty_failure = %d", + dp_stats_buf->q_not_empty_failure); + DP_TRACE_STATS(FATAL, "add_msdu_failure = %d\n", + dp_stats_buf->add_msdu_failure); +} + +/* + * dp_print_tx_tqm_cmdq_status_tlv: display htt_tx_tqm_cmdq_status_tlv + * @tag_buf: buffer containing the tlv htt_tx_tqm_cmdq_status_tlv + * + * return:void + */ +static inline void dp_print_tx_tqm_cmdq_status_tlv(uint32_t *tag_buf) +{ + htt_tx_tqm_cmdq_status_tlv *dp_stats_buf = + (htt_tx_tqm_cmdq_status_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_TQM_CMDQ_STATUS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__cmdq_id__word = %d", + dp_stats_buf->mac_id__cmdq_id__word); + DP_TRACE_STATS(FATAL, "sync_cmd = %d", + dp_stats_buf->sync_cmd); + DP_TRACE_STATS(FATAL, "write_cmd = %d", + dp_stats_buf->write_cmd); + DP_TRACE_STATS(FATAL, "gen_mpdu_cmd = %d", + dp_stats_buf->gen_mpdu_cmd); + DP_TRACE_STATS(FATAL, "mpdu_queue_stats_cmd = %d", + dp_stats_buf->mpdu_queue_stats_cmd); + DP_TRACE_STATS(FATAL, "mpdu_head_info_cmd = %d", + dp_stats_buf->mpdu_head_info_cmd); + DP_TRACE_STATS(FATAL, "msdu_flow_stats_cmd = %d", + dp_stats_buf->msdu_flow_stats_cmd); + DP_TRACE_STATS(FATAL, "remove_mpdu_cmd = %d", + dp_stats_buf->remove_mpdu_cmd); + DP_TRACE_STATS(FATAL, "remove_msdu_cmd = %d", + dp_stats_buf->remove_msdu_cmd); + DP_TRACE_STATS(FATAL, "flush_cache_cmd = %d", + dp_stats_buf->flush_cache_cmd); + DP_TRACE_STATS(FATAL, "update_mpduq_cmd = %d", + dp_stats_buf->update_mpduq_cmd); + DP_TRACE_STATS(FATAL, "update_msduq_cmd = %d\n", + dp_stats_buf->update_msduq_cmd); +} + +/* + * dp_print_tx_de_eapol_packets_stats_tlv: display htt_tx_de_eapol_packets_stats + * @tag_buf: buffer containing the tlv htt_tx_de_eapol_packets_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_eapol_packets_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_eapol_packets_stats_tlv *dp_stats_buf = + (htt_tx_de_eapol_packets_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "m1_packets = %d", + dp_stats_buf->m1_packets); + DP_TRACE_STATS(FATAL, "m2_packets = %d", + dp_stats_buf->m2_packets); + DP_TRACE_STATS(FATAL, "m3_packets = %d", + dp_stats_buf->m3_packets); + DP_TRACE_STATS(FATAL, "m4_packets = %d", + dp_stats_buf->m4_packets); + DP_TRACE_STATS(FATAL, "g1_packets = %d", + dp_stats_buf->g1_packets); + DP_TRACE_STATS(FATAL, "g2_packets = %d\n", + dp_stats_buf->g2_packets); +} + +/* + * dp_print_tx_de_classify_failed_stats_tlv: display + * htt_tx_de_classify_failed_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_classify_failed_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_classify_failed_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_classify_failed_stats_tlv *dp_stats_buf = + (htt_tx_de_classify_failed_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "ap_bss_peer_not_found = %d", + dp_stats_buf->ap_bss_peer_not_found); + DP_TRACE_STATS(FATAL, "ap_bcast_mcast_no_peer = %d", + dp_stats_buf->ap_bcast_mcast_no_peer); + DP_TRACE_STATS(FATAL, "sta_delete_in_progress = %d", + dp_stats_buf->sta_delete_in_progress); + DP_TRACE_STATS(FATAL, "ibss_no_bss_peer = %d", + dp_stats_buf->ibss_no_bss_peer); + DP_TRACE_STATS(FATAL, "invaild_vdev_type = %d", + dp_stats_buf->invaild_vdev_type); + DP_TRACE_STATS(FATAL, "invalid_ast_peer_entry = %d", + dp_stats_buf->invalid_ast_peer_entry); + DP_TRACE_STATS(FATAL, "peer_entry_invalid = %d", + dp_stats_buf->peer_entry_invalid); + DP_TRACE_STATS(FATAL, "ethertype_not_ip = %d", + dp_stats_buf->ethertype_not_ip); + DP_TRACE_STATS(FATAL, "eapol_lookup_failed = %d", + dp_stats_buf->eapol_lookup_failed); + DP_TRACE_STATS(FATAL, "qpeer_not_allow_data = %d", + dp_stats_buf->qpeer_not_allow_data); + DP_TRACE_STATS(FATAL, "fse_tid_override = %d\n", + dp_stats_buf->fse_tid_override); +} + +/* + * dp_print_tx_de_classify_stats_tlv: display htt_tx_de_classify_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_classify_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_classify_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_classify_stats_tlv *dp_stats_buf = + (htt_tx_de_classify_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_CLASSIFY_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "arp_packets = %d", + dp_stats_buf->arp_packets); + DP_TRACE_STATS(FATAL, "igmp_packets = %d", + dp_stats_buf->igmp_packets); + DP_TRACE_STATS(FATAL, "dhcp_packets = %d", + dp_stats_buf->dhcp_packets); + DP_TRACE_STATS(FATAL, "host_inspected = %d", + dp_stats_buf->host_inspected); + DP_TRACE_STATS(FATAL, "htt_included = %d", + dp_stats_buf->htt_included); + DP_TRACE_STATS(FATAL, "htt_valid_mcs = %d", + dp_stats_buf->htt_valid_mcs); + DP_TRACE_STATS(FATAL, "htt_valid_nss = %d", + dp_stats_buf->htt_valid_nss); + DP_TRACE_STATS(FATAL, "htt_valid_preamble_type = %d", + dp_stats_buf->htt_valid_preamble_type); + DP_TRACE_STATS(FATAL, "htt_valid_chainmask = %d", + dp_stats_buf->htt_valid_chainmask); + DP_TRACE_STATS(FATAL, "htt_valid_guard_interval = %d", + dp_stats_buf->htt_valid_guard_interval); + DP_TRACE_STATS(FATAL, "htt_valid_retries = %d", + dp_stats_buf->htt_valid_retries); + DP_TRACE_STATS(FATAL, "htt_valid_bw_info = %d", + dp_stats_buf->htt_valid_bw_info); + DP_TRACE_STATS(FATAL, "htt_valid_power = %d", + dp_stats_buf->htt_valid_power); + DP_TRACE_STATS(FATAL, "htt_valid_key_flags = %d", + dp_stats_buf->htt_valid_key_flags); + DP_TRACE_STATS(FATAL, "htt_valid_no_encryption = %d", + dp_stats_buf->htt_valid_no_encryption); + DP_TRACE_STATS(FATAL, "fse_entry_count = %d", + dp_stats_buf->fse_entry_count); + DP_TRACE_STATS(FATAL, "fse_priority_be = %d", + dp_stats_buf->fse_priority_be); + DP_TRACE_STATS(FATAL, "fse_priority_high = %d", + dp_stats_buf->fse_priority_high); + DP_TRACE_STATS(FATAL, "fse_priority_low = %d", + dp_stats_buf->fse_priority_low); + DP_TRACE_STATS(FATAL, "fse_traffic_ptrn_be = %d", + dp_stats_buf->fse_traffic_ptrn_be); + DP_TRACE_STATS(FATAL, "fse_traffic_ptrn_over_sub = %d", + dp_stats_buf->fse_traffic_ptrn_over_sub); + DP_TRACE_STATS(FATAL, "fse_traffic_ptrn_bursty = %d", + dp_stats_buf->fse_traffic_ptrn_bursty); + DP_TRACE_STATS(FATAL, "fse_traffic_ptrn_interactive = %d", + dp_stats_buf->fse_traffic_ptrn_interactive); + DP_TRACE_STATS(FATAL, "fse_traffic_ptrn_periodic = %d", + dp_stats_buf->fse_traffic_ptrn_periodic); + DP_TRACE_STATS(FATAL, "fse_hwqueue_alloc = %d", + dp_stats_buf->fse_hwqueue_alloc); + DP_TRACE_STATS(FATAL, "fse_hwqueue_created = %d", + dp_stats_buf->fse_hwqueue_created); + DP_TRACE_STATS(FATAL, "fse_hwqueue_send_to_host = %d", + dp_stats_buf->fse_hwqueue_send_to_host); + DP_TRACE_STATS(FATAL, "mcast_entry = %d", + dp_stats_buf->mcast_entry); + DP_TRACE_STATS(FATAL, "bcast_entry = %d\n", + dp_stats_buf->bcast_entry); +} + +/* + * dp_print_tx_de_classify_status_stats_tlv: display + * htt_tx_de_classify_status_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_classify_status_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_classify_status_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_classify_status_stats_tlv *dp_stats_buf = + (htt_tx_de_classify_status_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "eok = %d", + dp_stats_buf->eok); + DP_TRACE_STATS(FATAL, "classify_done = %d", + dp_stats_buf->classify_done); + DP_TRACE_STATS(FATAL, "lookup_failed = %d", + dp_stats_buf->lookup_failed); + DP_TRACE_STATS(FATAL, "send_host_dhcp = %d", + dp_stats_buf->send_host_dhcp); + DP_TRACE_STATS(FATAL, "send_host_mcast = %d", + dp_stats_buf->send_host_mcast); + DP_TRACE_STATS(FATAL, "send_host_unknown_dest = %d", + dp_stats_buf->send_host_unknown_dest); + DP_TRACE_STATS(FATAL, "send_host = %d", + dp_stats_buf->send_host); + DP_TRACE_STATS(FATAL, "status_invalid = %d\n", + dp_stats_buf->status_invalid); +} + +/* + * dp_print_tx_de_enqueue_packets_stats_tlv: display + * htt_tx_de_enqueue_packets_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_enqueue_packets_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_enqueue_packets_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_enqueue_packets_stats_tlv *dp_stats_buf = + (htt_tx_de_enqueue_packets_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "enqueued_pkts = %d", + dp_stats_buf->enqueued_pkts); + DP_TRACE_STATS(FATAL, "to_tqm = %d", + dp_stats_buf->to_tqm); + DP_TRACE_STATS(FATAL, "to_tqm_bypass = %d\n", + dp_stats_buf->to_tqm_bypass); +} + +/* + * dp_print_tx_de_enqueue_discard_stats_tlv: display + * htt_tx_de_enqueue_discard_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_enqueue_discard_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_enqueue_discard_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_enqueue_discard_stats_tlv *dp_stats_buf = + (htt_tx_de_enqueue_discard_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "discarded_pkts = %d", + dp_stats_buf->discarded_pkts); + DP_TRACE_STATS(FATAL, "local_frames = %d", + dp_stats_buf->local_frames); + DP_TRACE_STATS(FATAL, "is_ext_msdu = %d\n", + dp_stats_buf->is_ext_msdu); +} + +/* + * dp_print_tx_de_compl_stats_tlv: display htt_tx_de_compl_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_compl_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_compl_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_compl_stats_tlv *dp_stats_buf = + (htt_tx_de_compl_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_COMPL_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "tcl_dummy_frame = %d", + dp_stats_buf->tcl_dummy_frame); + DP_TRACE_STATS(FATAL, "tqm_dummy_frame = %d", + dp_stats_buf->tqm_dummy_frame); + DP_TRACE_STATS(FATAL, "tqm_notify_frame = %d", + dp_stats_buf->tqm_notify_frame); + DP_TRACE_STATS(FATAL, "fw2wbm_enq = %d", + dp_stats_buf->fw2wbm_enq); + DP_TRACE_STATS(FATAL, "tqm_bypass_frame = %d\n", + dp_stats_buf->tqm_bypass_frame); +} + +/* + * dp_print_tx_de_cmn_stats_tlv: display htt_tx_de_cmn_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_de_cmn_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_de_cmn_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_de_cmn_stats_tlv *dp_stats_buf = + (htt_tx_de_cmn_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_TX_DE_CMN_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "tcl2fw_entry_count = %d", + dp_stats_buf->tcl2fw_entry_count); + DP_TRACE_STATS(FATAL, "not_to_fw = %d", + dp_stats_buf->not_to_fw); + DP_TRACE_STATS(FATAL, "invalid_pdev_vdev_peer = %d", + dp_stats_buf->invalid_pdev_vdev_peer); + DP_TRACE_STATS(FATAL, "tcl_res_invalid_addrx = %d", + dp_stats_buf->tcl_res_invalid_addrx); + DP_TRACE_STATS(FATAL, "wbm2fw_entry_count = %d", + dp_stats_buf->wbm2fw_entry_count); + DP_TRACE_STATS(FATAL, "invalid_pdev = %d\n", + dp_stats_buf->invalid_pdev); +} + +/* + * dp_print_ring_if_stats_tlv: display htt_ring_if_stats_tlv + * @tag_buf: buffer containing the tlv htt_ring_if_stats_tlv + * + * return:void + */ +static inline void dp_print_ring_if_stats_tlv(uint32_t *tag_buf) +{ + htt_ring_if_stats_tlv *dp_stats_buf = + (htt_ring_if_stats_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char low_wm_hit_count[DP_MAX_STRING_LEN]; + char high_wm_hit_count[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_RING_IF_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "base_addr = %d", + dp_stats_buf->base_addr); + DP_TRACE_STATS(FATAL, "elem_size = %d", + dp_stats_buf->elem_size); + DP_TRACE_STATS(FATAL, "num_elems__prefetch_tail_idx = %d", + dp_stats_buf->num_elems__prefetch_tail_idx); + DP_TRACE_STATS(FATAL, "head_idx__tail_idx = %d", + dp_stats_buf->head_idx__tail_idx); + DP_TRACE_STATS(FATAL, "shadow_head_idx__shadow_tail_idx = %d", + dp_stats_buf->shadow_head_idx__shadow_tail_idx); + DP_TRACE_STATS(FATAL, "num_tail_incr = %d", + dp_stats_buf->num_tail_incr); + DP_TRACE_STATS(FATAL, "lwm_thresh__hwm_thresh = %d", + dp_stats_buf->lwm_thresh__hwm_thresh); + DP_TRACE_STATS(FATAL, "overrun_hit_count = %d", + dp_stats_buf->overrun_hit_count); + DP_TRACE_STATS(FATAL, "underrun_hit_count = %d", + dp_stats_buf->underrun_hit_count); + DP_TRACE_STATS(FATAL, "prod_blockwait_count = %d", + dp_stats_buf->prod_blockwait_count); + DP_TRACE_STATS(FATAL, "cons_blockwait_count = %d", + dp_stats_buf->cons_blockwait_count); + + for (i = 0; i < DP_HTT_LOW_WM_HIT_COUNT_LEN; i++) { + index += qdf_snprint(&low_wm_hit_count[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->low_wm_hit_count[i]); + } + DP_TRACE_STATS(FATAL, "low_wm_hit_count = %s ", low_wm_hit_count); + + index = 0; + for (i = 0; i < DP_HTT_HIGH_WM_HIT_COUNT_LEN; i++) { + index += qdf_snprint(&high_wm_hit_count[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->high_wm_hit_count[i]); + } + DP_TRACE_STATS(FATAL, "high_wm_hit_count = %s\n", high_wm_hit_count); +} + +/* + * dp_print_ring_if_cmn_tlv: display htt_ring_if_cmn_tlv + * @tag_buf: buffer containing the tlv htt_ring_if_cmn_tlv + * + * return:void + */ +static inline void dp_print_ring_if_cmn_tlv(uint32_t *tag_buf) +{ + htt_ring_if_cmn_tlv *dp_stats_buf = + (htt_ring_if_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_RING_IF_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "num_records = %d\n", + dp_stats_buf->num_records); +} + +/* + * dp_print_sfm_client_user_tlv_v: display htt_sfm_client_user_tlv_v + * @tag_buf: buffer containing the tlv htt_sfm_client_user_tlv_v + * + * return:void + */ +static inline void dp_print_sfm_client_user_tlv_v(uint32_t *tag_buf) +{ + htt_sfm_client_user_tlv_v *dp_stats_buf = + (htt_sfm_client_user_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char dwords_used_by_user_n[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + DP_TRACE_STATS(FATAL, "HTT_SFM_CLIENT_USER_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&dwords_used_by_user_n[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->dwords_used_by_user_n[i]); + } + DP_TRACE_STATS(FATAL, "dwords_used_by_user_n = %s\n", + dwords_used_by_user_n); +} + +/* + * dp_print_sfm_client_tlv: display htt_sfm_client_tlv + * @tag_buf: buffer containing the tlv htt_sfm_client_tlv + * + * return:void + */ +static inline void dp_print_sfm_client_tlv(uint32_t *tag_buf) +{ + htt_sfm_client_tlv *dp_stats_buf = + (htt_sfm_client_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_SFM_CLIENT_TLV:"); + DP_TRACE_STATS(FATAL, "client_id = %d", + dp_stats_buf->client_id); + DP_TRACE_STATS(FATAL, "buf_min = %d", + dp_stats_buf->buf_min); + DP_TRACE_STATS(FATAL, "buf_max = %d", + dp_stats_buf->buf_max); + DP_TRACE_STATS(FATAL, "buf_busy = %d", + dp_stats_buf->buf_busy); + DP_TRACE_STATS(FATAL, "buf_alloc = %d", + dp_stats_buf->buf_alloc); + DP_TRACE_STATS(FATAL, "buf_avail = %d", + dp_stats_buf->buf_avail); + DP_TRACE_STATS(FATAL, "num_users = %d\n", + dp_stats_buf->num_users); +} + +/* + * dp_print_sfm_cmn_tlv: display htt_sfm_cmn_tlv + * @tag_buf: buffer containing the tlv htt_sfm_cmn_tlv + * + * return:void + */ +static inline void dp_print_sfm_cmn_tlv(uint32_t *tag_buf) +{ + htt_sfm_cmn_tlv *dp_stats_buf = + (htt_sfm_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_SFM_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "buf_total = %d", + dp_stats_buf->buf_total); + DP_TRACE_STATS(FATAL, "mem_empty = %d", + dp_stats_buf->mem_empty); + DP_TRACE_STATS(FATAL, "deallocate_bufs = %d", + dp_stats_buf->deallocate_bufs); + DP_TRACE_STATS(FATAL, "num_records = %d\n", + dp_stats_buf->num_records); +} + +/* + * dp_print_sring_stats_tlv: display htt_sring_stats_tlv + * @tag_buf: buffer containing the tlv htt_sring_stats_tlv + * + * return:void + */ +static inline void dp_print_sring_stats_tlv(uint32_t *tag_buf) +{ + htt_sring_stats_tlv *dp_stats_buf = + (htt_sring_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_SRING_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__ring_id__arena__ep = %d", + dp_stats_buf->mac_id__ring_id__arena__ep); + DP_TRACE_STATS(FATAL, "base_addr_lsb = %d", + dp_stats_buf->base_addr_lsb); + DP_TRACE_STATS(FATAL, "base_addr_msb = %d", + dp_stats_buf->base_addr_msb); + DP_TRACE_STATS(FATAL, "ring_size = %d", + dp_stats_buf->ring_size); + DP_TRACE_STATS(FATAL, "elem_size = %d", + dp_stats_buf->elem_size); + DP_TRACE_STATS(FATAL, "num_avail_words__num_valid_words = %d", + dp_stats_buf->num_avail_words__num_valid_words); + DP_TRACE_STATS(FATAL, "head_ptr__tail_ptr = %d", + dp_stats_buf->head_ptr__tail_ptr); + DP_TRACE_STATS(FATAL, "consumer_empty__producer_full = %d", + dp_stats_buf->consumer_empty__producer_full); + DP_TRACE_STATS(FATAL, "prefetch_count__internal_tail_ptr = %d\n", + dp_stats_buf->prefetch_count__internal_tail_ptr); +} + +/* + * dp_print_sring_cmn_tlv: display htt_sring_cmn_tlv + * @tag_buf: buffer containing the tlv htt_sring_cmn_tlv + * + * return:void + */ +static inline void dp_print_sring_cmn_tlv(uint32_t *tag_buf) +{ + htt_sring_cmn_tlv *dp_stats_buf = + (htt_sring_cmn_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_SRING_CMN_TLV:"); + DP_TRACE_STATS(FATAL, "num_records = %d\n", + dp_stats_buf->num_records); +} + +/* + * dp_print_tx_pdev_rate_stats_tlv: display htt_tx_pdev_rate_stats_tlv + * @tag_buf: buffer containing the tlv htt_tx_pdev_rate_stats_tlv + * + * return:void + */ +static inline void dp_print_tx_pdev_rate_stats_tlv(uint32_t *tag_buf) +{ + htt_tx_pdev_rate_stats_tlv *dp_stats_buf = + (htt_tx_pdev_rate_stats_tlv *)tag_buf; + uint8_t i, j; + uint16_t index = 0; + char str_buf[DP_MAX_STRING_LEN]; + char *tx_gi[HTT_TX_PEER_STATS_NUM_GI_COUNTERS]; + + for (i = 0; i < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; i++) { + tx_gi[i] = (char *)qdf_mem_malloc(DP_MAX_STRING_LEN); + } + + DP_TRACE_STATS(FATAL, "HTT_TX_PDEV_RATE_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "tx_ldpc = %d", + dp_stats_buf->tx_ldpc); + DP_TRACE_STATS(FATAL, "rts_cnt = %d", + dp_stats_buf->rts_cnt); + DP_TRACE_STATS(FATAL, "ack_rssi = %d", + dp_stats_buf->ack_rssi); + + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_SU_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_su_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_su_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_MU_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_mu_mcs[i]); + } + DP_TRACE_STATS(FATAL, "tx_mu_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_NSS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_nss[i]); + } + DP_TRACE_STATS(FATAL, "tx_nss = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_BW_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_bw[i]); + } + DP_TRACE_STATS(FATAL, "tx_bw = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_stbc[i]); + } + DP_TRACE_STATS(FATAL, "tx_stbc = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_PREAM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_pream[i]); + } + DP_TRACE_STATS(FATAL, "tx_pream = %s ", str_buf); + + for (j = 0; j < DP_HTT_PDEV_TX_GI_LEN; j++) { + index = 0; + for (i = 0; i < HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&tx_gi[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->tx_gi[j][i]); + } + DP_TRACE_STATS(FATAL, "tx_gi[%d] = %s ", j, tx_gi[j]); + } + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_TX_DCM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->tx_dcm[i]); + } + DP_TRACE_STATS(FATAL, "tx_dcm = %s\n", str_buf); + + for (i = 0; i < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; i++) + qdf_mem_free(tx_gi[i]); +} + +/* + * dp_print_rx_pdev_rate_stats_tlv: display htt_rx_pdev_rate_stats_tlv + * @tag_buf: buffer containing the tlv htt_rx_pdev_rate_stats_tlv + * + * return:void + */ +static inline void dp_print_rx_pdev_rate_stats_tlv(uint32_t *tag_buf) +{ + htt_rx_pdev_rate_stats_tlv *dp_stats_buf = + (htt_rx_pdev_rate_stats_tlv *)tag_buf; + uint8_t i, j; + uint16_t index = 0; + char *rssi_chain[DP_HTT_RSSI_CHAIN_LEN]; + char *rx_gi[HTT_RX_PDEV_STATS_NUM_GI_COUNTERS]; + char str_buf[DP_MAX_STRING_LEN]; + + for (i = 0; i < DP_HTT_RSSI_CHAIN_LEN; i++) + rssi_chain[i] = qdf_mem_malloc(DP_MAX_STRING_LEN); + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; i++) + rx_gi[i] = qdf_mem_malloc(DP_MAX_STRING_LEN); + + DP_TRACE_STATS(FATAL, "HTT_RX_PDEV_RATE_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "nsts = %d", + dp_stats_buf->nsts); + DP_TRACE_STATS(FATAL, "rx_ldpc = %d", + dp_stats_buf->rx_ldpc); + DP_TRACE_STATS(FATAL, "rts_cnt = %d", + dp_stats_buf->rts_cnt); + DP_TRACE_STATS(FATAL, "rssi_mgmt = %d", + dp_stats_buf->rssi_mgmt); + DP_TRACE_STATS(FATAL, "rssi_data = %d", + dp_stats_buf->rssi_data); + DP_TRACE_STATS(FATAL, "rssi_comb = %d", + dp_stats_buf->rssi_comb); + + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_MCS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_mcs[i]); + } + DP_TRACE_STATS(FATAL, "rx_mcs = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_NSS_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_nss[i]); + } + DP_TRACE_STATS(FATAL, "rx_nss = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_DCM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_dcm[i]); + } + DP_TRACE_STATS(FATAL, "rx_dcm = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_stbc[i]); + } + DP_TRACE_STATS(FATAL, "rx_stbc = %s ", str_buf); + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_BW_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_bw[i]); + } + DP_TRACE_STATS(FATAL, "rx_bw = %s ", str_buf); + + for (j = 0; j < DP_HTT_RSSI_CHAIN_LEN; j++) { + index = 0; + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++) { + index += qdf_snprint(&rssi_chain[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->rssi_chain[j][i]); + } + DP_TRACE_STATS(FATAL, "rssi_chain[%d] = %s ", j, rssi_chain[j]); + } + + for (j = 0; j < DP_HTT_RX_GI_LEN; j++) { + index = 0; + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS; i++) { + index += qdf_snprint(&rx_gi[j][index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->rx_gi[j][i]); + } + DP_TRACE_STATS(FATAL, "rx_gi[%d] = %s ", j, rx_gi[j]); + } + + index = 0; + qdf_mem_set(str_buf, DP_MAX_STRING_LEN, 0x0); + for (i = 0; i < DP_HTT_RX_PREAM_LEN; i++) { + index += qdf_snprint(&str_buf[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->rx_pream[i]); + } + DP_TRACE_STATS(FATAL, "rx_pream = %s\n", str_buf); + for (i = 0; i < DP_HTT_RSSI_CHAIN_LEN; i++) + qdf_mem_free(rssi_chain[i]); + for (i = 0; i < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; i++) + qdf_mem_free(rx_gi[i]); +} + +/* + * dp_print_rx_soc_fw_stats_tlv: display htt_rx_soc_fw_stats_tlv + * @tag_buf: buffer containing the tlv htt_rx_soc_fw_stats_tlv + * + * return:void + */ +static inline void dp_print_rx_soc_fw_stats_tlv(uint32_t *tag_buf) +{ + htt_rx_soc_fw_stats_tlv *dp_stats_buf = + (htt_rx_soc_fw_stats_tlv *)tag_buf; + + DP_TRACE_STATS(FATAL, "HTT_RX_SOC_FW_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "fw_reo_ring_data_msdu = %d", + dp_stats_buf->fw_reo_ring_data_msdu); + DP_TRACE_STATS(FATAL, "fw_to_host_data_msdu_bcmc = %d", + dp_stats_buf->fw_to_host_data_msdu_bcmc); + DP_TRACE_STATS(FATAL, "fw_to_host_data_msdu_uc = %d", + dp_stats_buf->fw_to_host_data_msdu_uc); + DP_TRACE_STATS(FATAL, "ofld_remote_data_buf_recycle_cnt = %d", + dp_stats_buf->ofld_remote_data_buf_recycle_cnt); + DP_TRACE_STATS(FATAL, "ofld_remote_free_buf_indication_cnt = %d\n", + dp_stats_buf->ofld_remote_free_buf_indication_cnt); +} + +/* + * dp_print_rx_soc_fw_refill_ring_empty_tlv_v: display + * htt_rx_soc_fw_refill_ring_empty_tlv_v + * @tag_buf: buffer containing the tlv htt_rx_soc_fw_refill_ring_empty_tlv_v + * + * return:void + */ +static inline void dp_print_rx_soc_fw_refill_ring_empty_tlv_v(uint32_t *tag_buf) +{ + htt_rx_soc_fw_refill_ring_empty_tlv_v *dp_stats_buf = + (htt_rx_soc_fw_refill_ring_empty_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char refill_ring_empty_cnt[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_RX_STATS_REFILL_MAX_RING); + + DP_TRACE_STATS(FATAL, "HTT_RX_SOC_FW_REFILL_RING_EMPTY_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&refill_ring_empty_cnt[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->refill_ring_empty_cnt[i]); + } + DP_TRACE_STATS(FATAL, "refill_ring_empty_cnt = %s\n", + refill_ring_empty_cnt); +} + +/* + * dp_print_rx_soc_fw_refill_ring_num_refill_tlv_v: display + * htt_rx_soc_fw_refill_ring_num_refill_tlv_v + * @tag_buf: buffer containing the tlv htt_rx_soc_fw_refill_ring_num_refill_tlv + * + * return:void + */ +static inline void dp_print_rx_soc_fw_refill_ring_num_refill_tlv_v( + uint32_t *tag_buf) +{ + htt_rx_soc_fw_refill_ring_num_refill_tlv_v *dp_stats_buf = + (htt_rx_soc_fw_refill_ring_num_refill_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char refill_ring_num_refill[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_TX_PDEV_MAX_URRN_STATS); + + DP_TRACE_STATS(FATAL, "HTT_RX_SOC_FW_REFILL_RING_NUM_REFILL_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&refill_ring_num_refill[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->refill_ring_num_refill[i]); + } + DP_TRACE_STATS(FATAL, "refill_ring_num_refill = %s\n", + refill_ring_num_refill); +} + +/* + * dp_print_rx_pdev_fw_stats_tlv: display htt_rx_pdev_fw_stats_tlv + * @tag_buf: buffer containing the tlv htt_rx_pdev_fw_stats_tlv + * + * return:void + */ +static inline void dp_print_rx_pdev_fw_stats_tlv(uint32_t *tag_buf) +{ + htt_rx_pdev_fw_stats_tlv *dp_stats_buf = + (htt_rx_pdev_fw_stats_tlv *)tag_buf; + uint8_t i; + uint16_t index = 0; + char fw_ring_mgmt_subtype[DP_MAX_STRING_LEN]; + char fw_ring_ctrl_subtype[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_RX_PDEV_FW_STATS_TLV:"); + DP_TRACE_STATS(FATAL, "mac_id__word = %d", + dp_stats_buf->mac_id__word); + DP_TRACE_STATS(FATAL, "ppdu_recvd = %d", + dp_stats_buf->ppdu_recvd); + DP_TRACE_STATS(FATAL, "mpdu_cnt_fcs_ok = %d", + dp_stats_buf->mpdu_cnt_fcs_ok); + DP_TRACE_STATS(FATAL, "mpdu_cnt_fcs_err = %d", + dp_stats_buf->mpdu_cnt_fcs_err); + DP_TRACE_STATS(FATAL, "tcp_msdu_cnt = %d", + dp_stats_buf->tcp_msdu_cnt); + DP_TRACE_STATS(FATAL, "tcp_ack_msdu_cnt = %d", + dp_stats_buf->tcp_ack_msdu_cnt); + DP_TRACE_STATS(FATAL, "udp_msdu_cnt = %d", + dp_stats_buf->udp_msdu_cnt); + DP_TRACE_STATS(FATAL, "other_msdu_cnt = %d", + dp_stats_buf->other_msdu_cnt); + DP_TRACE_STATS(FATAL, "fw_ring_mpdu_ind = %d", + dp_stats_buf->fw_ring_mpdu_ind); + + for (i = 0; i < DP_HTT_FW_RING_MGMT_SUBTYPE_LEN; i++) { + index += qdf_snprint(&fw_ring_mgmt_subtype[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->fw_ring_mgmt_subtype[i]); + } + DP_TRACE_STATS(FATAL, "fw_ring_mgmt_subtype = %s ", fw_ring_mgmt_subtype); + + index = 0; + for (i = 0; i < DP_HTT_FW_RING_CTRL_SUBTYPE_LEN; i++) { + index += qdf_snprint(&fw_ring_ctrl_subtype[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->fw_ring_ctrl_subtype[i]); + } + DP_TRACE_STATS(FATAL, "fw_ring_ctrl_subtype = %s ", fw_ring_ctrl_subtype); + DP_TRACE_STATS(FATAL, "fw_ring_mcast_data_msdu = %d", + dp_stats_buf->fw_ring_mcast_data_msdu); + DP_TRACE_STATS(FATAL, "fw_ring_bcast_data_msdu = %d", + dp_stats_buf->fw_ring_bcast_data_msdu); + DP_TRACE_STATS(FATAL, "fw_ring_ucast_data_msdu = %d", + dp_stats_buf->fw_ring_ucast_data_msdu); + DP_TRACE_STATS(FATAL, "fw_ring_null_data_msdu = %d", + dp_stats_buf->fw_ring_null_data_msdu); + DP_TRACE_STATS(FATAL, "fw_ring_mpdu_drop = %d", + dp_stats_buf->fw_ring_mpdu_drop); + DP_TRACE_STATS(FATAL, "ofld_local_data_ind_cnt = %d", + dp_stats_buf->ofld_local_data_ind_cnt); + DP_TRACE_STATS(FATAL, "ofld_local_data_buf_recycle_cnt = %d", + dp_stats_buf->ofld_local_data_buf_recycle_cnt); + DP_TRACE_STATS(FATAL, "drx_local_data_ind_cnt = %d", + dp_stats_buf->drx_local_data_ind_cnt); + DP_TRACE_STATS(FATAL, "drx_local_data_buf_recycle_cnt = %d", + dp_stats_buf->drx_local_data_buf_recycle_cnt); + DP_TRACE_STATS(FATAL, "local_nondata_ind_cnt = %d", + dp_stats_buf->local_nondata_ind_cnt); + DP_TRACE_STATS(FATAL, "local_nondata_buf_recycle_cnt = %d", + dp_stats_buf->local_nondata_buf_recycle_cnt); + DP_TRACE_STATS(FATAL, "fw_status_buf_ring_refill_cnt = %d", + dp_stats_buf->fw_status_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "fw_status_buf_ring_empty_cnt = %d", + dp_stats_buf->fw_status_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "fw_pkt_buf_ring_refill_cnt = %d", + dp_stats_buf->fw_pkt_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "fw_pkt_buf_ring_empty_cnt = %d", + dp_stats_buf->fw_pkt_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "fw_link_buf_ring_refill_cnt = %d", + dp_stats_buf->fw_link_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "fw_link_buf_ring_empty_cnt = %d", + dp_stats_buf->fw_link_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "host_pkt_buf_ring_refill_cnt = %d", + dp_stats_buf->host_pkt_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "host_pkt_buf_ring_empty_cnt = %d", + dp_stats_buf->host_pkt_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "mon_pkt_buf_ring_refill_cnt = %d", + dp_stats_buf->mon_pkt_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "mon_pkt_buf_ring_empty_cnt = %d", + dp_stats_buf->mon_pkt_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "mon_status_buf_ring_refill_cnt = %d", + dp_stats_buf->mon_status_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "mon_status_buf_ring_empty_cnt = %d", + dp_stats_buf->mon_status_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "mon_desc_buf_ring_refill_cnt = %d", + dp_stats_buf->mon_desc_buf_ring_refill_cnt); + DP_TRACE_STATS(FATAL, "mon_desc_buf_ring_empty_cnt = %d", + dp_stats_buf->mon_desc_buf_ring_empty_cnt); + DP_TRACE_STATS(FATAL, "mon_dest_ring_update_cnt = %d", + dp_stats_buf->mon_dest_ring_update_cnt); + DP_TRACE_STATS(FATAL, "mon_dest_ring_full_cnt = %d", + dp_stats_buf->mon_dest_ring_full_cnt); + DP_TRACE_STATS(FATAL, "rx_suspend_cnt = %d", + dp_stats_buf->rx_suspend_cnt); + DP_TRACE_STATS(FATAL, "rx_suspend_fail_cnt = %d", + dp_stats_buf->rx_suspend_fail_cnt); + DP_TRACE_STATS(FATAL, "rx_resume_cnt = %d", + dp_stats_buf->rx_resume_cnt); + DP_TRACE_STATS(FATAL, "rx_resume_fail_cnt = %d", + dp_stats_buf->rx_resume_fail_cnt); + DP_TRACE_STATS(FATAL, "rx_ring_switch_cnt = %d", + dp_stats_buf->rx_ring_switch_cnt); + DP_TRACE_STATS(FATAL, "rx_ring_restore_cnt = %d", + dp_stats_buf->rx_ring_restore_cnt); + DP_TRACE_STATS(FATAL, "rx_flush_cnt = %d\n", + dp_stats_buf->rx_flush_cnt); +} + +/* + * dp_print_rx_pdev_fw_ring_mpdu_err_tlv_v: display + * htt_rx_pdev_fw_ring_mpdu_err_tlv_v + * @tag_buf: buffer containing the tlv htt_rx_pdev_fw_ring_mpdu_err_tlv_v + * + * return:void + */ +static inline void dp_print_rx_pdev_fw_ring_mpdu_err_tlv_v(uint32_t *tag_buf) +{ + htt_rx_pdev_fw_ring_mpdu_err_tlv_v *dp_stats_buf = + (htt_rx_pdev_fw_ring_mpdu_err_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char fw_ring_mpdu_err[DP_MAX_STRING_LEN]; + + DP_TRACE_STATS(FATAL, "HTT_RX_PDEV_FW_RING_MPDU_ERR_TLV_V:"); + for (i = 0; i < DP_HTT_FW_RING_MPDU_ERR_LEN; i++) { + index += qdf_snprint(&fw_ring_mpdu_err[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, + dp_stats_buf->fw_ring_mpdu_err[i]); + } + DP_TRACE_STATS(FATAL, "fw_ring_mpdu_err = %s\n", fw_ring_mpdu_err); +} + +/* + * dp_print_rx_pdev_fw_mpdu_drop_tlv_v: display htt_rx_pdev_fw_mpdu_drop_tlv_v + * @tag_buf: buffer containing the tlv htt_rx_pdev_fw_mpdu_drop_tlv_v + * + * return:void + */ +static inline void dp_print_rx_pdev_fw_mpdu_drop_tlv_v(uint32_t *tag_buf) +{ + htt_rx_pdev_fw_mpdu_drop_tlv_v *dp_stats_buf = + (htt_rx_pdev_fw_mpdu_drop_tlv_v *)tag_buf; + uint8_t i; + uint16_t index = 0; + char fw_mpdu_drop[DP_MAX_STRING_LEN]; + uint32_t tag_len = (HTT_STATS_TLV_LENGTH_GET(*tag_buf) >> 2); + + tag_len = qdf_min(tag_len, (uint32_t)HTT_RX_STATS_FW_DROP_REASON_MAX); + + DP_TRACE_STATS(FATAL, "HTT_RX_PDEV_FW_MPDU_DROP_TLV_V:"); + for (i = 0; i < tag_len; i++) { + index += qdf_snprint(&fw_mpdu_drop[index], + DP_MAX_STRING_LEN - index, + " %d:%d,", i, dp_stats_buf->fw_mpdu_drop[i]); + } + DP_TRACE_STATS(FATAL, "fw_mpdu_drop = %s\n", fw_mpdu_drop); +} + +/* * dp_htt_stats_print_tag: function to select the tag type and * print the corresponding tag structure * @tag_type: tag type that is to be printed @@ -256,6 +2565,257 @@ void dp_htt_stats_print_tag(uint8_t tag_type, uint32_t *tag_buf) case HTT_STATS_TX_PDEV_SIFS_TAG: dp_print_tx_pdev_stats_sifs_tlv_v(tag_buf); break; + case HTT_STATS_TX_PDEV_FLUSH_TAG: + dp_print_tx_pdev_stats_flush_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_PDEV_PHY_ERR_TAG: + dp_print_tx_pdev_stats_phy_err_tlv_v(tag_buf); + break; + + case HTT_STATS_STRING_TAG: + dp_print_stats_string_tlv(tag_buf); + break; + + case HTT_STATS_TX_HWQ_CMN_TAG: + dp_print_tx_hwq_stats_cmn_tlv(tag_buf); + break; + + case HTT_STATS_TX_HWQ_DIFS_LATENCY_TAG: + dp_print_tx_hwq_difs_latency_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_HWQ_CMD_RESULT_TAG: + dp_print_tx_hwq_cmd_result_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_HWQ_CMD_STALL_TAG: + dp_print_tx_hwq_cmd_stall_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_HWQ_FES_STATUS_TAG: + dp_print_tx_hwq_fes_result_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_TQM_GEN_MPDU_TAG: + dp_print_tx_tqm_gen_mpdu_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_TQM_LIST_MPDU_TAG: + dp_print_tx_tqm_list_mpdu_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG: + dp_print_tx_tqm_list_mpdu_cnt_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_TQM_CMN_TAG: + dp_print_tx_tqm_cmn_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_TQM_PDEV_TAG: + dp_print_tx_tqm_pdev_stats_tlv_v(tag_buf); + break; + + case HTT_STATS_TX_TQM_CMDQ_STATUS_TAG: + dp_print_tx_tqm_cmdq_status_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG: + dp_print_tx_de_eapol_packets_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG: + dp_print_tx_de_classify_failed_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG: + dp_print_tx_de_classify_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG: + dp_print_tx_de_classify_status_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG: + dp_print_tx_de_enqueue_packets_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG: + dp_print_tx_de_enqueue_discard_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_DE_CMN_TAG: + dp_print_tx_de_cmn_stats_tlv(tag_buf); + break; + + case HTT_STATS_RING_IF_TAG: + dp_print_ring_if_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG: + dp_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf); + break; + + case HTT_STATS_SFM_CMN_TAG: + dp_print_sfm_cmn_tlv(tag_buf); + break; + + case HTT_STATS_SRING_STATS_TAG: + dp_print_sring_stats_tlv(tag_buf); + break; + + case HTT_STATS_RX_PDEV_FW_STATS_TAG: + dp_print_rx_pdev_fw_stats_tlv(tag_buf); + break; + + case HTT_STATS_RX_PDEV_FW_RING_MPDU_ERR_TAG: + dp_print_rx_pdev_fw_ring_mpdu_err_tlv_v(tag_buf); + break; + + case HTT_STATS_RX_PDEV_FW_MPDU_DROP_TAG: + dp_print_rx_pdev_fw_mpdu_drop_tlv_v(tag_buf); + break; + + case HTT_STATS_RX_SOC_FW_STATS_TAG: + dp_print_rx_soc_fw_stats_tlv(tag_buf); + break; + + case HTT_STATS_RX_SOC_FW_REFILL_RING_EMPTY_TAG: + dp_print_rx_soc_fw_refill_ring_empty_tlv_v(tag_buf); + break; + + case HTT_STATS_RX_SOC_FW_REFILL_RING_NUM_REFILL_TAG: + dp_print_rx_soc_fw_refill_ring_num_refill_tlv_v( + tag_buf); + break; + + case HTT_STATS_TX_PDEV_RATE_STATS_TAG: + dp_print_tx_pdev_rate_stats_tlv(tag_buf); + break; + + case HTT_STATS_RX_PDEV_RATE_STATS_TAG: + dp_print_rx_pdev_rate_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG: + dp_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf); + break; + + case HTT_STATS_TX_SCHED_CMN_TAG: + dp_print_stats_tx_sched_cmn_tlv(tag_buf); + break; + + case HTT_STATS_TX_PDEV_MUMIMO_MPDU_STATS_TAG: + dp_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf); + break; + + case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG: + dp_print_sched_txq_cmd_posted_tlv_v(tag_buf); + break; + + case HTT_STATS_RING_IF_CMN_TAG: + dp_print_ring_if_cmn_tlv(tag_buf); + break; + + case HTT_STATS_SFM_CLIENT_USER_TAG: + dp_print_sfm_client_user_tlv_v(tag_buf); + break; + + case HTT_STATS_SFM_CLIENT_TAG: + dp_print_sfm_client_tlv(tag_buf); + break; + + case HTT_STATS_TX_TQM_ERROR_STATS_TAG: + dp_print_tx_tqm_error_stats_tlv(tag_buf); + break; + + case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG: + dp_print_sched_txq_cmd_reaped_tlv_v(tag_buf); + break; + + case HTT_STATS_SRING_CMN_TAG: + dp_print_sring_cmn_tlv(tag_buf); + break; + + case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG: + dp_print_tx_selfgen_ac_err_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG: + dp_print_tx_selfgen_cmn_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_SELFGEN_AC_STATS_TAG: + dp_print_tx_selfgen_ac_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_SELFGEN_AX_STATS_TAG: + dp_print_tx_selfgen_ax_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG: + dp_print_tx_selfgen_ax_err_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_HWQ_MUMIMO_SCH_STATS_TAG: + dp_print_tx_hwq_mu_mimo_sch_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_HWQ_MUMIMO_MPDU_STATS_TAG: + dp_print_tx_hwq_mu_mimo_mpdu_stats_tlv(tag_buf); + break; + + case HTT_STATS_TX_HWQ_MUMIMO_CMN_STATS_TAG: + dp_print_tx_hwq_mu_mimo_cmn_stats_tlv(tag_buf); + break; + + case HTT_STATS_HW_INTR_MISC_TAG: + dp_print_hw_stats_intr_misc_tlv(tag_buf); + break; + + case HTT_STATS_HW_WD_TIMEOUT_TAG: + dp_print_hw_stats_wd_timeout_tlv(tag_buf); + break; + + case HTT_STATS_HW_PDEV_ERRS_TAG: + dp_print_hw_stats_pdev_errs_tlv(tag_buf); + break; + + case HTT_STATS_COUNTER_NAME_TAG: + dp_print_counter_tlv(tag_buf); + break; + + case HTT_STATS_TX_TID_DETAILS_TAG: + dp_print_tx_tid_stats_tlv(tag_buf); + break; + + case HTT_STATS_RX_TID_DETAILS_TAG: + dp_print_rx_tid_stats_tlv(tag_buf); + break; + + case HTT_STATS_PEER_STATS_CMN_TAG: + dp_print_peer_stats_cmn_tlv(tag_buf); + break; + + case HTT_STATS_PEER_DETAILS_TAG: + dp_print_peer_details_tlv(tag_buf); + break; + + case HTT_STATS_PEER_MSDU_FLOWQ_TAG: + dp_print_msdu_flow_stats_tlv(tag_buf); + break; + + case HTT_STATS_PEER_TX_RATE_STATS_TAG: + dp_print_tx_peer_rate_stats_tlv(tag_buf); + break; + + case HTT_STATS_PEER_RX_RATE_STATS_TAG: + dp_print_rx_peer_rate_stats_tlv(tag_buf); + break; + case HTT_STATS_TX_DE_COMPL_STATS_TAG: + dp_print_tx_de_compl_stats_tlv(tag_buf); + break; default: break; } From cb5d59b696be0ed19dfc6851a54e9662a6788e04 Mon Sep 17 00:00:00 2001 From: Sreelakshmi Konamki Date: Thu, 25 May 2017 18:11:03 +0530 Subject: [PATCH 2/5] qcacmn: Fix different types of case labels used in switch statement Fix to update same enum wmi_scan_event_type types in switch statement of extract_vdev_scan_ev_param_tlv() Change-Id: I4817e57f2a9f309581392faadc1640c05d7fcf2b CRs-Fixed: 2049514 --- wmi/src/wmi_unified_tlv.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index aebcc5fbe189..98c984471947 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -15768,7 +15768,7 @@ static QDF_STATUS extract_vdev_scan_ev_param_tlv(wmi_unified_t wmi_handle, case WMI_SCAN_EVENT_RESTARTED: param->type = SCAN_EVENT_TYPE_RESTARTED; break; - case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT: + case WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT: param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT; break; case WMI_SCAN_EVENT_MAX: From 9d9fa19d83b9794495c1e0f8cb9e7ea6dced5817 Mon Sep 17 00:00:00 2001 From: Yu Wang Date: Fri, 10 Mar 2017 15:19:02 +0800 Subject: [PATCH 3/5] qcacmn: add 'const' for 'section' in struct TGT_REG_TABLE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit To fix the following compilation error: warning: assignment discards ‘const’ qualifier from pointer target type, at: reg_table->section = ar6320v2_reg_table in ol_fw.c. It's because the register table is a const array, while reg_table->section does not point to a const. So add 'const' for 'section'. Change-Id: Idfef358817241e73d660d2730b74c2ca88e23af1 CRs-Fixed: 2017786 --- hif/inc/regtable_pcie.h | 2 +- hif/src/sdio/regtable_sdio.h | 2 +- hif/src/usb/regtable_usb.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/hif/inc/regtable_pcie.h b/hif/inc/regtable_pcie.h index 87d55c52bf09..9dcb9e7d273b 100644 --- a/hif/inc/regtable_pcie.h +++ b/hif/inc/regtable_pcie.h @@ -740,7 +740,7 @@ struct tgt_reg_section { }; struct tgt_reg_table { - struct tgt_reg_section *section; + const struct tgt_reg_section *section; uint32_t section_size; }; diff --git a/hif/src/sdio/regtable_sdio.h b/hif/src/sdio/regtable_sdio.h index 7b03208b78d6..d6b30fb16058 100644 --- a/hif/src/sdio/regtable_sdio.h +++ b/hif/src/sdio/regtable_sdio.h @@ -879,7 +879,7 @@ struct tgt_reg_section { struct tgt_reg_table { - struct tgt_reg_section *section; + const struct tgt_reg_section *section; uint32_t section_size; }; #endif /* _REGTABLE_SDIO_H_ */ diff --git a/hif/src/usb/regtable_usb.h b/hif/src/usb/regtable_usb.h index 1e5e49d7edd6..4d17bcc0d5e0 100644 --- a/hif/src/usb/regtable_usb.h +++ b/hif/src/usb/regtable_usb.h @@ -1285,7 +1285,7 @@ struct tgt_reg_section { }; struct tgt_reg_table { - struct tgt_reg_section *section; + const struct tgt_reg_section *section; u_int32_t section_size; }; From f3351d97d720bd15657aee22e8d6d3d59744b2de Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Mon, 24 Apr 2017 10:47:42 -0700 Subject: [PATCH 4/5] qcacmn: Expose scan_backoff_multiplier for NLO/PNO For Network Listen Offload and Perfered Network Offload, the fast scan period is multiplied by scan_backoff_multiplier after max cycles have occurred. Expose scan_backoff_multiplier to consumers of the WMI API, so this parameter can be configured. Change-Id: I478fb61cd096d3496205f4ff556e180dabf99b77 CRs-Fixed: 2035201 --- os_if/linux/scan/inc/wlan_cfg80211_scan.h | 4 +++- os_if/linux/scan/src/wlan_cfg80211_scan.c | 6 ++++-- umac/scan/dispatcher/inc/wlan_scan_public_structs.h | 7 +++++++ wmi/src/wmi_unified_tlv.c | 1 + 4 files changed, 15 insertions(+), 3 deletions(-) diff --git a/os_if/linux/scan/inc/wlan_cfg80211_scan.h b/os_if/linux/scan/inc/wlan_cfg80211_scan.h index 3b47f7738cb7..b455b87cf3b6 100644 --- a/os_if/linux/scan/inc/wlan_cfg80211_scan.h +++ b/os_if/linux/scan/inc/wlan_cfg80211_scan.h @@ -117,12 +117,14 @@ struct scan_req { * @pdev: pdev pointer * @dev: Pointer network device * @request: Pointer to cfg80211 scheduled scan start request + * @scan_backoff_multiplier: multiply scan period by this after max cycles * * Return: 0 for success, non zero for failure */ int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_pdev *pdev, struct net_device *dev, - struct cfg80211_sched_scan_request *request); + struct cfg80211_sched_scan_request *request, + uint8_t scan_backoff_multiplier); /** * wlan_cfg80211_sched_scan_stop() - cfg80211 scheduled scan(pno) stop diff --git a/os_if/linux/scan/src/wlan_cfg80211_scan.c b/os_if/linux/scan/src/wlan_cfg80211_scan.c index 2ec383b23a80..9381ef7b516d 100644 --- a/os_if/linux/scan/src/wlan_cfg80211_scan.c +++ b/os_if/linux/scan/src/wlan_cfg80211_scan.c @@ -140,7 +140,7 @@ static void wlan_cfg80211_pno_callback(struct wlan_objmgr_vdev *vdev, pdev_ospriv = wlan_pdev_get_ospriv(pdev); wlan_pdev_obj_unlock(pdev); if (!pdev_ospriv) { - cfg80211_err("pdev_osprivis NULL"); + cfg80211_err("pdev_ospriv is NULL"); return; } cfg80211_sched_scan_results(pdev_ospriv->wiphy); @@ -181,7 +181,8 @@ static QDF_STATUS wlan_cfg80211_is_pno_allowed(struct wlan_objmgr_vdev *vdev) int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_pdev *pdev, struct net_device *dev, - struct cfg80211_sched_scan_request *request) + struct cfg80211_sched_scan_request *request, + uint8_t scan_backoff_multiplier) { struct pno_scan_req_params *req; int i, j, ret = 0; @@ -342,6 +343,7 @@ int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_pdev *pdev, */ wlan_config_sched_scan_plan(req, request); req->delay_start_time = hdd_config_sched_scan_start_delay(request); + req->scan_backoff_multiplier = scan_backoff_multiplier; cfg80211_notice("Base scan interval: %d sec, scan cycles: %d, slow scan interval %d", req->fast_scan_period, req->fast_scan_max_cycles, req->slow_scan_period); diff --git a/umac/scan/dispatcher/inc/wlan_scan_public_structs.h b/umac/scan/dispatcher/inc/wlan_scan_public_structs.h index d413547b7dfe..a3fada2c6f90 100644 --- a/umac/scan/dispatcher/inc/wlan_scan_public_structs.h +++ b/umac/scan/dispatcher/inc/wlan_scan_public_structs.h @@ -880,6 +880,7 @@ struct pno_nw_type { * @slow_scan_period: Slow scan period * @delay_start_time: delay in seconds to use before starting the first scan * @fast_scan_max_cycles: Fast scan max cycles + * @scan_backoff_multiplier: multiply fast scan period by this after max cycles * @pno_channel_prediction: PNO channel prediction feature status * @uint32_t active_dwell_time: active dwell time * @uint32_t passive_dwell_time: passive dwell time @@ -890,6 +891,11 @@ struct pno_nw_type { * @channel_prediction_full_scan: periodic timer upon which a full scan needs * to be triggered. * @networks_list: Preferred network list + * + * E.g. + * { fast_scan_period=120, fast_scan_max_cycles=2, + * slow_scan_period=1800, scan_backoff_multiplier=2 } + * Result: 120s x2, 240s x2, 480s x2, 960s x2, 1800s xN */ struct pno_scan_req_params { uint32_t networks_cnt; @@ -898,6 +904,7 @@ struct pno_scan_req_params { uint32_t slow_scan_period; uint32_t delay_start_time; uint32_t fast_scan_max_cycles; + uint8_t scan_backoff_multiplier; uint32_t active_dwell_time; uint32_t passive_dwell_time; uint32_t pno_channel_prediction; diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index 98c984471947..988c8f7fe626 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -7020,6 +7020,7 @@ static QDF_STATUS send_pno_start_cmd_tlv(wmi_unified_t wmi_handle, cmd->slow_scan_period = pno->slow_scan_period; cmd->delay_start_time = WMI_SEC_TO_MSEC(pno->delay_start_time); cmd->fast_scan_max_cycles = pno->fast_scan_max_cycles; + cmd->scan_backoff_multiplier = pno->scan_backoff_multiplier; WMI_LOGD("fast_scan_period: %d msec slow_scan_period: %d msec", cmd->fast_scan_period, cmd->slow_scan_period); WMI_LOGD("fast_scan_max_cycles: %d", cmd->fast_scan_max_cycles); From 7dc39001a5eaaa8bb0bfa9ac21b4bdc38108ce84 Mon Sep 17 00:00:00 2001 From: Abhijit Pradhan Date: Mon, 29 May 2017 20:43:03 +0530 Subject: [PATCH 5/5] qcacmn: Avoid using "ic_" prefix in common component code In DFS component the prefix "ic_ " was being used to represent ieee80211 channel related variables. Now use prefix "dfs_ch_" instead of "ic_". Change-Id: I2f739dc22ad89b7e410c06462876a22c2a615883 CRs-Fixed: 2056957 --- umac/cmn_services/dfs/inc/dfs_ioctl.h | 2 +- umac/dfs/core/src/dfs.h | 50 +++--- umac/dfs/core/src/dfs_channel.h | 156 +++++++++--------- umac/dfs/core/src/filtering/dfs_ar.c | 2 +- umac/dfs/core/src/filtering/dfs_fcc_bin5.c | 2 +- umac/dfs/core/src/filtering/dfs_phyerr_tlv.c | 10 +- .../core/src/filtering/dfs_process_phyerr.c | 6 +- .../src/filtering/dfs_process_radarevent.c | 18 +- umac/dfs/core/src/filtering/dfs_radar.c | 23 +-- umac/dfs/core/src/misc/dfs.c | 87 +++++----- umac/dfs/core/src/misc/dfs_cac.c | 117 ++++++------- umac/dfs/core/src/misc/dfs_nol.c | 26 +-- .../src/misc/dfs_process_radar_found_ind.c | 6 +- umac/dfs/core/src/misc/dfs_random_chan_sel.c | 52 +++--- umac/dfs/core/src/misc/dfs_zero_cac.c | 87 +++++----- umac/dfs/dispatcher/inc/wlan_dfs_mlme_api.h | 104 ++++++------ umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h | 24 +-- umac/dfs/dispatcher/inc/wlan_dfs_ucfg_api.h | 58 +++---- .../dispatcher/src/wlan_dfs_init_deinit_api.c | 11 +- umac/dfs/dispatcher/src/wlan_dfs_mlme_api.c | 108 ++++++------ umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c | 29 ++-- umac/dfs/dispatcher/src/wlan_dfs_utils_api.c | 13 +- 22 files changed, 510 insertions(+), 481 deletions(-) diff --git a/umac/cmn_services/dfs/inc/dfs_ioctl.h b/umac/cmn_services/dfs/inc/dfs_ioctl.h index a7451631ef8a..6f0e2147f4c8 100644 --- a/umac/cmn_services/dfs/inc/dfs_ioctl.h +++ b/umac/cmn_services/dfs/inc/dfs_ioctl.h @@ -79,7 +79,7 @@ struct dfsreq_nolelem { }; struct dfsreq_nolinfo { - uint32_t ic_nchans; + uint32_t dfs_ch_nchans; struct dfsreq_nolelem dfs_nol[IEEE80211_CHAN_MAX]; }; diff --git a/umac/dfs/core/src/dfs.h b/umac/dfs/core/src/dfs.h index aa133f2a961f..3bf04ed7a117 100644 --- a/umac/dfs/core/src/dfs.h +++ b/umac/dfs/core/src/dfs.h @@ -438,21 +438,21 @@ struct dfs_filtertype { /** * struct dfs_ieee80211_channel - Channel structure for dfs component. - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz * mode of operation. */ struct dfs_ieee80211_channel { - uint16_t ic_freq; - uint32_t ic_flags; - uint16_t ic_flagext; - uint8_t ic_ieee; - uint8_t ic_vhtop_ch_freq_seg1; - uint8_t ic_vhtop_ch_freq_seg2; + uint16_t dfs_ch_freq; + uint32_t dfs_ch_flags; + uint16_t dfs_ch_flagext; + uint8_t dfs_ch_ieee; + uint8_t dfs_ch_vhtop_ch_freq_seg1; + uint8_t dfs_ch_vhtop_ch_freq_seg2; }; /** @@ -1567,7 +1567,7 @@ int dfs_override_cac_timeout(struct wlan_dfs *dfs, /** * dfs_clear_nolhistory() - unmarks IEEE80211_CHAN_CLR_HISTORY_RADAR flag for - * all the channels in ic_channels. + * all the channels in dfs_ch_channels. * @dfs: Pointer to wlan_dfs structure. */ void dfs_clear_nolhistory(struct wlan_dfs *dfs); @@ -1710,20 +1710,20 @@ void ol_if_dfs_clist_update(struct wlan_dfs *dfs, /** * dfs_set_current_channel() - Set DFS current channel. * @dfs: Pointer to wlan_dfs structure. - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency1. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency2. + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency1. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency2. */ void dfs_set_current_channel(struct wlan_dfs *dfs, - uint16_t ic_freq, - uint32_t ic_flags, - uint16_t ic_flagext, - uint8_t ic_ieee, - uint8_t ic_vhtop_ch_freq_seg1, - uint8_t ic_vhtop_ch_freq_seg2); + uint16_t dfs_ch_freq, + uint32_t dfs_ch_flags, + uint16_t dfs_ch_flagext, + uint8_t dfs_ch_ieee, + uint8_t dfs_ch_vhtop_ch_freq_seg1, + uint8_t dfs_ch_vhtop_ch_freq_seg2); /** * dfs_second_segment_radar_disable() - Disables the second segment radar. diff --git a/umac/dfs/core/src/dfs_channel.h b/umac/dfs/core/src/dfs_channel.h index aec5378ee10a..8e30bba1ea27 100644 --- a/umac/dfs/core/src/dfs_channel.h +++ b/umac/dfs/core/src/dfs_channel.h @@ -252,142 +252,143 @@ enum dfs_ieee80211_opmode { (IEEE80211_CHAN_ALL | IEEE80211_CHAN_TURBO | IEEE80211_CHAN_STURBO) #define IEEE80211_IS_CHAN_FHSS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_FHSS) == IEEE80211_CHAN_FHSS) #define IEEE80211_IS_CHAN_A(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_A) == IEEE80211_CHAN_A) #define IEEE80211_IS_CHAN_B(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_B) == IEEE80211_CHAN_B) #define IEEE80211_IS_CHAN_PUREG(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_PUREG) == IEEE80211_CHAN_PUREG) #define IEEE80211_IS_CHAN_G(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_G) == IEEE80211_CHAN_G) #define IEEE80211_IS_CHAN_ANYG(_c) \ (IEEE80211_IS_CHAN_PUREG(_c) || IEEE80211_IS_CHAN_G(_c)) #define IEEE80211_IS_CHAN_ST(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_ST) == IEEE80211_CHAN_ST) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_ST) == IEEE80211_CHAN_ST) #define IEEE80211_IS_CHAN_108A(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_108A) == IEEE80211_CHAN_108A) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_108A) == IEEE80211_CHAN_108A) #define IEEE80211_IS_CHAN_108G(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_108G) == IEEE80211_CHAN_108G) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_108G) == IEEE80211_CHAN_108G) #define IEEE80211_IS_CHAN_2GHZ(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_2GHZ) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_2GHZ) != 0) #define IEEE80211_IS_CHAN_5GHZ(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_5GHZ) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_5GHZ) != 0) #define IEEE80211_IS_CHAN_OFDM(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_OFDM) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_OFDM) != 0) #define IEEE80211_IS_CHAN_CCK(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_CCK) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_CCK) != 0) #define IEEE80211_IS_CHAN_GFSK(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_GFSK) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_GFSK) != 0) #define IEEE80211_IS_CHAN_TURBO(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_TURBO) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_TURBO) != 0) #define IEEE80211_IS_CHAN_WEATHER_RADAR(_c) \ - ((((_c)->ic_freq >= 5600) && ((_c)->ic_freq <= 5650)) || \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40PLUS) && (5580 == (_c)->ic_freq))) + ((((_c)->dfs_ch_freq >= 5600) && ((_c)->dfs_ch_freq <= 5650)) || \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40PLUS) && \ + (5580 == (_c)->dfs_ch_freq))) #define IEEE80211_IS_CHAN_STURBO(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_STURBO) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_STURBO) != 0) #define IEEE80211_IS_CHAN_DTURBO(_c) \ - (((_c)->ic_flags & \ + (((_c)->dfs_ch_flags & \ (IEEE80211_CHAN_TURBO | IEEE80211_CHAN_STURBO)) == IEEE80211_CHAN_TURBO) #define IEEE80211_IS_CHAN_HALF(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HALF) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HALF) != 0) #define IEEE80211_IS_CHAN_QUARTER(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_QUARTER) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_QUARTER) != 0) #define IEEE80211_IS_CHAN_PASSIVE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_PASSIVE) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_PASSIVE) != 0) #define IEEE80211_IS_PRIMARY_OR_SECONDARY_CHAN_DFS(_c) \ - (IEEE80211_IS_CHAN_DFS(_c->ic_curchan) || \ - ((IEEE80211_IS_CHAN_11AC_VHT160(_c->ic_curchan) || \ - IEEE80211_IS_CHAN_11AC_VHT80_80(_c->ic_curchan)) \ - && IEEE80211_IS_CHAN_DFS_CFREQ2(_c->ic_curchan))) + (IEEE80211_IS_CHAN_DFS(_c->dfs_ch_curchan) || \ + ((IEEE80211_IS_CHAN_11AC_VHT160(_c->dfs_ch_curchan) || \ + IEEE80211_IS_CHAN_11AC_VHT80_80(_c->dfs_ch_curchan)) \ + && IEEE80211_IS_CHAN_DFS_CFREQ2(_c->dfs_ch_curchan))) #define IEEE80211_IS_CHAN_DFS(_c) \ - (((_c)->ic_flagext & \ + (((_c)->dfs_ch_flagext & \ (IEEE80211_CHAN_DFS|IEEE80211_CHAN_DFS_CLEAR)) == IEEE80211_CHAN_DFS) #define IEEE80211_IS_CHAN_DFS_CFREQ2(_c) \ - (((_c)->ic_flagext & \ + (((_c)->dfs_ch_flagext & \ (IEEE80211_CHAN_DFS_CFREQ2|IEEE80211_CHAN_DFS_CLEAR)) == \ IEEE80211_CHAN_DFS_CFREQ2) #define IEEE80211_IS_CHAN_DFSFLAG(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_DFS) == IEEE80211_CHAN_DFS) + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_DFS) == IEEE80211_CHAN_DFS) #define IEEE80211_IS_CHAN_DFSFLAG_CFREQ2(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_DFS_CFREQ2) == \ + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_DFS_CFREQ2) == \ IEEE80211_CHAN_DFS_CFREQ2) #define IEEE80211_IS_CHAN_DISALLOW_ADHOC(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_DISALLOW_ADHOC) != 0) + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_DISALLOW_ADHOC) != 0) #define IEEE80211_IS_CHAN_11D_EXCLUDED(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_11D_EXCLUDED) != 0) + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_11D_EXCLUDED) != 0) #define IEEE80211_IS_CHAN_CSA(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_CSA_RECEIVED) != 0) + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_CSA_RECEIVED) != 0) #define IEEE80211_IS_CHAN_ODD(_c) \ - (((_c)->ic_freq == 5170) || ((_c)->ic_freq == 5190) || \ - ((_c)->ic_freq == 5210) || ((_c)->ic_freq == 5230)) + (((_c)->dfs_ch_freq == 5170) || ((_c)->dfs_ch_freq == 5190) || \ + ((_c)->dfs_ch_freq == 5210) || ((_c)->dfs_ch_freq == 5230)) #define IEEE80211_IS_CHAN_DISALLOW_HOSTAP(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_DISALLOW_HOSTAP) != 0) + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_DISALLOW_HOSTAP) != 0) #define IEEE80211_IS_CHAN_11NG_HT20(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NG_HT20) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NG_HT20) == \ IEEE80211_CHAN_11NG_HT20) #define IEEE80211_IS_CHAN_11NA_HT20(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NA_HT20) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NA_HT20) == \ IEEE80211_CHAN_11NA_HT20) #define IEEE80211_IS_CHAN_11NG_HT40PLUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NG_HT40PLUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NG_HT40PLUS) == \ IEEE80211_CHAN_11NG_HT40PLUS) #define IEEE80211_IS_CHAN_11NG_HT40MINUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NG_HT40MINUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NG_HT40MINUS) == \ IEEE80211_CHAN_11NG_HT40MINUS) #define IEEE80211_IS_CHAN_11NA_HT40PLUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NA_HT40PLUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NA_HT40PLUS) == \ IEEE80211_CHAN_11NA_HT40PLUS) #define IEEE80211_IS_CHAN_11NA_HT40MINUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11NA_HT40MINUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11NA_HT40MINUS) == \ IEEE80211_CHAN_11NA_HT40MINUS) #define IEEE80211_IS_CHAN_11N(_c) \ - (((_c)->ic_flags & (IEEE80211_CHAN_HT20 | \ + (((_c)->dfs_ch_flags & (IEEE80211_CHAN_HT20 | \ IEEE80211_CHAN_HT40PLUS | \ IEEE80211_CHAN_HT40MINUS)) != 0) #define IEEE80211_IS_CHAN_11N_HT20(_c) \ - (((_c)->ic_flags & (IEEE80211_CHAN_HT20)) != 0) + (((_c)->dfs_ch_flags & (IEEE80211_CHAN_HT20)) != 0) #define IEEE80211_IS_CHAN_11N_HT40(_c) \ - (((_c)->ic_flags & (IEEE80211_CHAN_HT40PLUS | \ + (((_c)->dfs_ch_flags & (IEEE80211_CHAN_HT40PLUS | \ IEEE80211_CHAN_HT40MINUS)) != 0) #define IEEE80211_IS_CHAN_11NG(_c) \ @@ -397,19 +398,20 @@ enum dfs_ieee80211_opmode { (IEEE80211_IS_CHAN_5GHZ((_c)) && IEEE80211_IS_CHAN_11N((_c))) #define IEEE80211_IS_CHAN_11N_HT40PLUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40PLUS) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40PLUS) != 0) #define IEEE80211_IS_CHAN_11N_HT40MINUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40MINUS) != 0) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40MINUS) != 0) #define IEEE80211_IS_CHAN_HT20_CAPABLE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT20) == IEEE80211_CHAN_HT20) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT20) == IEEE80211_CHAN_HT20) #define IEEE80211_IS_CHAN_HT40PLUS_CAPABLE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40PLUS) == IEEE80211_CHAN_HT40PLUS) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40PLUS) == \ + IEEE80211_CHAN_HT40PLUS) #define IEEE80211_IS_CHAN_HT40MINUS_CAPABLE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40MINUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40MINUS) == \ IEEE80211_CHAN_HT40MINUS) #define IEEE80211_IS_CHAN_HT40_CAPABLE(_c) \ @@ -424,10 +426,11 @@ enum dfs_ieee80211_opmode { IEEE80211_IS_CHAN_HT20_CAPABLE(_c) #define IEEE80211_IS_CHAN_11N_CTL_U_CAPABLE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40PLUS) == IEEE80211_CHAN_HT40PLUS) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40PLUS) == \ + IEEE80211_CHAN_HT40PLUS) #define IEEE80211_IS_CHAN_11N_CTL_L_CAPABLE(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_HT40MINUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_HT40MINUS) == \ IEEE80211_CHAN_HT40MINUS) #define IEEE80211_IS_CHAN_11N_CTL_40_CAPABLE(_c) \ @@ -435,7 +438,7 @@ enum dfs_ieee80211_opmode { IEEE80211_IS_CHAN_11N_CTL_L_CAPABLE((_c))) #define IEEE80211_IS_CHAN_VHT(_c) \ - (((_c)->ic_flags & (IEEE80211_CHAN_VHT20 | \ + (((_c)->dfs_ch_flags & (IEEE80211_CHAN_VHT20 | \ IEEE80211_CHAN_VHT40PLUS | \ IEEE80211_CHAN_VHT40MINUS | \ IEEE80211_CHAN_VHT80 | \ @@ -468,86 +471,87 @@ enum dfs_ieee80211_opmode { (IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_VHT80_80) #define IEEE80211_IS_CHAN_11AC_VHT20(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT20) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT20) == \ IEEE80211_CHAN_11AC_VHT20) #define IEEE80211_IS_CHAN_11AC_VHT40(_c) \ - (((_c)->ic_flags & (IEEE80211_CHAN_VHT40PLUS | \ + (((_c)->dfs_ch_flags & (IEEE80211_CHAN_VHT40PLUS | \ IEEE80211_CHAN_VHT40MINUS)) != 0) #define IEEE80211_IS_CHAN_11AC_VHT40PLUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT40PLUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT40PLUS) == \ IEEE80211_CHAN_11AC_VHT40PLUS) #define IEEE80211_IS_CHAN_11AC_VHT40MINUS(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT40MINUS) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT40MINUS) == \ IEEE80211_CHAN_11AC_VHT40MINUS) #define IEEE80211_IS_CHAN_11AC_VHT80(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT80) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT80) == \ IEEE80211_CHAN_11AC_VHT80) #define IEEE80211_IS_CHAN_11AC_VHT160(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT160) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT160) == \ IEEE80211_CHAN_11AC_VHT160) #define IEEE80211_IS_CHAN_11AC_VHT80_80(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_11AC_VHT80_80) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_11AC_VHT80_80) == \ IEEE80211_CHAN_11AC_VHT80_80) #define IEEE80211_CH_HOPPING_SET_CHAN_BLOCKED(_c) \ - ((_c)->ic_flags |= IEEE80211_CHAN_BLOCKED) + ((_c)->dfs_ch_flags |= IEEE80211_CHAN_BLOCKED) #define IEEE80211_CH_HOPPING_IS_CHAN_BLOCKED(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_BLOCKED) == IEEE80211_CHAN_BLOCKED) + (((_c)->dfs_ch_flags & IEEE80211_CHAN_BLOCKED) == \ + IEEE80211_CHAN_BLOCKED) #define IEEE80211_CH_HOPPING_CLEAR_CHAN_BLOCKED(_c) \ - ((_c)->ic_flags &= ~IEEE80211_CHAN_BLOCKED) + ((_c)->dfs_ch_flags &= ~IEEE80211_CHAN_BLOCKED) #define IEEE80211_IS_CHAN_RADAR(_c) \ - (((_c)->ic_flags & IEEE80211_CHAN_DFS_RADAR) == \ + (((_c)->dfs_ch_flags & IEEE80211_CHAN_DFS_RADAR) == \ IEEE80211_CHAN_DFS_RADAR) #define IEEE80211_CHAN_SET_RADAR(_c) \ - ((_c)->ic_flags |= IEEE80211_CHAN_DFS_RADAR) + ((_c)->dfs_ch_flags |= IEEE80211_CHAN_DFS_RADAR) #define IEEE80211_CHAN_CLR_RADAR(_c) \ - ((_c)->ic_flags &= ~IEEE80211_CHAN_DFS_RADAR) + ((_c)->dfs_ch_flags &= ~IEEE80211_CHAN_DFS_RADAR) #define IEEE80211_CHAN_SET_DISALLOW_ADHOC(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_DISALLOW_ADHOC) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_DISALLOW_ADHOC) #define IEEE80211_CHAN_SET_DISALLOW_HOSTAP(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_DISALLOW_HOSTAP) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_DISALLOW_HOSTAP) #define IEEE80211_CHAN_SET_DFS(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_DFS) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_DFS) #define IEEE80211_CHAN_SET_DFS_CLEAR(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_DFS_CLEAR) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_DFS_CLEAR) #define IEEE80211_CHAN_EXCLUDE_11D(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_11D_EXCLUDED) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_11D_EXCLUDED) #define IEEE80211_IS_CHAN_HISTORY_RADAR(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_HISTORY_RADAR) == \ + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_HISTORY_RADAR) == \ IEEE80211_CHAN_HISTORY_RADAR) #define IEEE80211_CHAN_SET_HISTORY_RADAR(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_HISTORY_RADAR) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_HISTORY_RADAR) #define IEEE80211_CHAN_CLR_HISTORY_RADAR(_c) \ - ((_c)->ic_flagext &= ~IEEE80211_CHAN_HISTORY_RADAR) + ((_c)->dfs_ch_flagext &= ~IEEE80211_CHAN_HISTORY_RADAR) #define IEEE80211_IS_CHAN_CAC_VALID(_c) \ - (((_c)->ic_flagext & IEEE80211_CHAN_CAC_VALID) == \ + (((_c)->dfs_ch_flagext & IEEE80211_CHAN_CAC_VALID) == \ IEEE80211_CHAN_CAC_VALID) #define IEEE80211_CHAN_SET_CAC_VALID(_c) \ - ((_c)->ic_flagext |= IEEE80211_CHAN_CAC_VALID) + ((_c)->dfs_ch_flagext |= IEEE80211_CHAN_CAC_VALID) #define IEEE80211_CHAN_CLR_CAC_VALID(_c) \ - ((_c)->ic_flagext &= ~IEEE80211_CHAN_CAC_VALID) + ((_c)->dfs_ch_flagext &= ~IEEE80211_CHAN_CAC_VALID) #define IEEE80211_CHAN_ANY (-1) /* token for ``any channel'' */ diff --git a/umac/dfs/core/src/filtering/dfs_ar.c b/umac/dfs/core/src/filtering/dfs_ar.c index dcf03f08fc9b..d3ce4b14bfd4 100644 --- a/umac/dfs/core/src/filtering/dfs_ar.c +++ b/umac/dfs/core/src/filtering/dfs_ar.c @@ -262,7 +262,7 @@ void dfs_process_ar_event(struct wlan_dfs *dfs, * Neighboring traffic detected, get out of * Turbo. */ - chan->ic_flagext |= CHANNEL_INTERFERENCE; + chan->dfs_ch_flagext |= CHANNEL_INTERFERENCE; qdf_mem_zero(ar->ar_peaklist, sizeof(ar->ar_peaklist)); ar->ar_acksum = 0; diff --git a/umac/dfs/core/src/filtering/dfs_fcc_bin5.c b/umac/dfs/core/src/filtering/dfs_fcc_bin5.c index e90f18ea47a1..e233afc25f9e 100644 --- a/umac/dfs/core/src/filtering/dfs_fcc_bin5.c +++ b/umac/dfs/core/src/filtering/dfs_fcc_bin5.c @@ -54,7 +54,7 @@ int dfs_bin5_check_pulse(struct wlan_dfs *dfs, struct dfs_event *re, #define CHANNEL_TURBO 0x00010 /* Adjust the filter threshold for rssi in non TURBO mode. */ - if (!(dfs->dfs_curchan->ic_flags & CHANNEL_TURBO)) + if (!(dfs->dfs_curchan->dfs_ch_flags & CHANNEL_TURBO)) b5_rssithresh += br->br_pulse.b5_rssimargin; /* Check if the pulse is within duration and rssi thresholds. */ diff --git a/umac/dfs/core/src/filtering/dfs_phyerr_tlv.c b/umac/dfs/core/src/filtering/dfs_phyerr_tlv.c index 26c1ad4f9eeb..94b3c1231049 100644 --- a/umac/dfs/core/src/filtering/dfs_phyerr_tlv.c +++ b/umac/dfs/core/src/filtering/dfs_phyerr_tlv.c @@ -460,8 +460,8 @@ static int dfs_tlv_calc_freq_info(struct wlan_dfs *dfs, * appropriately! */ chan_centre = dfs_mlme_ieee2mhz(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg1, - dfs->dfs_curchan->ic_flags); + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1, + dfs->dfs_curchan->dfs_ch_flags); } else { /* * HT20/HT40. @@ -475,10 +475,12 @@ static int dfs_tlv_calc_freq_info(struct wlan_dfs *dfs, /* Calculate offset based on HT40U/HT40D and VHT40U/VHT40D. */ if (IEEE80211_IS_CHAN_11N_HT40PLUS(dfs->dfs_curchan) || - dfs->dfs_curchan->ic_flags & IEEE80211_CHAN_VHT40PLUS) + dfs->dfs_curchan->dfs_ch_flags & + IEEE80211_CHAN_VHT40PLUS) chan_offset = chan_width; else if (IEEE80211_IS_CHAN_11N_HT40MINUS(dfs->dfs_curchan) || - dfs->dfs_curchan->ic_flags & IEEE80211_CHAN_VHT40MINUS) + dfs->dfs_curchan->dfs_ch_flags & + IEEE80211_CHAN_VHT40MINUS) chan_offset = -chan_width; else chan_offset = 0; diff --git a/umac/dfs/core/src/filtering/dfs_process_phyerr.c b/umac/dfs/core/src/filtering/dfs_process_phyerr.c index 7513038ae508..f47101e6c531 100644 --- a/umac/dfs/core/src/filtering/dfs_process_phyerr.c +++ b/umac/dfs/core/src/filtering/dfs_process_phyerr.c @@ -99,8 +99,8 @@ static inline uint16_t dfs_get_event_freqcentre(struct wlan_dfs *dfs, } /* - * For non-wide channels, the centre frequency is just ic_freq. - * The centre frequency for pri events is still ic_freq. + * For non-wide channels, the centre frequency is just dfs_ch_freq. + * The centre frequency for pri events is still dfs_ch_freq. */ if (is_pri) return dfs_ieee80211_chan2freq(dfs->dfs_curchan); @@ -651,7 +651,7 @@ void dfs_process_phyerr(struct wlan_dfs *dfs, void *buf, uint16_t datalen, * If the channel is a turbo G channel, then the event is for the * adaptive radio (AR) pattern matching rather than radar detection. */ - if ((dfs->dfs_curchan->ic_flags & CHANNEL_108G) == CHANNEL_108G) { + if ((dfs->dfs_curchan->dfs_ch_flags & CHANNEL_108G) == CHANNEL_108G) { if (!(dfs->dfs_proc_phyerr & DFS_AR_EN)) { DFS_DPRINTK(dfs, WLAN_DEBUG_DFS2, "%s: DFS_AR_EN not enabled\n", diff --git a/umac/dfs/core/src/filtering/dfs_process_radarevent.c b/umac/dfs/core/src/filtering/dfs_process_radarevent.c index 1b181fb09bf8..4f7c74cd8066 100644 --- a/umac/dfs/core/src/filtering/dfs_process_radarevent.c +++ b/umac/dfs/core/src/filtering/dfs_process_radarevent.c @@ -304,7 +304,7 @@ int dfs_process_radarevent(struct wlan_dfs *dfs, if ((dfs->dfsdomain == DFS_MKK4_DOMAIN) && (dfs->dfs_caps.wlan_chip_is_bb_tlv) && - (chan->ic_freq < FREQ_5500_MHZ)) { + (chan->dfs_ch_freq < FREQ_5500_MHZ)) { dfs->dfs_pri_multiplier = DFS_W53_DEFAULT_PRI_MULTIPLIER; /* @@ -374,7 +374,7 @@ int dfs_process_radarevent(struct wlan_dfs *dfs, WLAN_DFSQ_UNLOCK(dfs); continue; } - if (rs->rs_chan.ic_flagext & CHANNEL_INTERFERENCE) { + if (rs->rs_chan.dfs_ch_flagext & CHANNEL_INTERFERENCE) { WLAN_DFSQ_LOCK(dfs); empty = STAILQ_EMPTY(&(dfs->dfs_radarq)); WLAN_DFSQ_UNLOCK(dfs); @@ -597,7 +597,7 @@ int dfs_process_radarevent(struct wlan_dfs *dfs, rf = NULL; DFS_DPRINTK(dfs, WLAN_DEBUG_DFS1, " *** chan freq (%d): ts %llu dur %u rssi %u\n", - rs->rs_chan.ic_freq, + rs->rs_chan.dfs_ch_freq, (uint64_t)this_ts, re.re_dur, re.re_rssi); @@ -609,7 +609,7 @@ int dfs_process_radarevent(struct wlan_dfs *dfs, [tabledepth])]; DFS_DPRINTK(dfs, WLAN_DEBUG_DFS2, " ** RD (%d): ts %x dur %u rssi %u\n", - rs->rs_chan.ic_freq, + rs->rs_chan.dfs_ch_freq, re.re_ts, re.re_dur, re.re_rssi); @@ -685,7 +685,7 @@ dfsfound: } else { DFS_PRINTK( "Radar found on channel %d (%d MHz)\n", - thischan->ic_ieee, thischan->ic_freq); + thischan->dfs_ch_ieee, thischan->dfs_ch_freq); } /* @@ -701,13 +701,13 @@ dfsfound: DFS_DPRINTK(dfs, WLAN_DEBUG_DFS1, "Primary channel freq = %u flags=0x%x\n", - chan->ic_freq, chan->ic_flagext); + chan->dfs_ch_freq, chan->dfs_ch_flagext); - if (chan->ic_freq != thischan->ic_freq) + if (chan->dfs_ch_freq != thischan->dfs_ch_freq) DFS_DPRINTK(dfs, WLAN_DEBUG_DFS1, "Ext channel freq = %u flags=0x%x\n", - thischan->ic_freq, - thischan->ic_flagext); + thischan->dfs_ch_freq, + thischan->dfs_ch_flagext); dfs->dfs_phyerr_freq_min = 0x7fffffff; dfs->dfs_phyerr_freq_max = 0; diff --git a/umac/dfs/core/src/filtering/dfs_radar.c b/umac/dfs/core/src/filtering/dfs_radar.c index 5f4cb431d5aa..50a12da115af 100644 --- a/umac/dfs/core/src/filtering/dfs_radar.c +++ b/umac/dfs/core/src/filtering/dfs_radar.c @@ -498,14 +498,15 @@ void dfs_radar_found_action(struct wlan_dfs *dfs) dfs_find_precac_secondary_vht80_chan(dfs, &ichan); dfs_mlme_channel_mark_radar(dfs->dfs_pdev_obj, - ichan->ic_freq, - ichan->ic_vhtop_ch_freq_seg2, - ichan->ic_flags); + ichan->dfs_ch_freq, + ichan->dfs_ch_vhtop_ch_freq_seg2, + ichan->dfs_ch_flags); } else { dfs_mlme_channel_mark_radar(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags); + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan-> + dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags); } } @@ -540,10 +541,10 @@ void dfs_radar_found_action(struct wlan_dfs *dfs) if (dfs->dfs_rinfo.rn_use_nol == 1) { dfs_mlme_start_rcsa(dfs->dfs_pdev_obj); dfs_mlme_mark_dfs(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_ieee, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags); + dfs->dfs_curchan->dfs_ch_ieee, + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags); /* * EV 129487 : We have detected radar in the channel, * stop processing PHY error data as this can cause @@ -560,7 +561,7 @@ void dfs_radar_found_action(struct wlan_dfs *dfs) */ qdf_timer_stop(&dfs->wlan_dfstesttimer); dfs->wlan_dfstest = 1; - dfs->wlan_dfstest_ieeechan = dfs->dfs_curchan->ic_ieee; + dfs->wlan_dfstest_ieeechan = dfs->dfs_curchan->dfs_ch_ieee; dfs->wlan_dfstesttime = 1; /* 1ms */ OS_SET_TIMER(&dfs->wlan_dfstesttimer, dfs->wlan_dfstesttime); diff --git a/umac/dfs/core/src/misc/dfs.c b/umac/dfs/core/src/misc/dfs.c index d3c49fbf721a..e3cfbf61ea19 100644 --- a/umac/dfs/core/src/misc/dfs.c +++ b/umac/dfs/core/src/misc/dfs.c @@ -440,29 +440,32 @@ struct dfs_state *dfs_getchanstate(struct wlan_dfs *dfs, uint8_t *index, cmp_ch = &cmp_ch1; if (ext_chan_flag) { err = dfs_mlme_get_extchan(dfs->dfs_pdev_obj, - &(cmp_ch->ic_freq), - &(cmp_ch->ic_flags), - &(cmp_ch->ic_flagext), - &(cmp_ch->ic_ieee), - &(cmp_ch->ic_vhtop_ch_freq_seg1), - &(cmp_ch->ic_vhtop_ch_freq_seg2)); + &(cmp_ch->dfs_ch_freq), + &(cmp_ch->dfs_ch_flags), + &(cmp_ch->dfs_ch_flagext), + &(cmp_ch->dfs_ch_ieee), + &(cmp_ch->dfs_ch_vhtop_ch_freq_seg1), + &(cmp_ch->dfs_ch_vhtop_ch_freq_seg2)); if (err == QDF_STATUS_SUCCESS) { DFS_DPRINTK(dfs, WLAN_DEBUG_DFS2, "Extension channel freq = %u flags=0x%x\n", - cmp_ch->ic_freq, cmp_ch->ic_flagext); + cmp_ch->dfs_ch_freq, + cmp_ch->dfs_ch_flagext); } else return NULL; } else { cmp_ch = dfs->dfs_curchan; DFS_DPRINTK(dfs, WLAN_DEBUG_DFS2, "Primary channel freq = %u flags=0x%x\n", - cmp_ch->ic_freq, cmp_ch->ic_flagext); + cmp_ch->dfs_ch_freq, cmp_ch->dfs_ch_flagext); } for (i = 0; i < DFS_NUM_RADAR_STATES; i++) { - if ((dfs->dfs_radar[i].rs_chan.ic_freq == cmp_ch->ic_freq) && - (dfs->dfs_radar[i].rs_chan.ic_flags == cmp_ch->ic_flags) + if ((dfs->dfs_radar[i].rs_chan.dfs_ch_freq == + cmp_ch->dfs_ch_freq) && + (dfs->dfs_radar[i].rs_chan.dfs_ch_flags == + cmp_ch->dfs_ch_flags) ) { if (index != NULL) *index = (uint8_t)i; @@ -471,7 +474,7 @@ struct dfs_state *dfs_getchanstate(struct wlan_dfs *dfs, uint8_t *index, } /* No existing channel found, look for first free channel state entry.*/ for (i = 0; i < DFS_NUM_RADAR_STATES; i++) { - if (dfs->dfs_radar[i].rs_chan.ic_freq == 0) { + if (dfs->dfs_radar[i].rs_chan.dfs_ch_freq == 0) { rs = &(dfs->dfs_radar[i]); /* Found one, set channel info and default thresholds.*/ rs->rs_chan = *cmp_ch; @@ -528,12 +531,12 @@ void dfs_radar_enable(struct wlan_dfs *dfs, int no_cac, uint32_t opmode) ext_ch = &extchan; if (is_ext_ch) err = dfs_mlme_get_extchan(dfs->dfs_pdev_obj, - &(ext_ch->ic_freq), - &(ext_ch->ic_flags), - &(ext_ch->ic_flagext), - &(ext_ch->ic_ieee), - &(ext_ch->ic_vhtop_ch_freq_seg1), - &(ext_ch->ic_vhtop_ch_freq_seg2)); + &(ext_ch->dfs_ch_freq), + &(ext_ch->dfs_ch_flags), + &(ext_ch->dfs_ch_flagext), + &(ext_ch->dfs_ch_ieee), + &(ext_ch->dfs_ch_vhtop_ch_freq_seg1), + &(ext_ch->dfs_ch_vhtop_ch_freq_seg2)); dfs_reset_alldelaylines(dfs); @@ -578,7 +581,7 @@ void dfs_radar_enable(struct wlan_dfs *dfs, int no_cac, uint32_t opmode) dfs->dfsdomain); DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "Enabled radar detection on channel %d\n", - dfs->dfs_curchan->ic_freq); + dfs->dfs_curchan->dfs_ch_freq); dfs->dur_multiplier = is_fastclk ? DFS_FAST_CLOCK_MULTIPLIER : @@ -869,7 +872,7 @@ int dfs_control(struct wlan_dfs *dfs, nol = (struct dfsreq_nolinfo *)outdata; dfs_get_nol(dfs, (struct dfsreq_nolelem *)nol->dfs_nol, - &nol->ic_nchans); + &nol->dfs_ch_nchans); dfs_print_nol(dfs); break; case DFS_SET_NOL: @@ -880,7 +883,7 @@ int dfs_control(struct wlan_dfs *dfs, nol = (struct dfsreq_nolinfo *) indata; dfs_set_nol(dfs, (struct dfsreq_nolelem *)nol->dfs_nol, - nol->ic_nchans); + nol->dfs_ch_nchans); break; case DFS_SHOW_NOL: dfs_print_nol(dfs); @@ -1025,7 +1028,7 @@ void dfs_getnol(struct wlan_dfs *dfs, void *dfs_nolinfo) { struct dfsreq_nolinfo *nolinfo = (struct dfsreq_nolinfo *)dfs_nolinfo; - dfs_get_nol(dfs, nolinfo->dfs_nol, &(nolinfo->ic_nchans)); + dfs_get_nol(dfs, nolinfo->dfs_nol, &(nolinfo->dfs_ch_nchans)); } void dfs_clear_nolhistory(struct wlan_dfs *dfs) @@ -1036,39 +1039,39 @@ void dfs_clear_nolhistory(struct wlan_dfs *dfs) int nchans = 0; c = &lc; - dfs_mlme_get_ic_nchans(dfs->dfs_pdev_obj, &nchans); + dfs_mlme_get_dfs_ch_nchans(dfs->dfs_pdev_obj, &nchans); for (i = 0; i < nchans; i++) { - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(c->ic_freq), - &(c->ic_flags), - &(c->ic_flagext), - &(c->ic_ieee), - &(c->ic_vhtop_ch_freq_seg1), - &(c->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(c->dfs_ch_freq), + &(c->dfs_ch_flags), + &(c->dfs_ch_flagext), + &(c->dfs_ch_ieee), + &(c->dfs_ch_vhtop_ch_freq_seg1), + &(c->dfs_ch_vhtop_ch_freq_seg2), i); IEEE80211_CHAN_CLR_HISTORY_RADAR(c); } } void dfs_set_current_channel(struct wlan_dfs *dfs, - uint16_t ic_freq, - uint32_t ic_flags, - uint16_t ic_flagext, - uint8_t ic_ieee, - uint8_t ic_vhtop_ch_freq_seg1, - uint8_t ic_vhtop_ch_freq_seg2) + uint16_t dfs_ch_freq, + uint32_t dfs_ch_flags, + uint16_t dfs_ch_flagext, + uint8_t dfs_ch_ieee, + uint8_t dfs_ch_vhtop_ch_freq_seg1, + uint8_t dfs_ch_vhtop_ch_freq_seg2) { if (dfs == NULL) { DFS_PRINTK("%s: wlan_dfs is NULL\n", __func__); return; } - dfs->dfs_curchan->ic_freq = ic_freq; - dfs->dfs_curchan->ic_flags = ic_flags; - dfs->dfs_curchan->ic_flagext = ic_flagext; - dfs->dfs_curchan->ic_ieee = ic_ieee; - dfs->dfs_curchan->ic_vhtop_ch_freq_seg1 = ic_vhtop_ch_freq_seg1; - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2 = ic_vhtop_ch_freq_seg2; + dfs->dfs_curchan->dfs_ch_freq = dfs_ch_freq; + dfs->dfs_curchan->dfs_ch_flags = dfs_ch_flags; + dfs->dfs_curchan->dfs_ch_flagext = dfs_ch_flagext; + dfs->dfs_curchan->dfs_ch_ieee = dfs_ch_ieee; + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1 = dfs_ch_vhtop_ch_freq_seg1; + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2 = dfs_ch_vhtop_ch_freq_seg2; } u_int dfs_ieee80211_chan2freq(struct dfs_ieee80211_channel *chan) @@ -1077,5 +1080,5 @@ u_int dfs_ieee80211_chan2freq(struct dfs_ieee80211_channel *chan) return 0; return chan == IEEE80211_CHAN_ANYC ? - IEEE80211_CHAN_ANY : chan->ic_freq; + IEEE80211_CHAN_ANY : chan->dfs_ch_freq; } diff --git a/umac/dfs/core/src/misc/dfs_cac.c b/umac/dfs/core/src/misc/dfs_cac.c index 3f58c5976718..ca71e9b6e2a8 100644 --- a/umac/dfs/core/src/misc/dfs_cac.c +++ b/umac/dfs/core/src/misc/dfs_cac.c @@ -86,8 +86,8 @@ void dfs_cac_valid_reset(struct wlan_dfs *dfs, uint32_t prevchan_flags) { if (dfs->dfs_cac_valid_time) { - if ((prevchan_ieee != dfs->dfs_curchan->ic_ieee) || - (prevchan_flags != dfs->dfs_curchan->ic_flags)) { + if ((prevchan_ieee != dfs->dfs_curchan->dfs_ch_ieee) || + (prevchan_flags != dfs->dfs_curchan->dfs_ch_flags)) { DFS_PRINTK( "%s : Cancelling timer & clearing cac_valid\n", __func__); @@ -138,7 +138,7 @@ static os_timer_func(dfs_cac_timeout) dfs->dfs_cac_timer_running = 0; DFS_PRINTK("%s cac expired, chan %d curr time %d\n", __func__, - dfs->dfs_curchan->ic_freq, + dfs->dfs_curchan->dfs_ch_freq, (qdf_system_ticks_to_msecs(qdf_system_ticks()) / 1000)); /* * When radar is detected during a CAC we are woken up prematurely to @@ -146,17 +146,19 @@ static os_timer_func(dfs_cac_timeout) */ if (IEEE80211_IS_CHAN_RADAR(dfs->dfs_curchan)) { dfs_mlme_mark_dfs(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_ieee, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags); + dfs->dfs_curchan->dfs_ch_ieee, + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags); DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "CAC timer on channel %u (%u MHz) stopped due to radar\n", - dfs->dfs_curchan->ic_ieee, dfs->dfs_curchan->ic_freq); + dfs->dfs_curchan->dfs_ch_ieee, + dfs->dfs_curchan->dfs_ch_freq); } else { DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "CAC timer on channel %u (%u MHz) expired; no radar detected\n", - dfs->dfs_curchan->ic_ieee, dfs->dfs_curchan->ic_freq); + dfs->dfs_curchan->dfs_ch_ieee, + dfs->dfs_curchan->dfs_ch_freq); /* On CAC completion, set the bit 'cac_valid'. * CAC will not be re-done if this bit is reset. @@ -191,9 +193,9 @@ void dfs_start_cac_timer(struct wlan_dfs *dfs) { OS_SET_TIMER(&dfs->dfs_cac_timer, dfs_mlme_get_cac_timeout(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags) * 1000); + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags) * 1000); } void dfs_cancel_cac_timer(struct wlan_dfs *dfs) @@ -208,7 +210,7 @@ void dfs_cac_stop(struct wlan_dfs *dfs) dfs_get_debug_info(dfs, (void *)&phyerr); DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "%s : Stopping CAC Timer %d procphyerr 0x%08x\n", - __func__, dfs->dfs_curchan->ic_freq, phyerr); + __func__, dfs->dfs_curchan->dfs_ch_freq, phyerr); qdf_timer_stop(&dfs->dfs_cac_timer); dfs->dfs_cac_timer_running = 0; } @@ -220,7 +222,7 @@ void dfs_stacac_stop(struct wlan_dfs *dfs) dfs_get_debug_info(dfs, (void *)&phyerr); DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "%s : Stopping STA CAC Timer %d procphyerr 0x%08x\n", - __func__, dfs->dfs_curchan->ic_freq, phyerr); + __func__, dfs->dfs_curchan->dfs_ch_freq, phyerr); } /** @@ -239,24 +241,25 @@ static os_timer_func(dfs_nol_timeout) c = &lc; OS_GET_TIMER_ARG(dfs, struct wlan_dfs *); - dfs_mlme_get_ic_nchans(dfs->dfs_pdev_obj, &nchans); + dfs_mlme_get_dfs_ch_nchans(dfs->dfs_pdev_obj, &nchans); now = oldest = qdf_system_ticks(); for (i = 0; i < nchans; i++) { - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(c->ic_freq), - &(c->ic_flags), - &(c->ic_flagext), - &(c->ic_ieee), - &(c->ic_vhtop_ch_freq_seg1), - &(c->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(c->dfs_ch_freq), + &(c->dfs_ch_flags), + &(c->dfs_ch_flagext), + &(c->dfs_ch_ieee), + &(c->dfs_ch_vhtop_ch_freq_seg1), + &(c->dfs_ch_vhtop_ch_freq_seg2), i); if (IEEE80211_IS_CHAN_RADAR(c)) { if (qdf_system_time_after_eq(now, dfs->dfs_nol_event[i] + NOL_TIMEOUT)) { - c->ic_flagext &= + c->dfs_ch_flagext &= ~IEEE80211_CHAN_DFS_RADAR_FOUND; - if (c->ic_flags & IEEE80211_CHAN_DFS_RADAR) { + if (c->dfs_ch_flags & + IEEE80211_CHAN_DFS_RADAR) { /* * NB: do this here so we get only one * msg instead of one for every channel @@ -265,8 +268,8 @@ static os_timer_func(dfs_nol_timeout) DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "%s : radar on channel %u (%u MHz) cleared after timeout\n", __func__, - c->ic_ieee, - c->ic_freq); + c->dfs_ch_ieee, + c->dfs_ch_freq); } } else if (dfs->dfs_nol_event[i] < oldest) oldest = dfs->dfs_nol_event[i]; @@ -370,7 +373,7 @@ int dfs_random_channel(struct wlan_dfs *dfs, "%s -- MMK4 domain, HT160, will look for HT160. if can't find no restriction on using upper or lower 5G channel\n", __func__); } else { - if (dfs->dfs_curchan->ic_freq < CH100_START_FREQ) { + if (dfs->dfs_curchan->dfs_ch_freq < CH100_START_FREQ) { use_lower_5g_only = 1; use_upper_5g_only = 0; DFS_PRINTK( @@ -392,17 +395,17 @@ int dfs_random_channel(struct wlan_dfs *dfs, * Assuming all G channels are present at the beginning of the * list, followed by all A channels */ - dfs_mlme_get_ic_nchans(dfs->dfs_pdev_obj, &nchans); + dfs_mlme_get_dfs_ch_nchans(dfs->dfs_pdev_obj, &nchans); for (j = 0; j < nchans; j++) { - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(c->ic_freq), - &(c->ic_flags), - &(c->ic_flagext), - &(c->ic_ieee), - &(c->ic_vhtop_ch_freq_seg1), - &(c->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(c->dfs_ch_freq), + &(c->dfs_ch_flags), + &(c->dfs_ch_flagext), + &(c->dfs_ch_ieee), + &(c->dfs_ch_vhtop_ch_freq_seg1), + &(c->dfs_ch_vhtop_ch_freq_seg2), j); - chan_flags = c->ic_flags; + chan_flags = c->dfs_ch_flags; if (chan_flags & IEEE80211_CHAN_2GHZ) { numGChannels++; continue; @@ -413,34 +416,34 @@ int dfs_random_channel(struct wlan_dfs *dfs, numAChannels = (nchans - numGChannels); chanStart = numGChannels; - curChanFlags = (dfs->dfs_curchan->ic_flags) & IEEE80211_CHAN_ALL; - if (dfs_mlme_ic_flags_ext(dfs->dfs_pdev_obj) & + curChanFlags = (dfs->dfs_curchan->dfs_ch_flags) & IEEE80211_CHAN_ALL; + if (dfs_mlme_dfs_ch_flags_ext(dfs->dfs_pdev_obj) & IEEE80211_FEXT_BLKDFSCHAN) curChanFlags &= ~IEEE80211_CHAN_DFS; for (n = 0; n < nchans; chanStart++, n++) { if (chanStart == nchans) chanStart = 0; - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(c->ic_freq), - &(c->ic_flags), - &(c->ic_flagext), - &(c->ic_ieee), - &(c->ic_vhtop_ch_freq_seg1), - &(c->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(c->dfs_ch_freq), + &(c->dfs_ch_flags), + &(c->dfs_ch_flagext), + &(c->dfs_ch_ieee), + &(c->dfs_ch_vhtop_ch_freq_seg1), + &(c->dfs_ch_vhtop_ch_freq_seg2), chanStart); - chan_flags = c->ic_flags; - chan_flagext = c->ic_flagext; + chan_flags = c->dfs_ch_flags; + chan_flagext = c->dfs_ch_flagext; if (skip_curchan) { /* Skip curchan when choosing apriori random channel. */ - if (c->ic_freq == dfs->dfs_curchan->ic_freq) + if (c->dfs_ch_freq == dfs->dfs_curchan->dfs_ch_freq) continue; } /* These channels have CAC of 10 minutes so skipping these. */ - dfs_mlme_get_ic_no_weather_radar_chan(dfs->dfs_pdev_obj, + dfs_mlme_get_dfs_ch_no_weather_radar_chan(dfs->dfs_pdev_obj, &no_wradar); if (no_wradar) { /* @@ -473,7 +476,7 @@ int dfs_random_channel(struct wlan_dfs *dfs, (chan_flags & IEEE80211_CHAN_DFS_RADAR) || (chan_flagext & IEEE80211_CHAN_11D_EXCLUDED) || (chan_flagext & IEEE80211_CHAN_DFS && - dfs_mlme_ic_flags_ext(dfs->dfs_pdev_obj) & + dfs_mlme_dfs_ch_flags_ext(dfs->dfs_pdev_obj) & IEEE80211_FEXT_BLKDFSCHAN) || (chan_flagext & IEEE80211_CHAN_DFS && is_select_nondfs)) continue; @@ -486,13 +489,14 @@ int dfs_random_channel(struct wlan_dfs *dfs, */ if (use_lower_5g_only) { if (IEEE80211_IS_CHAN_11AC_VHT80_80(c)) { - if ((c->ic_freq > CH100_START_FREQ) || - (c->ic_vhtop_ch_freq_seg2 > CH100)) { + if ((c->dfs_ch_freq > CH100_START_FREQ) || + (c->dfs_ch_vhtop_ch_freq_seg2 > + CH100)) { /* Skip this channel. */ continue; } } else { - if (c->ic_freq > CH100_START_FREQ) { + if (c->dfs_ch_freq > CH100_START_FREQ) { /* Skip this channel. */ continue; } @@ -501,13 +505,14 @@ int dfs_random_channel(struct wlan_dfs *dfs, if (use_upper_5g_only) { if (IEEE80211_IS_CHAN_11AC_VHT80_80(c)) { - if ((c->ic_freq < CH100_START_FREQ) || - (c->ic_vhtop_ch_freq_seg2 < CH100)) { + if ((c->dfs_ch_freq < CH100_START_FREQ) || + (c->dfs_ch_vhtop_ch_freq_seg2 < + CH100)) { /* Skip this channel. */ continue; } } else { - if (c->ic_freq < CH100_START_FREQ) { + if (c->dfs_ch_freq < CH100_START_FREQ) { /* Skip this channel. */ continue; } diff --git a/umac/dfs/core/src/misc/dfs_nol.c b/umac/dfs/core/src/misc/dfs_nol.c index 04be39d6b5d3..7a5d45c5d80a 100644 --- a/umac/dfs/core/src/misc/dfs_nol.c +++ b/umac/dfs/core/src/misc/dfs_nol.c @@ -171,20 +171,20 @@ void dfs_print_nolhistory(struct wlan_dfs *dfs) c = &lc; - dfs_mlme_get_ic_nchans(dfs->dfs_pdev_obj, &nchans); + dfs_mlme_get_dfs_ch_nchans(dfs->dfs_pdev_obj, &nchans); for (i = 0; i < nchans; i++) { - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(c->ic_freq), - &(c->ic_flags), - &(c->ic_flagext), - &(c->ic_ieee), - &(c->ic_vhtop_ch_freq_seg1), - &(c->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(c->dfs_ch_freq), + &(c->dfs_ch_flags), + &(c->dfs_ch_flagext), + &(c->dfs_ch_ieee), + &(c->dfs_ch_vhtop_ch_freq_seg1), + &(c->dfs_ch_vhtop_ch_freq_seg2), i); if (IEEE80211_IS_CHAN_HISTORY_RADAR(c)) { DFS_PRINTK( "nolhistory:%d channel=%d MHz Flags=%X\n", - j, c->ic_freq, c->ic_flags); + j, c->dfs_ch_freq, c->dfs_ch_flags); j++; } } @@ -235,12 +235,12 @@ void dfs_set_nol(struct wlan_dfs *dfs, qdf_system_ticks_to_msecs(qdf_system_ticks() - dfs_nol[i].nol_start_ticks); if (nol_time_left_ms < dfs_nol[i].nol_timeout_ms) { - chan.ic_freq = dfs_nol[i].nol_freq; - chan.ic_flags = 0; - chan.ic_flagext = 0; + chan.dfs_ch_freq = dfs_nol[i].nol_freq; + chan.dfs_ch_flags = 0; + chan.dfs_ch_flagext = 0; nol_time_left_ms = (dfs_nol[i].nol_timeout_ms - nol_time_left_ms); - dfs_nol_addchan(dfs, chan.ic_freq, + dfs_nol_addchan(dfs, chan.dfs_ch_freq, (nol_time_left_ms / TIME_IN_MS)); } } diff --git a/umac/dfs/core/src/misc/dfs_process_radar_found_ind.c b/umac/dfs/core/src/misc/dfs_process_radar_found_ind.c index 57600fb3189a..056dfae69916 100644 --- a/umac/dfs/core/src/misc/dfs_process_radar_found_ind.c +++ b/umac/dfs/core/src/misc/dfs_process_radar_found_ind.c @@ -222,7 +222,7 @@ void dfs_process_radar_found_indication(struct wlan_dfs *dfs, } qdf_mem_set(&freq_offset, sizeof(freq_offset), 0); - flag = dfs->dfs_curchan->ic_flags; + flag = dfs->dfs_curchan->dfs_ch_flags; for (i = 0; i < DFS_NUM_FREQ_OFFSET; i++) freq_offset.offset[i] = radar_found->freq_offset; @@ -231,10 +231,10 @@ void dfs_process_radar_found_indication(struct wlan_dfs *dfs, if (!radar_found->segment_id) freq_center = utils_dfs_chan_to_freq( - dfs->dfs_curchan->ic_vhtop_ch_freq_seg1); + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1); else { freq_center = utils_dfs_chan_to_freq( - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2); + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2); if (flag & IEEE80211_CHAN_VHT160) freq_center += DFS_160MHZ_SECOND_SEG_OFFSET; } diff --git a/umac/dfs/core/src/misc/dfs_random_chan_sel.c b/umac/dfs/core/src/misc/dfs_random_chan_sel.c index b831c56b9fc0..ef819685f2db 100644 --- a/umac/dfs/core/src/misc/dfs_random_chan_sel.c +++ b/umac/dfs/core/src/misc/dfs_random_chan_sel.c @@ -436,31 +436,35 @@ static void dfs_apply_rules(struct wlan_dfs *dfs, for (i = 0; i < ch_cnt; i++) { chan = &ch_list[i]; - if ((chan->ic_ieee == 0) || (chan->ic_ieee > MAX_CHANNEL_NUM)) { + if ((chan->dfs_ch_ieee == 0) || + (chan->dfs_ch_ieee > MAX_CHANNEL_NUM)) { DFS_PRINTK("%s: invalid channel %d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } if (acs_info && (acs_info->acs_mode == 1) && - ((chan->ic_ieee < acs_info->start_ch) || - (chan->ic_ieee > acs_info->end_ch))) { + ((chan->dfs_ch_ieee < acs_info->start_ch) || + (chan->dfs_ch_ieee > acs_info->end_ch))) { DFS_PRINTK("%s: skip ch %d not in acs range (%d-%d)\n", - __func__, chan->ic_ieee, acs_info->start_ch, + __func__, chan->dfs_ch_ieee, + acs_info->start_ch, acs_info->end_ch); continue; } - if (flag_no_2g_chan && chan->ic_ieee <= DFS_MAX_24GHZ_CHANNEL) { + if (flag_no_2g_chan && + chan->dfs_ch_ieee <= DFS_MAX_24GHZ_CHANNEL) { DFS_PRINTK("%s: skip 2.4 GHz channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } - if (flag_no_5g_chan && chan->ic_ieee > DFS_MAX_24GHZ_CHANNEL) { + if (flag_no_5g_chan && + chan->dfs_ch_ieee > DFS_MAX_24GHZ_CHANNEL) { DFS_PRINTK("%s: skip 5 GHz channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } @@ -469,50 +473,50 @@ static void dfs_apply_rules(struct wlan_dfs *dfs, * We should also avoid this channel in HT40 mode as * extension channel will be on 5600. */ - /* TODO check if reg updating chan->ic_flags for + /* TODO check if reg updating chan->dfs_ch_flags for * IEEE80211_CHAN_11NA_HT40PLUS * */ - if (DFS_IS_CHANNEL_WEATHER_RADAR(chan->ic_freq)) { + if (DFS_IS_CHANNEL_WEATHER_RADAR(chan->dfs_ch_freq)) { DFS_PRINTK("%s: skip weather channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } else if (DFS_ADJACENT_WEATHER_RADAR_CHANNEL == - chan->ic_freq && (chan->ic_flags & + chan->dfs_ch_freq && (chan->dfs_ch_flags & IEEE80211_CHAN_11NA_HT40PLUS)) { DFS_PRINTK("%s: skip weather adjacent ch=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } } if (flag_no_lower_5g && - DFS_IS_CHAN_JAPAN_INDOOR(chan->ic_freq)) { + DFS_IS_CHAN_JAPAN_INDOOR(chan->dfs_ch_freq)) { DFS_PRINTK("%s: skip indoor channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } if (flag_no_upper_5g && - DFS_IS_CHAN_JAPAN_OUTDOOR(chan->ic_freq)) { + DFS_IS_CHAN_JAPAN_OUTDOOR(chan->dfs_ch_freq)) { DFS_PRINTK("%s: skip outdoor channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } if (flag_no_dfs_chan && - (chan->ic_flagext & IEEE80211_CHAN_DFS)) { + (chan->dfs_ch_flagext & IEEE80211_CHAN_DFS)) { DFS_PRINTK("%s: skip dfs channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } - if (dfs_freq_is_in_nol(dfs, chan->ic_freq)) { + if (dfs_freq_is_in_nol(dfs, chan->dfs_ch_freq)) { DFS_PRINTK("%s: skip nol channel=%d\n", - __func__, chan->ic_ieee); + __func__, chan->dfs_ch_ieee); continue; } - random_chan_list[*random_chan_cnt] = chan->ic_ieee; + random_chan_list[*random_chan_cnt] = chan->dfs_ch_ieee; *random_chan_cnt += 1; } } @@ -561,7 +565,7 @@ int dfs_prepare_random_channel(struct wlan_dfs *dfs, } target_ch = dfs_find_ch_with_fallback(ch_wd, - &cur_chan->ic_vhtop_ch_freq_seg2, + &cur_chan->dfs_ch_vhtop_ch_freq_seg2, random_chan_list, random_chan_cnt); if (target_ch) diff --git a/umac/dfs/core/src/misc/dfs_zero_cac.c b/umac/dfs/core/src/misc/dfs_zero_cac.c index 5736d1819a03..cd7903af45a5 100644 --- a/umac/dfs/core/src/misc/dfs_zero_cac.c +++ b/umac/dfs/core/src/misc/dfs_zero_cac.c @@ -158,7 +158,7 @@ bool dfs_is_ht20_40_80_chan_in_precac_done_list(struct wlan_dfs *dfs) &dfs->dfs_precac_done_list, pe_list) { /* Find if the VHT80 freq1 is in Pre-CAC done list */ - if (IS_WITHIN_RANGE(dfs->dfs_curchan->ic_ieee, + if (IS_WITHIN_RANGE(dfs->dfs_curchan->dfs_ch_ieee, precac_entry->vht80_freq, VHT80_OFFSET)) { ret_val = 1; @@ -168,7 +168,7 @@ bool dfs_is_ht20_40_80_chan_in_precac_done_list(struct wlan_dfs *dfs) PRECAC_LIST_UNLOCK(dfs); DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "%s : vht80_freq = %u ret_val = %d\n", - __func__, dfs->dfs_curchan->ic_ieee, ret_val); + __func__, dfs->dfs_curchan->dfs_ch_ieee, ret_val); return ret_val; } @@ -186,7 +186,7 @@ bool dfs_is_ht80_80_chan_in_precac_done_list(struct wlan_dfs *dfs) TAILQ_FOREACH(precac_entry, &dfs->dfs_precac_done_list, pe_list) { - if (dfs->dfs_curchan->ic_vhtop_ch_freq_seg1 + if (dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1 == precac_entry->vht80_freq) { primary_found = 1; break; @@ -202,7 +202,7 @@ bool dfs_is_ht80_80_chan_in_precac_done_list(struct wlan_dfs *dfs) TAILQ_FOREACH(precac_entry, &dfs->dfs_precac_done_list, pe_list) { - if (dfs->dfs_curchan->ic_vhtop_ch_freq_seg2 + if (dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2 == precac_entry->vht80_freq) { /* Now secondary also found */ ret_val = 1; @@ -219,8 +219,8 @@ bool dfs_is_ht80_80_chan_in_precac_done_list(struct wlan_dfs *dfs) DFS_DPRINTK(dfs, WLAN_DEBUG_DFS, "%s : freq_seg1 = %u freq_seq2 = %u ret_val = %d\n", __func__, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg1, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, ret_val); return ret_val; @@ -277,7 +277,7 @@ void dfs_mark_precac_dfs(struct wlan_dfs *dfs, if (is_radar_found_on_secondary_seg ? (dfs->dfs_precac_secondary_freq == precac_entry->vht80_freq) : IS_WITHIN_RANGE( - dfs->dfs_curchan->ic_ieee, + dfs->dfs_curchan->dfs_ch_ieee, precac_entry->vht80_freq, VHT80_IEEE_FREQ_OFFSET)) { TAILQ_REMOVE(&dfs->dfs_precac_required_list, @@ -311,7 +311,7 @@ void dfs_mark_precac_dfs(struct wlan_dfs *dfs, (dfs->dfs_precac_secondary_freq == precac_entry->vht80_freq) : IS_WITHIN_RANGE( - dfs->dfs_curchan->ic_ieee, + dfs->dfs_curchan->dfs_ch_ieee, precac_entry->vht80_freq, 6)) { TAILQ_REMOVE(&dfs->dfs_precac_done_list, precac_entry, pe_list); @@ -370,19 +370,20 @@ bool dfs_is_precac_timer_running(struct wlan_dfs *dfs) void dfs_find_precac_secondary_vht80_chan(struct wlan_dfs *dfs, struct dfs_ieee80211_channel **chan) { - uint8_t first_primary_ic_ieee; + uint8_t first_primary_dfs_ch_ieee; - first_primary_ic_ieee = + first_primary_dfs_ch_ieee = dfs->dfs_precac_secondary_freq - VHT80_IEEE_FREQ_OFFSET; - dfs_mlme_find_dot11_channel(dfs->dfs_pdev_obj, first_primary_ic_ieee, 0, + dfs_mlme_find_dot11_channel(dfs->dfs_pdev_obj, + first_primary_dfs_ch_ieee, 0, IEEE80211_MODE_11AC_VHT80, - &((*chan)->ic_freq), - &((*chan)->ic_flags), - &((*chan)->ic_flagext), - &((*chan)->ic_ieee), - &((*chan)->ic_vhtop_ch_freq_seg1), - &((*chan)->ic_vhtop_ch_freq_seg2)); + &((*chan)->dfs_ch_freq), + &((*chan)->dfs_ch_flags), + &((*chan)->dfs_ch_flagext), + &((*chan)->dfs_ch_ieee), + &((*chan)->dfs_ch_vhtop_ch_freq_seg1), + &((*chan)->dfs_ch_vhtop_ch_freq_seg2)); } /** @@ -486,7 +487,7 @@ void dfs_init_precac_list(struct wlan_dfs *dfs) TAILQ_INIT(&dfs->dfs_precac_required_list); TAILQ_INIT(&dfs->dfs_precac_done_list); TAILQ_INIT(&dfs->dfs_precac_nol_list); - dfs_mlme_get_ic_nchans(dfs->dfs_pdev_obj, &nchans); + dfs_mlme_get_dfs_ch_nchans(dfs->dfs_pdev_obj, &nchans); PRECAC_LIST_LOCK(dfs); /* Fill the precac-required-list with unique elements */ @@ -494,13 +495,13 @@ void dfs_init_precac_list(struct wlan_dfs *dfs) struct dfs_ieee80211_channel *ichan = NULL, lc; ichan = &lc; - dfs_mlme_get_ic_channels(dfs->dfs_pdev_obj, - &(ichan->ic_freq), - &(ichan->ic_flags), - &(ichan->ic_flagext), - &(ichan->ic_ieee), - &(ichan->ic_vhtop_ch_freq_seg1), - &(ichan->ic_vhtop_ch_freq_seg2), + dfs_mlme_get_dfs_ch_channels(dfs->dfs_pdev_obj, + &(ichan->dfs_ch_freq), + &(ichan->dfs_ch_flags), + &(ichan->dfs_ch_flagext), + &(ichan->dfs_ch_ieee), + &(ichan->dfs_ch_vhtop_ch_freq_seg1), + &(ichan->dfs_ch_vhtop_ch_freq_seg2), i); if (IEEE80211_IS_CHAN_11AC_VHT80(ichan) && @@ -510,7 +511,8 @@ void dfs_init_precac_list(struct wlan_dfs *dfs) &dfs->dfs_precac_required_list, pe_list) { if (tmp_precac_entry->vht80_freq == - ichan->ic_vhtop_ch_freq_seg1) { + ichan-> + dfs_ch_vhtop_ch_freq_seg1) { found = 1; break; } @@ -521,7 +523,7 @@ void dfs_init_precac_list(struct wlan_dfs *dfs) precac_entry = qdf_mem_malloc( sizeof(*precac_entry)); precac_entry->vht80_freq = - ichan->ic_vhtop_ch_freq_seg1; + ichan->dfs_ch_vhtop_ch_freq_seg1; precac_entry->dfs = dfs; /* @@ -631,7 +633,7 @@ void dfs_cancel_precac_timer(struct wlan_dfs *dfs) void dfs_start_precac_timer(struct wlan_dfs *dfs, uint8_t precac_chan) { struct dfs_ieee80211_channel *ichan, lc; - uint8_t first_primary_ic_ieee; + uint8_t first_primary_dfs_ch_ieee; int primary_cac_timeout; int secondary_cac_timeout; int precac_timeout; @@ -643,29 +645,30 @@ void dfs_start_precac_timer(struct wlan_dfs *dfs, uint8_t precac_chan) * Get the first primary ieee chan in the HT80 band and find the channel * pointer. */ - first_primary_ic_ieee = precac_chan - VHT80_IEEE_FREQ_OFFSET; + first_primary_dfs_ch_ieee = precac_chan - VHT80_IEEE_FREQ_OFFSET; primary_cac_timeout = dfs_mlme_get_cac_timeout(dfs->dfs_pdev_obj, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags); + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags); ichan = &lc; - dfs_mlme_find_dot11_channel(dfs->dfs_pdev_obj, first_primary_ic_ieee, 0, + dfs_mlme_find_dot11_channel(dfs->dfs_pdev_obj, + first_primary_dfs_ch_ieee, 0, IEEE80211_MODE_11AC_VHT80, - &(ichan->ic_freq), - &(ichan->ic_flags), - &(ichan->ic_flagext), - &(ichan->ic_ieee), - &(ichan->ic_vhtop_ch_freq_seg1), - &(ichan->ic_vhtop_ch_freq_seg2)); + &(ichan->dfs_ch_freq), + &(ichan->dfs_ch_flags), + &(ichan->dfs_ch_flagext), + &(ichan->dfs_ch_ieee), + &(ichan->dfs_ch_vhtop_ch_freq_seg1), + &(ichan->dfs_ch_vhtop_ch_freq_seg2)); secondary_cac_timeout = (dfs->dfs_precac_timeout_override != -1) ? dfs->dfs_precac_timeout_override : dfs_mlme_get_cac_timeout(dfs->dfs_pdev_obj, - ichan->ic_freq, - ichan->ic_vhtop_ch_freq_seg2, - ichan->ic_flags); + ichan->dfs_ch_freq, + ichan->dfs_ch_vhtop_ch_freq_seg2, + ichan->dfs_ch_flags); /* * EXTRA time is needed so that if CAC and PreCAC is running diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_mlme_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_mlme_api.h index becd551d33e0..fcc1036996bc 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_mlme_api.h +++ b/umac/dfs/dispatcher/inc/wlan_dfs_mlme_api.h @@ -76,25 +76,25 @@ void dfs_mlme_proc_cac(struct wlan_objmgr_pdev *pdev, uint32_t vdev_id); /** * dfs_mlme_deliver_event_up_afrer_cac() - Send a CAC timeout, VAP up event to - * userspace. + * userspace. * @pdev: Pointer to DFS pdev object. */ void dfs_mlme_deliver_event_up_afrer_cac(struct wlan_objmgr_pdev *pdev); /** - * dfs_mlme_get_ic_nchans() - Get number of channels in the channel list + * dfs_mlme_get_dfs_ch_nchans() - Get number of channels in the channel list * @pdev: Pointer to DFS pdev object. * @nchans: Pointer to save the channel number. */ -void dfs_mlme_get_ic_nchans(struct wlan_objmgr_pdev *pdev, int *nchans); +void dfs_mlme_get_dfs_ch_nchans(struct wlan_objmgr_pdev *pdev, int *nchans); /** - * dfs_mlme_get_ic_no_weather_radar_chan() - Checks is the channel is weather - * radar channel. + * dfs_mlme_get_dfs_ch_no_weather_radar_chan() - Checks is the channel is + * weather radar channel. * @pdev: Pointer to DFS pdev object. * @no_wradar: Pointer to save weather radar filter value. */ -void dfs_mlme_get_ic_no_weather_radar_chan(struct wlan_objmgr_pdev *pdev, +void dfs_mlme_get_dfs_ch_no_weather_radar_chan(struct wlan_objmgr_pdev *pdev, uint8_t *no_wradar); /** @@ -120,21 +120,21 @@ void dfs_mlme_find_any_valid_channel(struct wlan_objmgr_pdev *pdev, /** * dfs_mlme_get_extchan() - Get extension channel. * @pdev: Pointer to DFS pdev object. - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz * mode of operation. */ QDF_STATUS dfs_mlme_get_extchan(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2); + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2); /** * dfs_mlme_set_no_chans_available() - Set no_chans_available flag. @@ -160,51 +160,51 @@ int dfs_mlme_ieee2mhz(struct wlan_objmgr_pdev *pdev, * @ieee: Channel number. * @des_cfreq2: cfreq2 * @mode: Phymode - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz * mode of operation. */ void dfs_mlme_find_dot11_channel(struct wlan_objmgr_pdev *pdev, uint8_t ieee, uint8_t des_cfreq2, int mode, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2); + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2); /** - * dfs_mlme_get_ic_channels() - Get channel from channel list. + * dfs_mlme_get_dfs_ch_channels() - Get channel from channel list. * @pdev: Pointer to DFS pdev object. - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz * mode of operation. * @index: Index into channel list. */ -void dfs_mlme_get_ic_channels(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2, +void dfs_mlme_get_dfs_ch_channels(struct wlan_objmgr_pdev *pdev, + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2, int index); /** - * dfs_mlme_ic_flags_ext() - Get extension channel flags. + * dfs_mlme_dfs_ch_flags_ext() - Get extension channel flags. * @pdev: Pointer to DFS pdev object. */ -uint32_t dfs_mlme_ic_flags_ext(struct wlan_objmgr_pdev *pdev); +uint32_t dfs_mlme_dfs_ch_flags_ext(struct wlan_objmgr_pdev *pdev); /** * dfs_mlme_channel_change_by_precac() - Channel change by PreCAC. @@ -231,14 +231,14 @@ void dfs_mlme_clist_update(struct wlan_objmgr_pdev *pdev, /** * dfs_mlme_get_cac_timeout() - Get cac_timeout. * @pdev: Pointer to DFS pdev object. - * @ic_freq: Frequency in Mhz. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz * mode of operation. - * @ic_flags: Channel flags. + * @dfs_ch_flags: Channel flags. */ int dfs_mlme_get_cac_timeout(struct wlan_objmgr_pdev *pdev, - uint16_t ic_freq, - uint8_t ic_vhtop_ch_freq_seg2, - uint32_t ic_flags); + uint16_t dfs_ch_freq, + uint8_t dfs_ch_vhtop_ch_freq_seg2, + uint32_t dfs_ch_flags); #endif /* _WLAN_DFS_MLME_API_H_ */ diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h index 20c64baccaae..21f2a120c97a 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h +++ b/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h @@ -34,20 +34,20 @@ extern struct dfs_to_mlme global_dfs_to_mlme; * tgt_dfs_set_current_channel() - Fill dfs channel structure from * dfs_ieee80211_channel structure. * @pdev: Pointer to DFS pdev object. - * @ic_freq: Frequency in Mhz. - * @ic_flags: Channel flags. - * @ic_flagext: Extended channel flags. - * @ic_ieee: IEEE channel number. - * @ic_vhtop_ch_freq_seg1: Channel Center frequency1. - * @ic_vhtop_ch_freq_seg2: Channel Center frequency2. + * @dfs_ch_freq: Frequency in Mhz. + * @dfs_ch_flags: Channel flags. + * @dfs_ch_flagext: Extended channel flags. + * @dfs_ch_ieee: IEEE channel number. + * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency1. + * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency2. */ QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev, - uint16_t ic_freq, - uint32_t ic_flags, - uint16_t ic_flagext, - uint8_t ic_ieee, - uint8_t ic_vhtop_ch_freq_seg1, - uint8_t ic_vhtop_ch_freq_seg2); + uint16_t dfs_ch_freq, + uint32_t dfs_ch_flags, + uint16_t dfs_ch_flagext, + uint8_t dfs_ch_ieee, + uint8_t dfs_ch_vhtop_ch_freq_seg1, + uint8_t dfs_ch_vhtop_ch_freq_seg2); /** * tgt_dfs_reset() - DFS reset diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_ucfg_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_ucfg_api.h index e91d79a754c5..7f44c0e52852 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_ucfg_api.h +++ b/umac/dfs/dispatcher/inc/wlan_dfs_ucfg_api.h @@ -40,18 +40,18 @@ * @mlme_proc_cac: Process the CAC completion event. * @mlme_deliver_event_up_afrer_cac: Send a CAC timeout, VAP up event to user * space - * @mlme_get_ic_nchans: Get number of channels in the channel + * @mlme_get_dfs_ch_nchans: Get number of channels in the channel * list. - * @mlme_get_ic_no_weather_radar_chan: Checks is the channel is weather radar - * channel. + * @mlme_get_dfs_ch_no_weather_radar_chan: Checks is the channel is weather + * radar channel. * @mlme_find_alternate_mode_channel: Finds the channel. * @mlme_find_any_valid_channel: Find the valid channeil. * @mlme_get_extchan: Gets the extension channel. * @mlme_set_no_chans_available: Sets no_chans_available flag. * @mlme_ieee2mhz: Gets Channel freq from ieee number. * @mlme_find_dot11_channel: Find dot11 channel. - * @mlme_get_ic_channels: Get the channel list. - * @mlme_ic_flags_ext: Gets channel extension flag. + * @mlme_get_dfs_ch_channels: Get the channel list. + * @mlme_dfs_ch_flags_ext: Gets channel extension flag. * @mlme_channel_change_by_precac: Channel change triggered by PreCAC. * @mlme_nol_timeout_notification: NOL timeout notification. * @mlme_clist_update: Updates the channel list. @@ -82,9 +82,9 @@ struct dfs_to_mlme { QDF_STATUS (*mlme_proc_cac)(struct wlan_objmgr_pdev *pdev); QDF_STATUS (*mlme_deliver_event_up_afrer_cac)( struct wlan_objmgr_pdev *pdev); - QDF_STATUS (*mlme_get_ic_nchans)(struct wlan_objmgr_pdev *pdev, + QDF_STATUS (*mlme_get_dfs_ch_nchans)(struct wlan_objmgr_pdev *pdev, int *nchans); - QDF_STATUS (*mlme_get_ic_no_weather_radar_chan)( + QDF_STATUS (*mlme_get_dfs_ch_no_weather_radar_chan)( struct wlan_objmgr_pdev *pdev, uint8_t *no_wradar); QDF_STATUS (*mlme_find_alternate_mode_channel)( @@ -97,12 +97,12 @@ struct dfs_to_mlme { uint32_t chan_mode, int *ret_val); QDF_STATUS (*mlme_get_extchan)(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2); + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2); QDF_STATUS (*mlme_set_no_chans_available)(struct wlan_objmgr_pdev *pdev, int val); QDF_STATUS (*mlme_ieee2mhz)(struct wlan_objmgr_pdev *pdev, @@ -113,22 +113,22 @@ struct dfs_to_mlme { uint8_t ieee, uint8_t des_cfreq2, int mode, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2); + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2); - QDF_STATUS (*mlme_get_ic_channels)(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2, + QDF_STATUS (*mlme_get_dfs_ch_channels)(struct wlan_objmgr_pdev *pdev, + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2, int index); - QDF_STATUS (*mlme_ic_flags_ext)(struct wlan_objmgr_pdev *pdev, + QDF_STATUS (*mlme_dfs_ch_flags_ext)(struct wlan_objmgr_pdev *pdev, uint32_t *flag_ext); QDF_STATUS (*mlme_channel_change_by_precac)( struct wlan_objmgr_pdev *pdev); @@ -138,9 +138,9 @@ struct dfs_to_mlme { void *nollist, int nentries); QDF_STATUS (*mlme_get_cac_timeout)(struct wlan_objmgr_pdev *pdev, - uint16_t ic_freq, + uint16_t dfs_ch_freq, uint8_t c_vhtop_ch_freq_seg2, - uint32_t ic_flags, + uint32_t dfs_ch_flags, int *cac_timeout); }; diff --git a/umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c b/umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c index 8b1a594de652..5f3044ce0596 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c @@ -64,9 +64,9 @@ void register_dfs_callbacks(void) tmp_dfs_to_mlme->mlme_proc_cac = mlme_dfs_proc_cac; tmp_dfs_to_mlme->mlme_deliver_event_up_afrer_cac = mlme_dfs_deliver_event_up_afrer_cac; - tmp_dfs_to_mlme->mlme_get_ic_nchans = mlme_dfs_get_ic_nchans; - tmp_dfs_to_mlme->mlme_get_ic_no_weather_radar_chan = - mlme_dfs_get_ic_no_weather_radar_chan; + tmp_dfs_to_mlme->mlme_get_dfs_ch_nchans = mlme_dfs_get_dfs_ch_nchans; + tmp_dfs_to_mlme->mlme_get_dfs_ch_no_weather_radar_chan = + mlme_dfs_get_dfs_ch_no_weather_radar_chan; tmp_dfs_to_mlme->mlme_find_alternate_mode_channel = mlme_dfs_find_alternate_mode_channel; tmp_dfs_to_mlme->mlme_find_any_valid_channel = @@ -76,8 +76,9 @@ void register_dfs_callbacks(void) mlme_dfs_set_no_chans_available; tmp_dfs_to_mlme->mlme_ieee2mhz = mlme_dfs_ieee2mhz; tmp_dfs_to_mlme->mlme_find_dot11_channel = mlme_dfs_find_dot11_channel; - tmp_dfs_to_mlme->mlme_get_ic_channels = mlme_dfs_get_ic_channels; - tmp_dfs_to_mlme->mlme_ic_flags_ext = mlme_dfs_ic_flags_ext; + tmp_dfs_to_mlme->mlme_get_dfs_ch_channels = + mlme_dfs_get_dfs_ch_channels; + tmp_dfs_to_mlme->mlme_dfs_ch_flags_ext = mlme_dfs_dfs_ch_flags_ext; tmp_dfs_to_mlme->mlme_channel_change_by_precac = mlme_dfs_channel_change_by_precac; tmp_dfs_to_mlme->mlme_nol_timeout_notification = diff --git a/umac/dfs/dispatcher/src/wlan_dfs_mlme_api.c b/umac/dfs/dispatcher/src/wlan_dfs_mlme_api.c index 00d994acad92..5ae8a4b8012f 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_mlme_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_mlme_api.c @@ -130,19 +130,19 @@ void dfs_mlme_deliver_event_up_afrer_cac(struct wlan_objmgr_pdev *pdev) pdev); } -void dfs_mlme_get_ic_nchans(struct wlan_objmgr_pdev *pdev, +void dfs_mlme_get_dfs_ch_nchans(struct wlan_objmgr_pdev *pdev, int *nchans) { - if (global_dfs_to_mlme.mlme_get_ic_nchans != NULL) - global_dfs_to_mlme.mlme_get_ic_nchans(pdev, + if (global_dfs_to_mlme.mlme_get_dfs_ch_nchans != NULL) + global_dfs_to_mlme.mlme_get_dfs_ch_nchans(pdev, nchans); } -void dfs_mlme_get_ic_no_weather_radar_chan(struct wlan_objmgr_pdev *pdev, +void dfs_mlme_get_dfs_ch_no_weather_radar_chan(struct wlan_objmgr_pdev *pdev, uint8_t *no_wradar) { - if (global_dfs_to_mlme.mlme_get_ic_no_weather_radar_chan != NULL) - global_dfs_to_mlme.mlme_get_ic_no_weather_radar_chan( + if (global_dfs_to_mlme.mlme_get_dfs_ch_no_weather_radar_chan != NULL) + global_dfs_to_mlme.mlme_get_dfs_ch_no_weather_radar_chan( pdev, no_wradar); } @@ -173,21 +173,21 @@ void dfs_mlme_find_any_valid_channel(struct wlan_objmgr_pdev *pdev, } QDF_STATUS dfs_mlme_get_extchan(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2) + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2) { if (global_dfs_to_mlme.mlme_get_extchan != NULL) return global_dfs_to_mlme.mlme_get_extchan(pdev, - ic_freq, - ic_flags, - ic_flagext, - ic_ieee, - ic_vhtop_ch_freq_seg1, - ic_vhtop_ch_freq_seg2); + dfs_ch_freq, + dfs_ch_flags, + dfs_ch_flagext, + dfs_ch_ieee, + dfs_ch_vhtop_ch_freq_seg1, + dfs_ch_vhtop_ch_freq_seg2); return QDF_STATUS_E_FAILURE; } @@ -218,52 +218,52 @@ void dfs_mlme_find_dot11_channel(struct wlan_objmgr_pdev *pdev, uint8_t ieee, uint8_t des_cfreq2, int mode, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2) + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2) { if (global_dfs_to_mlme.mlme_find_dot11_channel != NULL) global_dfs_to_mlme.mlme_find_dot11_channel(pdev, ieee, des_cfreq2, mode, - ic_freq, - ic_flags, - ic_flagext, - ic_ieee, - ic_vhtop_ch_freq_seg1, - ic_vhtop_ch_freq_seg2); + dfs_ch_freq, + dfs_ch_flags, + dfs_ch_flagext, + dfs_ch_ieee, + dfs_ch_vhtop_ch_freq_seg1, + dfs_ch_vhtop_ch_freq_seg2); } -void dfs_mlme_get_ic_channels(struct wlan_objmgr_pdev *pdev, - uint16_t *ic_freq, - uint32_t *ic_flags, - uint16_t *ic_flagext, - uint8_t *ic_ieee, - uint8_t *ic_vhtop_ch_freq_seg1, - uint8_t *ic_vhtop_ch_freq_seg2, +void dfs_mlme_get_dfs_ch_channels(struct wlan_objmgr_pdev *pdev, + uint16_t *dfs_ch_freq, + uint32_t *dfs_ch_flags, + uint16_t *dfs_ch_flagext, + uint8_t *dfs_ch_ieee, + uint8_t *dfs_ch_vhtop_ch_freq_seg1, + uint8_t *dfs_ch_vhtop_ch_freq_seg2, int index) { - if (global_dfs_to_mlme.mlme_get_ic_channels != NULL) - global_dfs_to_mlme.mlme_get_ic_channels(pdev, - ic_freq, - ic_flags, - ic_flagext, - ic_ieee, - ic_vhtop_ch_freq_seg1, - ic_vhtop_ch_freq_seg2, + if (global_dfs_to_mlme.mlme_get_dfs_ch_channels != NULL) + global_dfs_to_mlme.mlme_get_dfs_ch_channels(pdev, + dfs_ch_freq, + dfs_ch_flags, + dfs_ch_flagext, + dfs_ch_ieee, + dfs_ch_vhtop_ch_freq_seg1, + dfs_ch_vhtop_ch_freq_seg2, index); } -uint32_t dfs_mlme_ic_flags_ext(struct wlan_objmgr_pdev *pdev) +uint32_t dfs_mlme_dfs_ch_flags_ext(struct wlan_objmgr_pdev *pdev) { uint32_t flag_ext = 0; - if (global_dfs_to_mlme.mlme_ic_flags_ext != NULL) - global_dfs_to_mlme.mlme_ic_flags_ext(pdev, + if (global_dfs_to_mlme.mlme_dfs_ch_flags_ext != NULL) + global_dfs_to_mlme.mlme_dfs_ch_flags_ext(pdev, &flag_ext); return flag_ext; @@ -294,17 +294,17 @@ void dfs_mlme_clist_update(struct wlan_objmgr_pdev *pdev, } int dfs_mlme_get_cac_timeout(struct wlan_objmgr_pdev *pdev, - uint16_t ic_freq, - uint8_t ic_vhtop_ch_freq_seg2, - uint32_t ic_flags) + uint16_t dfs_ch_freq, + uint8_t dfs_ch_vhtop_ch_freq_seg2, + uint32_t dfs_ch_flags) { int cac_timeout = 0; if (global_dfs_to_mlme.mlme_get_cac_timeout != NULL) global_dfs_to_mlme.mlme_get_cac_timeout(pdev, - ic_freq, - ic_vhtop_ch_freq_seg2, - ic_flags, + dfs_ch_freq, + dfs_ch_vhtop_ch_freq_seg2, + dfs_ch_flags, &cac_timeout); return cac_timeout; diff --git a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c index 278bf0bcf5da..d98bcd9305bd 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c @@ -36,12 +36,12 @@ wlan_psoc_get_dfs_txops(struct wlan_objmgr_psoc *psoc) } QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev, - uint16_t ic_freq, - uint32_t ic_flags, - uint16_t ic_flagext, - uint8_t ic_ieee, - uint8_t ic_vhtop_ch_freq_seg1, - uint8_t ic_vhtop_ch_freq_seg2) + uint16_t dfs_ch_freq, + uint32_t dfs_ch_flags, + uint16_t dfs_ch_flagext, + uint8_t dfs_ch_ieee, + uint8_t dfs_ch_vhtop_ch_freq_seg1, + uint8_t dfs_ch_vhtop_ch_freq_seg2) { struct wlan_dfs *dfs; @@ -49,8 +49,13 @@ QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev, if (dfs == NULL) return QDF_STATUS_E_FAILURE; - dfs_set_current_channel(dfs, ic_freq, ic_flags, ic_flagext, ic_ieee, - ic_vhtop_ch_freq_seg1, ic_vhtop_ch_freq_seg2); + dfs_set_current_channel(dfs, + dfs_ch_freq, + dfs_ch_flags, + dfs_ch_flagext, + dfs_ch_ieee, + dfs_ch_vhtop_ch_freq_seg1, + dfs_ch_vhtop_ch_freq_seg2); return QDF_STATUS_SUCCESS; } @@ -253,10 +258,10 @@ QDF_STATUS tgt_dfs_process_radar_ind(struct wlan_objmgr_pdev *pdev, } dfs_process_radar_found_indication(dfs, radar_found); - dfs_mlme_mark_dfs(pdev, dfs->dfs_curchan->ic_ieee, - dfs->dfs_curchan->ic_freq, - dfs->dfs_curchan->ic_vhtop_ch_freq_seg2, - dfs->dfs_curchan->ic_flags); + dfs_mlme_mark_dfs(pdev, dfs->dfs_curchan->dfs_ch_ieee, + dfs->dfs_curchan->dfs_ch_freq, + dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2, + dfs->dfs_curchan->dfs_ch_flags); return QDF_STATUS_SUCCESS; } diff --git a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c b/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c index 157f4e0bbf07..bb1593a24b06 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c @@ -465,8 +465,9 @@ static void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev, } for (i = 0; i < len; i++) { - chan_list[i].ic_ieee = pcl_ch[i]; - chan_list[i].ic_freq = wlan_reg_chan_to_freq(pdev, pcl_ch[i]); + chan_list[i].dfs_ch_ieee = pcl_ch[i]; + chan_list[i].dfs_ch_freq = + wlan_reg_chan_to_freq(pdev, pcl_ch[i]); } *num_chan = i; DFS_PRINTK("%s: num channels %d\n", __func__, i); @@ -517,8 +518,8 @@ QDF_STATUS dfs_get_random_channel( goto random_chan_error; } - cur_chan.ic_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0; - cur_chan.ic_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1; + cur_chan.dfs_ch_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0; + cur_chan.dfs_ch_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1; if (!ch_params->ch_width) utils_dfs_get_max_sup_width(pdev, @@ -528,8 +529,8 @@ QDF_STATUS dfs_get_random_channel( num_chan, flags, (uint8_t *)&ch_params->ch_width, &cur_chan, (uint8_t)dfs_reg, acs_info); - ch_params->center_freq_seg0 = cur_chan.ic_vhtop_ch_freq_seg1; - ch_params->center_freq_seg1 = cur_chan.ic_vhtop_ch_freq_seg2; + ch_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1; + ch_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2; DFS_PRINTK("%s: input width=%d\n", __func__, ch_params->ch_width); if (*target_chan) {