/*
 * Copyright (c) 2011-2014, 2017 The Linux Foundation. All rights reserved.
 *
 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
 *
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This file was originally distributed by Qualcomm Atheros, Inc.
 * under proprietary terms before Copyright ownership was assigned
 * to the Linux Foundation.
 */

#ifndef _OL_TXRX_INTERNAL__H_
#define _OL_TXRX_INTERNAL__H_

#include <adf_os_util.h>   /* adf_os_assert */
#include <adf_nbuf.h>      /* adf_nbuf_t */
#include <adf_os_mem.h>    /* adf_os_mem_set */
#include <ieee80211_common.h>     /* ieee80211_frame */
#include <ol_htt_rx_api.h> /* htt_rx_msdu_desc_completes_mpdu, etc. */

#include <ol_txrx_types.h>

#include <ol_txrx_dbg.h>
#include <enet.h>          /* ETHERNET_HDR_LEN, etc. */
#include <ipv4.h>          /* IPV4_HDR_LEN, etc. */
#include <ipv6.h>          /* IPV6_HDR_LEN, etc. */
#include <ip_prot.h>       /* IP_PROTOCOL_TCP, etc. */

#ifdef ATH_11AC_TXCOMPACT
#define OL_TX_DESC_NO_REFS(tx_desc) 1
#define OL_TX_DESC_REF_INIT(tx_desc) /* no-op */
#define OL_TX_DESC_REF_INC(tx_desc) /* no-op */
#else
#define OL_TX_DESC_NO_REFS(tx_desc) \
    adf_os_atomic_dec_and_test(&tx_desc->ref_cnt)
#define OL_TX_DESC_REF_INIT(tx_desc) adf_os_atomic_init(&tx_desc->ref_cnt)
#define OL_TX_DESC_REF_INC(tx_desc) adf_os_atomic_inc(&tx_desc->ref_cnt)
#endif

#ifndef ARRAY_LEN
#define ARRAY_LEN(x) (sizeof(x)/sizeof(x[0]))
#endif


#ifndef TXRX_ASSERT_LEVEL
#define TXRX_ASSERT_LEVEL 3
#endif

#ifdef __KLOCWORK__
# define TXRX_ASSERT1(x) do { if (!(x)) abort(); } while (0)
# define TXRX_ASSERT2(x) do { if (!(x)) abort(); } while (0)
#else // #ifdef __KLOCWORK__

#if TXRX_ASSERT_LEVEL > 0
#define TXRX_ASSERT1(condition) adf_os_assert((condition))
#else
#define TXRX_ASSERT1(condition)
#endif

#if TXRX_ASSERT_LEVEL > 1
#define TXRX_ASSERT2(condition) adf_os_assert((condition))
#else
#define TXRX_ASSERT2(condition)
#endif
#endif // #ifdef __KLOCWORK__
enum {
    /* FATAL_ERR - print only irrecoverable error messages */
    TXRX_PRINT_LEVEL_FATAL_ERR,

    /* ERR - include non-fatal err messages */
    TXRX_PRINT_LEVEL_ERR,

    /* WARN - include warnings */
    TXRX_PRINT_LEVEL_WARN,

    /* INFO1 - include fundamental, infrequent events */
    TXRX_PRINT_LEVEL_INFO1,

    /* INFO2 - include non-fundamental but infrequent events */
    TXRX_PRINT_LEVEL_INFO2,

    /* INFO3 - include frequent events */
    /* to avoid performance impact, don't use INFO3 unless explicitly enabled */
    #ifdef TXRX_PRINT_VERBOSE_ENABLE
    TXRX_PRINT_LEVEL_INFO3,
    #endif /* TXRX_PRINT_VERBOSE_ENABLE */
};

extern unsigned g_txrx_print_level;

#ifdef TXRX_PRINT_ENABLE

#include <stdarg.h>       /* va_list */
#include <adf_os_types.h> /* adf_os_vprint */

/* Supress 4296 - expression is always true
 * It will fire if level is TXRX_PRINT_LEVEL_FATAL_ERR (0)
 * because g_txrx_print_level is unsigned */
#define ol_txrx_print(level, fmt, ...) \
    if (level <= g_txrx_print_level) adf_os_print(fmt, ## __VA_ARGS__)
#define TXRX_PRINT(level, fmt, ...) \
    ol_txrx_print(level, "TXRX: " fmt, ## __VA_ARGS__)

#ifdef TXRX_PRINT_VERBOSE_ENABLE

#define ol_txrx_print_verbose(fmt, ...) \
    if (TXRX_PRINT_LEVEL_INFO3 <= g_txrx_print_level) \
        adf_os_print(fmt, ## __VA_ARGS__)
#define TXRX_PRINT_VERBOSE(fmt, ...) \
    ol_txrx_print_verbose("TXRX: " fmt, ## __VA_ARGS__)
#else
#define TXRX_PRINT_VERBOSE(fmt, ...)
#endif /* TXRX_PRINT_VERBOSE_ENABLE */

/* define PN check failure message print rate
   as 1 second */
#define TXRX_PN_CHECK_FAILURE_PRINT_PERIOD_MS  1000

#else
#define TXRX_PRINT(level, fmt, ...)
#define TXRX_PRINT_VERBOSE(fmt, ...)
#endif /* TXRX_PRINT_ENABLE */

/*--- tx credit debug printouts ---*/

#ifndef DEBUG_CREDIT
#define DEBUG_CREDIT 0
#endif

#if DEBUG_CREDIT
#define TX_CREDIT_DEBUG_PRINT(fmt, ...) adf_os_print(fmt, ## __VA_ARGS__)
#else
#define TX_CREDIT_DEBUG_PRINT(fmt, ...)
#endif

/*--- tx scheduler debug printouts ---*/

#ifdef HOST_TX_SCHED_DEBUG
#define TX_SCHED_DEBUG_PRINT(fmt, ...) adf_os_print(fmt, ## __VA_ARGS__)
#else
#define TX_SCHED_DEBUG_PRINT(fmt, ...)
#endif
#define TX_SCHED_DEBUG_PRINT_ALWAYS(fmt, ...) adf_os_print(fmt, ## __VA_ARGS__)

#define OL_TXRX_LIST_APPEND(head, tail, elem) \
do {                                            \
    if (!(head)) {                              \
        (head) = (elem);                        \
    } else {                                    \
        adf_nbuf_set_next((tail), (elem));      \
    }                                           \
    (tail) = (elem);                            \
} while (0)

static inline void
ol_rx_mpdu_list_next(
    struct ol_txrx_pdev_t *pdev,
    void *mpdu_list,
    adf_nbuf_t *mpdu_tail,
    adf_nbuf_t *next_mpdu)
{
    htt_pdev_handle htt_pdev = pdev->htt_pdev;
    adf_nbuf_t msdu;

    /*
     * For now, we use a simply flat list of MSDUs.
     * So, traverse the list until we reach the last MSDU within the MPDU.
     */
    TXRX_ASSERT2(mpdu_list);
    msdu = mpdu_list;
    while (!htt_rx_msdu_desc_completes_mpdu(
                htt_pdev, htt_rx_msdu_desc_retrieve(htt_pdev, msdu)))
    {
        msdu = adf_nbuf_next(msdu);
        TXRX_ASSERT2(msdu);
    }
    /* msdu now points to the last MSDU within the first MPDU */
    *mpdu_tail = msdu;
    *next_mpdu = adf_nbuf_next(msdu);
}


/*--- txrx stats macros ---*/


/* unconditional defs */
#define TXRX_STATS_INCR(pdev, field) TXRX_STATS_ADD(pdev, field, 1)

/* default conditional defs (may be undefed below) */

#define TXRX_STATS_INIT(_pdev) \
    adf_os_mem_set(&((_pdev)->stats), 0x0, sizeof((_pdev)->stats))
#define TXRX_STATS_ADD(_pdev, _field, _delta) \
    _pdev->stats._field += _delta
#define TXRX_STATS_MSDU_INCR(pdev, field, netbuf) \
    do { \
        TXRX_STATS_INCR((pdev), pub.field.pkts); \
        TXRX_STATS_ADD((pdev), pub.field.bytes, adf_nbuf_len(netbuf)); \
    } while (0)

/* conditional defs based on verbosity level */

#if /*---*/ TXRX_STATS_LEVEL == TXRX_STATS_LEVEL_FULL

#define TXRX_STATS_MSDU_LIST_INCR(pdev, field, netbuf_list) \
    do { \
        adf_nbuf_t tmp_list = netbuf_list; \
        while (tmp_list) { \
            TXRX_STATS_MSDU_INCR(pdev, field, tmp_list); \
            tmp_list = adf_nbuf_next(tmp_list); \
        } \
    } while (0)

#define TXRX_STATS_MSDU_INCR_TX_STATUS(status, pdev, netbuf) \
    switch (status) { \
    case htt_tx_status_ok: \
        TXRX_STATS_MSDU_INCR(pdev, tx.delivered, netbuf); \
        break; \
    case htt_tx_status_discard: \
        TXRX_STATS_MSDU_INCR(pdev, tx.dropped.target_discard, netbuf); \
        break; \
    case htt_tx_status_no_ack: \
        TXRX_STATS_MSDU_INCR(pdev, tx.dropped.no_ack, netbuf); \
        break; \
    case htt_tx_status_download_fail: \
        TXRX_STATS_MSDU_INCR(pdev, tx.dropped.download_fail, netbuf); \
        break; \
    default: \
        break; \
    }

#define TXRX_STATS_UPDATE_TX_COMP_HISTOGRAM(_pdev, _p_cntrs)                   \
do {                                                                           \
    if (_p_cntrs > 60)                                                         \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_61_plus,1);            \
    else if (_p_cntrs > 50)                                                    \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_51_60,1);              \
    else if (_p_cntrs > 40)                                                    \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_41_50,1);              \
    else if (_p_cntrs > 30)                                                    \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_31_40,1);              \
    else if (_p_cntrs > 20)                                                    \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_21_30,1);              \
    else if (_p_cntrs > 10)                                                    \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_11_20,1);              \
    else if (_p_cntrs > 2)                                                     \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_2_10,1);               \
    else                                                                       \
        TXRX_STATS_ADD(_pdev,pub.tx.comp_histogram.pkts_1,1);                  \
                                                                               \
} while (0)


#define TXRX_STATS_UPDATE_TX_STATS(_pdev, _status, _p_cntrs, _b_cntrs)         \
do {                                                                           \
    switch (status) {                                                          \
    case htt_tx_status_ok:                                                     \
       TXRX_STATS_ADD(_pdev, pub.tx.delivered.pkts, _p_cntrs);                 \
       TXRX_STATS_ADD(_pdev, pub.tx.delivered.bytes, _b_cntrs);                \
        break;                                                                 \
    case htt_tx_status_discard:                                                \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.target_discard.pkts, _p_cntrs);    \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.target_discard.bytes, _b_cntrs);   \
        break;                                                                 \
    case htt_tx_status_no_ack:                                                 \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.no_ack.pkts, _p_cntrs);            \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.no_ack.bytes, _b_cntrs);           \
        break;                                                                 \
    case htt_tx_status_download_fail:                                          \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.download_fail.pkts, _p_cntrs);     \
       TXRX_STATS_ADD(_pdev, pub.tx.dropped.download_fail.bytes, _b_cntrs);    \
        break;                                                                 \
    default:                                                                   \
        break;                                                                 \
    }                                                                          \
    TXRX_STATS_UPDATE_TX_COMP_HISTOGRAM(_pdev, _p_cntrs);                      \
} while (0)

#elif /*---*/ TXRX_STATS_LEVEL == TXRX_STATS_LEVEL_BASIC

#define TXRX_STATS_MSDU_LIST_INCR(pdev, field, netbuf_list) \
    do { \
        adf_nbuf_t tmp_list = netbuf_list; \
        while (tmp_list) { \
            TXRX_STATS_MSDU_INCR(pdev, field, tmp_list); \
            tmp_list = adf_nbuf_next(tmp_list); \
        } \
    } while (0)

#define TXRX_STATS_MSDU_INCR_TX_STATUS(status, pdev, netbuf) \
    do { \
        if (status == htt_tx_status_ok) { \
            TXRX_STATS_MSDU_INCR(pdev, tx.delivered, netbuf); \
        } \
    } while (0)

#define TXRX_STATS_INIT(_pdev) \
    adf_os_mem_set(&((_pdev)->stats), 0x0, sizeof((_pdev)->stats))

#define TXRX_STATS_UPDATE_TX_STATS(_pdev, _status, _p_cntrs, _b_cntrs)          \
do {                                                                            \
    if (adf_os_likely(_status == htt_tx_status_ok)) {                           \
       TXRX_STATS_ADD(_pdev, pub.tx.delivered.pkts, _p_cntrs);                  \
       TXRX_STATS_ADD(_pdev, pub.tx.delivered.bytes, _b_cntrs);                 \
    }                                                                           \
} while (0)

#else /*---*/ /* stats off */

#undef  TXRX_STATS_INIT
#define TXRX_STATS_INIT(_pdev)

#undef  TXRX_STATS_ADD
#define TXRX_STATS_ADD(_pdev, _field, _delta)

#undef  TXRX_STATS_MSDU_INCR
#define TXRX_STATS_MSDU_INCR(pdev, field, netbuf)

#define TXRX_STATS_MSDU_LIST_INCR(pdev, field, netbuf_list)

#define TXRX_STATS_MSDU_INCR_TX_STATUS(status, pdev, netbuf)

#define TXRX_STATS_UPDATE_TX_STATS(_pdev, _status, _p_cntrs, _b_cntrs)

#endif /*---*/ /* TXRX_STATS_LEVEL */


/*--- txrx sequence number trace macros ---*/


#define TXRX_SEQ_NUM_ERR(_status) (0xffff - _status)

#if defined(ENABLE_RX_REORDER_TRACE)

A_STATUS ol_rx_reorder_trace_attach(ol_txrx_pdev_handle pdev);
void ol_rx_reorder_trace_detach(ol_txrx_pdev_handle pdev);
void ol_rx_reorder_trace_add(
    ol_txrx_pdev_handle pdev,
    u_int8_t tid,
    u_int16_t reorder_idx,
    u_int16_t seq_num,
    int num_mpdus);

#define OL_RX_REORDER_TRACE_ATTACH ol_rx_reorder_trace_attach
#define OL_RX_REORDER_TRACE_DETACH ol_rx_reorder_trace_detach
#define OL_RX_REORDER_TRACE_ADD    ol_rx_reorder_trace_add

#else

#define OL_RX_REORDER_TRACE_ATTACH(_pdev) A_OK
#define OL_RX_REORDER_TRACE_DETACH(_pdev)
#define OL_RX_REORDER_TRACE_ADD(pdev, tid, reorder_idx, seq_num, num_mpdus)

#endif /* ENABLE_RX_REORDER_TRACE */


/*--- txrx packet number trace macros ---*/


#if defined(ENABLE_RX_PN_TRACE)

A_STATUS ol_rx_pn_trace_attach(ol_txrx_pdev_handle pdev);
void ol_rx_pn_trace_detach(ol_txrx_pdev_handle pdev);
void ol_rx_pn_trace_add(
    struct ol_txrx_pdev_t *pdev,
    struct ol_txrx_peer_t *peer,
    u_int16_t tid,
    void *rx_desc);

#define OL_RX_PN_TRACE_ATTACH ol_rx_pn_trace_attach
#define OL_RX_PN_TRACE_DETACH ol_rx_pn_trace_detach
#define OL_RX_PN_TRACE_ADD    ol_rx_pn_trace_add

#else

#define OL_RX_PN_TRACE_ATTACH(_pdev) A_OK
#define OL_RX_PN_TRACE_DETACH(_pdev)
#define OL_RX_PN_TRACE_ADD(pdev, peer, tid, rx_desc)

#endif /* ENABLE_RX_PN_TRACE */

static inline int
ol_txrx_ieee80211_hdrsize(const void *data)
{
    const struct ieee80211_frame *wh = (const struct ieee80211_frame *)data;
    int size = sizeof(struct ieee80211_frame);

    /* NB: we don't handle control frames */
    TXRX_ASSERT1(
        (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_CTL);
    if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
        size += IEEE80211_ADDR_LEN;
    }
    if (IEEE80211_QOS_HAS_SEQ(wh)) {
        size += sizeof(u_int16_t);
        /* Qos frame with Order bit set indicates an HTC frame */
        if (wh->i_fc[1] & IEEE80211_FC1_ORDER) {
            size += sizeof(struct ieee80211_htc);
        }
    }
    return size;
}

/*--- frame display utility ---*/

enum ol_txrx_frm_dump_options {
    ol_txrx_frm_dump_contents = 0x1,
    ol_txrx_frm_dump_tcp_seq  = 0x2,
};

#ifdef TXRX_DEBUG_DATA
static inline void
OL_TXRX_FRMS_DUMP(
    const char *name,
    struct ol_txrx_pdev_t *pdev,
    adf_nbuf_t frm,
    enum ol_txrx_frm_dump_options display_options,
    int max_len)
{
    #define TXRX_FRM_DUMP_MAX_LEN 128
    u_int8_t local_buf[TXRX_FRM_DUMP_MAX_LEN] = {0};
    u_int8_t *p;

    if (name) {
        VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO, "%s\n", name);
    }
    while (frm) {
        p = adf_nbuf_data(frm);
        if (display_options & ol_txrx_frm_dump_tcp_seq) {
            int tcp_offset;
            int l2_hdr_size;
            u_int16_t ethertype;
            u_int8_t ip_prot;

            if (pdev->frame_format == wlan_frm_fmt_802_3) {
                struct ethernet_hdr_t *enet_hdr = (struct ethernet_hdr_t *) p;
                l2_hdr_size = ETHERNET_HDR_LEN;

                /*
                 * LLC/SNAP present?
                 */
                ethertype =
                    (enet_hdr->ethertype[0] << 8) | enet_hdr->ethertype[1];
                if (!IS_ETHERTYPE(ethertype)) {
                    /* 802.3 format */
                    struct llc_snap_hdr_t *llc_hdr;

                    llc_hdr = (struct llc_snap_hdr_t *) (p + l2_hdr_size);
                    l2_hdr_size += LLC_SNAP_HDR_LEN;
                    ethertype =
                        (llc_hdr->ethertype[0] << 8) | llc_hdr->ethertype[1];
                }
            } else {
                struct llc_snap_hdr_t *llc_hdr;
                /* (generic?) 802.11 */
                l2_hdr_size = sizeof(struct ieee80211_frame);
                llc_hdr = (struct llc_snap_hdr_t *) (p + l2_hdr_size);
                l2_hdr_size += LLC_SNAP_HDR_LEN;
                ethertype =
                    (llc_hdr->ethertype[0] << 8) | llc_hdr->ethertype[1];
            }
            if (ethertype == ETHERTYPE_IPV4) {
                struct ipv4_hdr_t *ipv4_hdr;
                ipv4_hdr = (struct ipv4_hdr_t *) (p + l2_hdr_size);
                ip_prot = ipv4_hdr->protocol;
                tcp_offset = l2_hdr_size + IPV4_HDR_LEN;
            } else if (ethertype == ETHERTYPE_IPV6) {
                struct ipv6_hdr_t *ipv6_hdr;
                ipv6_hdr = (struct ipv6_hdr_t *) (p + l2_hdr_size);
                ip_prot = ipv6_hdr->next_hdr;
                tcp_offset = l2_hdr_size + IPV6_HDR_LEN;
            } else {
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                    "frame %pK non-IP ethertype (%x)\n", frm, ethertype);
                goto NOT_IP_TCP;
            }
            if (ip_prot == IP_PROTOCOL_TCP) {
#if 0
                struct tcp_hdr_t *tcp_hdr;
                u_int32_t tcp_seq_num;
                tcp_hdr = (struct tcp_hdr_t *) (p + tcp_offset);
                tcp_seq_num =
                    (tcp_hdr->seq_num[0] << 24) |
                    (tcp_hdr->seq_num[1] << 16) |
                    (tcp_hdr->seq_num[1] <<  8) |
                    (tcp_hdr->seq_num[1] <<  0);
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                    "frame %pK: TCP seq num = %d\n", frm, tcp_seq_num);
#else
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                     "frame %pK: TCP seq num = %d\n", frm,
                    ((*(p + tcp_offset + 4)) << 24) |
                    ((*(p + tcp_offset + 5)) << 16) |
                    ((*(p + tcp_offset + 6)) <<  8) |
                     (*(p + tcp_offset + 7)));
#endif
            } else {
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                    "frame %pK non-TCP IP protocol (%x)\n", frm, ip_prot);
            }
        }
NOT_IP_TCP:
        if (display_options & ol_txrx_frm_dump_contents) {
            int i, frag_num, len_lim;
            len_lim = max_len;
            if (len_lim > adf_nbuf_len(frm)) {
                len_lim = adf_nbuf_len(frm);
            }
            if (len_lim > TXRX_FRM_DUMP_MAX_LEN) {
                len_lim = TXRX_FRM_DUMP_MAX_LEN;
            }

            /*
             * Gather frame contents from netbuf fragments
             * into a contiguous buffer.
             */
            frag_num = 0;
            i = 0;
            while (i < len_lim) {
                int frag_bytes;
                frag_bytes = adf_nbuf_get_frag_len(frm, frag_num);
                if (frag_bytes > len_lim - i) {
                    frag_bytes = len_lim - i;
                }
                if (frag_bytes > 0) {
                    p = adf_nbuf_get_frag_vaddr(frm, frag_num);
                    adf_os_mem_copy(&local_buf[i], p, frag_bytes);
                }
                frag_num++;
                i += frag_bytes;
            }

            VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                "frame %pK data (%pK), hex dump of bytes 0-%d of %d:\n",
                frm, p, len_lim-1, (int) adf_nbuf_len(frm));
            p = local_buf;
            while (len_lim > 16) {
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                    "  " /* indent */
                    "%02x %02x %02x %02x %02x %02x %02x %02x "
                    "%02x %02x %02x %02x %02x %02x %02x %02x\n",
                    *(p +  0), *(p +  1), *(p +  2), *(p +  3),
                    *(p +  4), *(p +  5), *(p +  6), *(p +  7),
                    *(p +  8), *(p +  9), *(p + 10), *(p + 11),
                    *(p + 12), *(p + 13), *(p + 14), *(p + 15));
                p += 16;
                len_lim -= 16;
            }
            VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                "  " /* indent */);
            while (len_lim > 0) {
                VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO,
                    "%02x ", *p);
                p++;
                len_lim--;
            }
            VOS_TRACE(VOS_MODULE_ID_TXRX, VOS_TRACE_LEVEL_INFO, "\n");
        }
        frm = adf_nbuf_next(frm);
    }
}
#else
#define OL_TXRX_FRMS_DUMP(name, pdev, frms, display_options, max_len)
#endif /* TXRX_DEBUG_DATA */

#ifdef SUPPORT_HOST_STATISTICS

#define OL_RX_ERR_STATISTICS(pdev, vdev, err_type, sec_type, is_mcast) \
    ol_rx_err_statistics(pdev->ctrl_pdev, vdev->vdev_id, err_type,     \
			             sec_type, is_mcast);

#define OL_RX_ERR_STATISTICS_1(pdev, vdev, peer, rx_desc, err_type)                  \
do {                                                                                    \
    int is_mcast;                                                                    \
    enum htt_sec_type sec_type;                                                      \
    is_mcast = htt_rx_msdu_is_wlan_mcast(pdev->htt_pdev, rx_desc);                   \
    sec_type = peer->security[is_mcast ? txrx_sec_mcast : txrx_sec_ucast].sec_type;  \
	OL_RX_ERR_STATISTICS(pdev, vdev, err_type, pdev->sec_types[sec_type], is_mcast); \
} while (false)

#define OL_RX_ERR_INV_PEER_STATISTICS(pdev, rx_msdu)                             \
do {                                                                                \
	struct ieee80211_frame *wh = NULL;                                           \
	/*FIX THIS :Here htt_rx_mpdu_wifi_hdr_retrieve should be used. But at */     \
    /*present it seems it does not work.*/                                       \
	/*wh = (struct ieee80211_frame *)htt_rx_mpdu_wifi_hdr_retrieve(pdev->htt_pdev, rx_desc);*/ \
	                                                                             \
	/* this only apply to LL device.*/                                           \
	if (!ol_cfg_is_high_latency(pdev->ctrl_pdev) &&                              \
			ol_cfg_frame_type(pdev->ctrl_pdev) == wlan_frm_fmt_native_wifi) {    \
		/* For windows, it is always native wifi header .*/                      \
		wh = (struct ieee80211_frame*)adf_nbuf_data(rx_msdu);                    \
	}                                                                            \
	ol_rx_err_inv_peer_statistics(pdev->ctrl_pdev, wh, OL_RX_ERR_UNKNOWN_PEER);  \
} while (false)

#define OL_RX_ERR_STATISTICS_2(pdev, vdev, peer, rx_desc, rx_msdu, rx_status)                 \
do {                                                                                    \
	enum ol_rx_err_type err_type = OL_RX_ERR_NONE;                                   \
    switch (rx_status) {                                                             \
		case htt_rx_status_decrypt_err:                                              \
			 err_type = OL_RX_ERR_DECRYPT;                                           \
			 break;                                                                  \
		case htt_rx_status_tkip_mic_err:                                             \
			 err_type = OL_RX_ERR_TKIP_MIC;                                          \
			 break;                                                                  \
		case htt_rx_status_mpdu_length_err:                                          \
		     err_type = OL_RX_ERR_MPDU_LENGTH;                                       \
			 break;                                                                  \
		case htt_rx_status_mpdu_encrypt_required_err:                                \
		     err_type = OL_RX_ERR_ENCRYPT_REQUIRED;                                  \
			 break;                                                                  \
		case htt_rx_status_err_dup:                                                  \
		     err_type = OL_RX_ERR_DUP;                                               \
			 break;                                                                  \
		case htt_rx_status_err_fcs:                                                  \
		     err_type = OL_RX_ERR_FCS;                                               \
			 break;                                                                  \
		default:                                                                     \
			 err_type = OL_RX_ERR_UNKNOWN;                                           \
		     break;                                                                  \
	}                                                                                \
	if (vdev != NULL && peer != NULL) {                                              \
	    OL_RX_ERR_STATISTICS_1(pdev, vdev, peer, rx_mpdu_desc, err_type);            \
	} else {                                                                         \
		OL_RX_ERR_INV_PEER_STATISTICS(pdev, rx_msdu);                                \
	}                                                                                \
} while (false)
#else
#define OL_RX_ERR_STATISTICS(pdev, vdev, err_type, sec_type, is_mcast)
#define OL_RX_ERR_STATISTICS_1(pdev, vdev, peer, rx_desc, err_type)
#define OL_RX_ERR_STATISTICS_2(pdev, vdev, peer, rx_desc, rx_msdu, rx_status)
#endif /* SUPPORT_HOST_STATISTICS */

#ifdef QCA_ENABLE_OL_TXRX_PEER_STATS
#define OL_TXRX_PEER_STATS_UPDATE_BASE(peer, tx_or_rx, type, msdu) \
    do { \
        adf_os_spin_lock_bh(&peer->vdev->pdev->peer_stat_mutex); \
        peer->stats. tx_or_rx .frms.  type += 1; \
        peer->stats. tx_or_rx .bytes. type += adf_nbuf_len(msdu); \
        adf_os_spin_unlock_bh(&peer->vdev->pdev->peer_stat_mutex); \
    } while (0)
#define OL_TXRX_PEER_STATS_UPDATE(peer, tx_or_rx, msdu) \
    do { \
        struct ol_txrx_vdev_t *vdev = peer->vdev; \
        struct ol_txrx_pdev_t *pdev = vdev->pdev; \
        u_int8_t *dest_addr; \
        if (pdev->frame_format == wlan_frm_fmt_802_3) { \
            dest_addr = adf_nbuf_data(msdu); \
        } else { /* 802.11 format */ \
            struct ieee80211_frame *frm; \
            frm = (struct ieee80211_frame *) adf_nbuf_data(msdu); \
            if (vdev->opmode == wlan_op_mode_ap) { \
                dest_addr = (u_int8_t *) &(frm->i_addr1[0]); \
            } else { \
                dest_addr = (u_int8_t *) &(frm->i_addr3[0]); \
            } \
        } \
        if (adf_os_unlikely(IEEE80211_IS_BROADCAST(dest_addr))) { \
            OL_TXRX_PEER_STATS_UPDATE_BASE(peer, tx_or_rx, bcast, msdu); \
        } else if (adf_os_unlikely(IEEE80211_IS_MULTICAST(dest_addr))) { \
            OL_TXRX_PEER_STATS_UPDATE_BASE(peer, tx_or_rx, mcast, msdu); \
        } else { \
            OL_TXRX_PEER_STATS_UPDATE_BASE(peer, tx_or_rx, ucast, msdu); \
        } \
    } while (0)
#define OL_TX_PEER_STATS_UPDATE(peer, msdu) \
    OL_TXRX_PEER_STATS_UPDATE(peer, tx, msdu)
#define OL_RX_PEER_STATS_UPDATE(peer, msdu) \
    OL_TXRX_PEER_STATS_UPDATE(peer, rx, msdu)
#define OL_TXRX_PEER_STATS_MUTEX_INIT(pdev) \
    adf_os_spinlock_init(&pdev->peer_stat_mutex)
#define OL_TXRX_PEER_STATS_MUTEX_DESTROY(pdev) \
    adf_os_spinlock_destroy(&pdev->peer_stat_mutex)
#else
#define OL_TX_PEER_STATS_UPDATE(peer, msdu) /* no-op */
#define OL_RX_PEER_STATS_UPDATE(peer, msdu) /* no-op */
#define OL_TXRX_PEER_STATS_MUTEX_INIT(peer) /* no-op */
#define OL_TXRX_PEER_STATS_MUTEX_DESTROY(peer) /* no-op */
#endif

#ifndef DEBUG_HTT_CREDIT
#define DEBUG_HTT_CREDIT 0
#endif

#ifdef FEATURE_HL_GROUP_CREDIT_FLOW_CONTROL
void
ol_txrx_update_group_credit(
    struct ol_tx_queue_group_t *group,
    int32_t credit,
    u_int8_t absolute);
#endif

#endif /* _OL_TXRX_INTERNAL__H_ */