/space/home/slher/rel/Beken/v6_4_5/macsw/ip/lmac/src/tx/txl/txl_buffer.h

Go to the documentation of this file.

#ifndef _TXL_BUFFER_H_
#define _TXL_BUFFER_H_

/*
 * INCLUDE FILES
 ****************************************************************************************
 */
#include "co_int.h"
#include "co_bool.h"
#include "rwnx_config.h"
#include "co_list.h"
#include "txl_cntrl.h"
#include "tx_swdesc.h"
#include "txl_agg.h"
#include "txl_he.h"
#include "co_utils.h"
#if NX_UMAC_PRESENT
#include "me_mic.h"
#include "txu_cntrl.h"
#include "rc.h"
#endif


/*
 * CONSTANTS
 ****************************************************************************************
 */
#define TX_BUFFER_MTU 1536

#define TX_ADD_BUFFER 64

#define TX_MPDU_LEN_MAX  (TX_BUFFER_MTU + TX_ADD_BUFFER)

#define TX_BUFFER_MAX (sizeof_b(struct txl_buffer_tag) + TX_MPDU_LEN_MAX)

#define TX_BUFFER_POOL_MAX (AC_MAX * RW_USER_MAX + NX_BEACONING)

#if NX_AMPDU_TX
#if defined(CFG_VIRTEX7) && !defined(CFG_FHOST)
#define TX_MIN_DOWNLOAD_CNT   8
#else
#if NX_AMSDU_TX
#define TX_MIN_DOWNLOAD_CNT   4
#else
#define TX_MIN_DOWNLOAD_CNT   3
#endif // NX_AMSDU_TX
#endif // defined(CFG_VIRTEX7)
#define TX_BUFFER_POOL_SIZE     ((TX_MIN_DOWNLOAD_CNT * TX_BUFFER_MAX) / 4)
#else
#define TX_MIN_DOWNLOAD_CNT   2
#define TX_BUFFER_POOL_SIZE     ((TX_MIN_DOWNLOAD_CNT * TX_BUFFER_MAX) / 4)
#endif // NX_AMPDU_TX

#define TX_BUFFER_NULL          0xFFFFFFFF

#if NX_UMAC_PRESENT
#define TX_BUFFER_PADDING_MAX   0
#else
#define TX_BUFFER_PADDING_MAX   3
#endif

#define TX_BUFFER_PADDING_MASK  0x00000003

#define TX_BUFFER_PADDING_OFT   0

#define TX_BUFFER_MIN_SIZE      256

#define TX_BUFFER_MIN_AMPDU_DWNLD   500

#if NX_UMAC_PRESENT && NX_AMSDU_TX
#define TX_DMA_DESC_MAX  NX_TX_PAYLOAD_MAX
#elif NX_MFP
#define TX_DMA_DESC_MAX  2
#else
#define TX_DMA_DESC_MAX  1
#endif

#if NX_FULLY_HOSTED

#define TX_PBD_CNT            3
#endif

enum
{
    BUF_FRONTIER = CO_BIT(0),
    BUF_SPLIT = CO_BIT(1),
    BUF_ALLOC_OK = CO_BIT(2),
    BUF_INT_MSDU = CO_BIT(3),
    #if NX_MAC_HE
    BUF_SINGLETON_READY = CO_BIT(4),
    #endif
};

/*
 * TYPE and STRUCT DEFINITIONS
 ****************************************************************************************
 */
struct txl_buffer_hw_desc_tag
{
    struct dma_desc dma_desc;
    struct tx_pbd   pbd;
};

struct txl_buffer_list_tag
{
    struct txl_buffer_tag *first;
    struct txl_buffer_tag *last;
};

struct txl_buffer_idx_tag
{
    uint32_t used_area;
    uint32_t free;
    uint32_t free_size;
    uint32_t last;
    uint32_t next_needed;
    uint32_t buf_size;
    uint32_t *pool;
    struct txl_buffer_hw_desc_tag *desc;
    uint8_t count;
};


struct txl_buffer_env_tag
{
    struct txl_buffer_idx_tag buf_idx[NX_TXQ_CNT][RW_USER_MAX];
    struct txl_buffer_list_tag list[NX_TXQ_CNT];
};

struct txl_buffer_tag
{
    #if !NX_FULLY_HOSTED
    uint32_t length;
    struct txl_buffer_tag *next;
    struct txdesc *txdesc;
    struct dma_desc dma_desc[TX_DMA_DESC_MAX];
    struct dma_desc dma_desc_pat;
    #if (RW_BFMER_EN)
    struct dma_desc dma_desc_bfr;
    #endif //(RW_BFMER_EN)
    struct tx_pbd tbd;
    uint8_t user_idx;
    #endif 

    uint32_t flags;
    struct txl_buffer_control buffer_control;
    #if NX_FULLY_HOSTED
    struct tx_pbd pbd[TX_PBD_CNT];
    struct tx_pbd pbd_tail;
    uint8_t sec_tail[MIC_LEN];
    uint8_t headers[MAC_LONG_QOS_MAC_HDR_LEN + LLC_802_2_HDR_LEN + WPI_IV_LEN - LLC_ETHER_HDR_LEN];
    #endif
    uint32_t payload[];
};


/*
 * GLOBAL VARIABLES
 ****************************************************************************************
 */
extern uint32_t txl_buffer_pool[TX_BUFFER_POOL_MAX][TX_BUFFER_POOL_SIZE];

extern struct txl_buffer_hw_desc_tag txl_buffer_hw_desc[TX_BUFFER_POOL_MAX];

extern struct txl_buffer_env_tag txl_buffer_env;

#if NX_UMAC_PRESENT
extern struct txl_buffer_control txl_buffer_control_desc[NX_REMOTE_STA_MAX];
extern struct txl_buffer_control txl_buffer_control_desc_bcmc[NX_VIRT_DEV_MAX];
#endif

/*
 * FUNCTION PROTOTYPES
 ****************************************************************************************
 */


#if !NX_FULLY_HOSTED

__INLINE void txl_buffer_push(uint8_t access_category, struct txl_buffer_tag *buf)
{
    struct txl_buffer_list_tag *list = &txl_buffer_env.list[access_category];

    // check if list is empty
    if (list->first == NULL)
    {
        // list empty => pushed element is also head
        list->first = buf;
    }
    else
    {
        // list not empty => update next of last
        list->last->next = buf;
    }

    // add element at the end of the list
    list->last = buf;
    buf->next = NULL;
}

__INLINE struct txl_buffer_tag *txl_buffer_pop(uint8_t access_category)
{
    struct txl_buffer_list_tag *list = &txl_buffer_env.list[access_category];
    struct txl_buffer_tag *buf;

    // check if list is empty
    buf = list->first;
    if (buf != NULL)
    {
        // The list isn't empty : extract the first element
        list->first = list->first->next;
    }

    return buf;
}

__INLINE struct txl_buffer_tag *txl_buffer_pick(uint8_t access_category)
{
    struct txl_buffer_list_tag *list = &txl_buffer_env.list[access_category];

    return list->first;
}

__INLINE bool txl_buffer_list_empty(uint8_t access_category)
{
    struct txl_buffer_list_tag *list = &txl_buffer_env.list[access_category];

    return (list->first == NULL);
}
#endif 


__INLINE struct txl_buffer_tag *txl_buffer_get(struct txdesc *txdesc)
{
    #if NX_AMSDU_TX
    struct txl_buffer_tag *buffer = txdesc->lmac.buffer[0];
    #else
    struct txl_buffer_tag *buffer = txdesc->lmac.buffer;
    #endif
    return (buffer);
}


__INLINE struct txl_buffer_control *txl_buffer_control_get(struct txdesc *txdesc)
{
    struct txl_buffer_tag *buffer = txl_buffer_get(txdesc);
    return (&buffer->buffer_control);
}

__INLINE void *txl_buffer_payload_get(struct txdesc *txdesc)
{
    struct txl_buffer_tag *buffer = txl_buffer_get(txdesc);
    return ((void *)buffer->payload);
}

__INLINE uint32_t txl_buffer_machdr_get(struct txdesc *txdesc)
{
    struct tx_hd *thd = &txdesc->lmac.hw_desc->thd;
    struct tx_pbd *pbd;

    // A buffer shall be available
    ASSERT_ERR(txl_buffer_get(txdesc) != NULL);

    // Check if the frame buffer is at least partly pointed by the THD
    if (thd->datastartptr)
        return (thd->datastartptr);

    // Sanity check - If the MAC header is not pointed by the THD, a PBD shall be present
    ASSERT_ERR(thd->first_pbd_ptr);
    pbd = HW2CPU(thd->first_pbd_ptr);

    return (pbd->datastartptr);
}

#if NX_UMAC_PRESENT

__INLINE void txl_buffer_control_trial(struct txdesc *txdesc, struct txl_buffer_tag *buf)
{
    // Set ratecntrlinfo for trial rate transmission
    if (txdesc->host.flags & TXU_CNTRL_RC_TRIAL)
    {
        struct txl_buffer_control *buf_ctrl_src = txdesc->umac.buf_control;
        struct txl_buffer_control *buf_ctrl_dest = &buf->buffer_control;
        // get RC station statistics
        struct rc_sta_stats *rc_ss = rc_get_sta_stats(txdesc->host.staid);

        PROF_RC_SET_TRIAL_BUFFER_SET();

        // Move step 0 to step 1
        buf_ctrl_dest->policy_tbl.ratecntrlinfo[1] = buf_ctrl_src->policy_tbl.ratecntrlinfo[0];
        #if NX_MAC_HE
        buf_ctrl_dest->policy_tbl.powercntrlinfo[1] = buf_ctrl_src->policy_tbl.powercntrlinfo[0];
        #endif

        // Replace step 0 by trial rate
        buf_ctrl_dest->policy_tbl.ratecntrlinfo[0] = rc_ss->trial_rate;
        #if NX_MAC_HE
        if (txl_he_is_he_su(rc_ss->trial_rate))
        {
            txl_he_ltf_type_set(rc_ss->trial_rate,
                                &buf_ctrl_dest->policy_tbl.powercntrlinfo[0]);
        }
        #endif

        // Disable the STBC
        if ((buf_ctrl_src->tx_flags & TX_SWDESC_UMAC_TRIAL_STBC_BIT) == 0)
        {
            buf_ctrl_dest->policy_tbl.phycntrlinfo1 &= ~STBC_PT_MASK;
        }

        PROF_RC_SET_TRIAL_BUFFER_CLR();
    }
}

__INLINE void txl_buffer_control_copy(struct txdesc *txdesc,
                                      struct txl_buffer_tag *buf)
{
    uint32_t *dst = (uint32_t *)&buf->buffer_control;
    uint32_t *src = (uint32_t *)txdesc->umac.buf_control;
    unsigned int i;

    // Copy the policy table
    for (i = 0; i < (sizeof_b(struct txl_buffer_control)/sizeof_b(uint32_t)); i++)
    {
        *dst++ = *src++;
    }

    // Set the trial rate if a trial tx is requested
    txl_buffer_control_trial(txdesc, buf);

}
#endif


__INLINE int txl_buffer_padding(struct txdesc *txdesc)
{
    #if NX_UMAC_PRESENT
    return (0);
    #else
    return (txdesc->host.padding);
    #endif
}

#if NX_AMSDU_TX

__INLINE bool txl_buffer_is_amsdu_multi_buf(struct txdesc *txdesc)
{
    return (is_mpdu_split(txdesc) && (txdesc->lmac.hw_desc->thd.frmlen > TX_MPDU_LEN_MAX));
}
__INLINE bool txl_buffer_is_amsdu_single_buf(struct txdesc *txdesc)
{
    return (is_mpdu_split(txdesc) && (txdesc->lmac.hw_desc->thd.frmlen <= TX_MPDU_LEN_MAX));
}
#endif

#if NX_MAC_HE

__INLINE void txl_buffer_remove_htc(struct tx_hd *thd)
{
    #if NX_UMAC_PRESENT
    uint32_t mac_hdr_addr = thd->datastartptr;
    uint16_t framectl = co_read16p(mac_hdr_addr);

    // Check if the order bit is set in the MAC Header, indicating if the +HTC is present
    // or not
    if ((framectl & MAC_FCTRL_ORDER) == 0)
        return;

    framectl &= ~MAC_FCTRL_ORDER;
    co_write16p(mac_hdr_addr, framectl);

    thd->frmlen -= MAC_HTC_LEN;
    thd->dataendptr -= MAC_HTC_LEN;
    #endif
}

__INLINE void txl_buffer_add_htc(struct tx_hd *thd)
{
    #if NX_UMAC_PRESENT
    uint32_t mac_hdr_addr = thd->datastartptr;
    uint16_t framectl;

    if (!mac_hdr_addr || ((framectl = co_read16p(mac_hdr_addr)) & MAC_FCTRL_ORDER))
        return;

    framectl |= MAC_FCTRL_ORDER;
    co_write16p(mac_hdr_addr, framectl);

    thd->frmlen += MAC_HTC_LEN;
    thd->dataendptr += MAC_HTC_LEN;
    #endif
}

__INLINE bool txl_buffer_update_htc(struct tx_hd *thd, uint32_t htc)
{
    #if NX_UMAC_PRESENT
    // Ensure we have a buffer already allocated
    if (!thd->datastartptr)
        return false;

    co_write32p(thd->dataendptr - MAC_HTC_LEN + 1, htc);
    return true;
    #else
    return false;
    #endif
}


#endif

#if !NX_FULLY_HOSTED

__INLINE void txl_buffer_update_thd(struct txdesc *txdesc,
                                    uint8_t access_category)
{
    struct tx_hd *thd = &txdesc->lmac.hw_desc->thd;
    #if NX_AMSDU_TX
    struct txl_list *txlist = &txl_cntrl_env.txlist[access_category];
    #endif
    struct txl_buffer_tag *buffer = txl_buffer_get(txdesc);
    struct txl_buffer_idx_tag *idx = &txl_buffer_env.buf_idx[access_category][buffer->user_idx];
    uint32_t pool_size = TX_BUFFER_POOL_SIZE * sizeof_b(uint32_t);
    uint32_t pool_start = CPU2HW(idx->pool);
    uint32_t pool_end = pool_start + pool_size - 1;
    uint32_t start = CPU2HW(buffer->payload) + txl_buffer_padding(txdesc);
    #if NX_UMAC_PRESENT
    uint16_t add_len;
    uint32_t payl = start + txdesc->umac.machead_len;
    #else
    uint32_t payl = start;
    #endif
    #if NX_AMSDU_TX
    uint32_t pkt_len = txdesc->host.packet_len[0];
    #else
    uint32_t pkt_len = txdesc->host.packet_len;
    #endif
    uint32_t end;
    struct tx_pbd *pbd = &buffer->tbd;
    struct tx_pbd *add_pbd = NULL;
    struct tx_pbd *last_pbd = pbd;

    #if NX_UMAC_PRESENT
    #if NX_AMSDU_TX
    if (txl_buffer_is_amsdu_single_buf(txdesc))
        pkt_len = txdesc->lmac.hw_desc->thd.frmlen - MAC_FCS_LEN;
    else
    #endif
    {
        add_len = txdesc->umac.head_len;
        #if NX_AMSDU_TX
        if (!is_mpdu_split(txdesc))
        #endif
            add_len += txdesc->umac.tail_len;
        pkt_len += add_len;
    }
    #endif
    end = start + pkt_len - 1;

    // By default we consider that the buffer is not split
    buffer->flags &= ~BUF_SPLIT;

    // Check if buffer padding has caused a buffer wrap
    ASSERT_ERR(start < pool_end);

    // Check if buffer is split
    if (end > pool_end)
    {
        // Buffer is split
        end = pool_end;

        // We use the PBD of the pool to handle the split
        add_pbd = &idx->desc->pbd;
        add_pbd->datastartptr = pool_start;
        add_pbd->dataendptr = pool_start + pkt_len - (end - start) - 2;

        last_pbd = add_pbd;

        // Buffer is split
        buffer->flags |= BUF_SPLIT;
    }

    // Set start and end pointers to the beginning and end of the frame
    #if NX_UMAC_PRESENT
    if (txdesc->umac.machead_len)
    {
        thd->datastartptr = start;
        thd->dataendptr = start + txdesc->umac.machead_len - 1;
    }
    #endif
    pbd->datastartptr = payl;
    pbd->dataendptr = end;
    pbd->next = CPU2HW(add_pbd);
    pbd->bufctrlinfo = 0;

    thd->first_pbd_ptr = CPU2HW(pbd);
    last_pbd->bufctrlinfo = 0;
    #if NX_AMPDU_TX
    if ((buffer->flags & BUF_FRONTIER) || is_mpdu_last(txdesc) || !is_mpdu_agg(txdesc))
    {
        if (!(buffer->flags & BUF_FRONTIER))
        {
            #if NX_AMSDU_TX
            if (!is_mpdu_split(txdesc))
            {
            #endif
                buffer->flags |= BUF_FRONTIER;
                idx->count++;
            #if NX_AMSDU_TX
            }
            #endif
            // Set WhichDescriptor field
            thd->macctrlinfo2 |= INTERRUPT_EN_TX;
        }
        else
        {
            #if NX_AMSDU_TX
            if (txl_buffer_is_amsdu_multi_buf(txdesc))
            {
                // Enable interrupt on the last PBD
                last_pbd->bufctrlinfo = TBD_INTERRUPT_EN;

                // For singleton we need to enable the IRQ on packet completion
                if (!is_mpdu_agg(txdesc))
                    thd->macctrlinfo2 |= INTERRUPT_EN_TX;
            }
            else
            #endif
            {
                // Set WhichDescriptor field
                thd->macctrlinfo2 |= INTERRUPT_EN_TX;
            }
        }
    }
    #else
    // Set WhichDescriptor field
    thd->macctrlinfo2 = WHICHDESC_UNFRAGMENTED_MSDU | INTERRUPT_EN_TX;
    #endif
    last_pbd->next = 0;

    #if NX_AMSDU_TX
    // Store the new value of last PBD
    txlist->last_pbd[buffer->user_idx] = last_pbd;
    #endif
}

#if NX_AMSDU_TX

__INLINE void txl_buffer_update_tbd(struct txdesc *txdesc,
                                    uint8_t access_category,
                                    uint8_t pkt_idx)
{
    struct txl_list *txlist = &txl_cntrl_env.txlist[access_category];
    struct txl_buffer_tag *buffer = txdesc->lmac.buffer[pkt_idx];
    struct tx_pbd *tbd = &buffer->tbd;
    uint32_t pkt_len = txdesc->host.packet_len[pkt_idx];
    struct txl_buffer_idx_tag *idx = &txl_buffer_env.buf_idx[access_category][buffer->user_idx];
    uint32_t pool_size = TX_BUFFER_POOL_SIZE * sizeof_b(uint32_t);
    uint32_t pool_start = CPU2HW(idx->pool);
    uint32_t pool_end = pool_start + pool_size - 1;
    uint32_t start = CPU2HW(buffer->payload);
    uint32_t end = start + pkt_len - 1;
    struct tx_pbd *pbd = NULL;
    struct tx_pbd *last = tbd;

    #if NX_UMAC_PRESENT
    if ((pkt_idx + 1) == txdesc->host.packet_cnt) {
       pkt_len += txdesc->umac.tail_len;
       end += txdesc->umac.tail_len;
    }
    #endif

    // By default we consider that the buffer is not split
    buffer->flags &= ~BUF_SPLIT;

    // Check if buffer padding has caused a buffer wrap
    if (start > pool_end)
    {
        start -= pool_size;
        end -= pool_size;
    }
    else
    {
        // Check if buffer is split
        if (end > pool_end)
        {
            // Buffer is split
            end = pool_end;

            // We use the PBD of the pool to handle the split
            pbd = &idx->desc->pbd;
            pbd->datastartptr = pool_start;
            pbd->dataendptr = pool_start + pkt_len - (end - start) - 2;

            last = pbd;

            // Buffer is split
            buffer->flags |= BUF_SPLIT;
        }
    }

    // Set start and end pointers to the beginning and end of the frame
    tbd->datastartptr = start;
    tbd->dataendptr = end;
    tbd->next = CPU2HW(pbd);
    tbd->bufctrlinfo = 0;

    if ((buffer->flags & BUF_FRONTIER) ||
        (is_mpdu_last(txdesc) && ((pkt_idx + 1) == txdesc->host.packet_cnt)))
        // Enable interrupt on the last PBD
        last->bufctrlinfo = TBD_INTERRUPT_EN;
    else
        last->bufctrlinfo = 0;

    // Chain the descriptor(s) to the previous one(s)
    ASSERT_ERR(txlist->last_pbd[buffer->user_idx] != NULL);
    txlist->last_pbd[buffer->user_idx]->next = CPU2HW(tbd);

    // Store the new value of last PBD
    last->next = 0;
    txlist->last_pbd[buffer->user_idx] = last;
}
#endif


#if NX_UMAC_PRESENT

__INLINE void txl_buffer_mic_compute(struct txdesc *txdesc,
                                     uint32_t *mic_key,
                                     uint32_t start,
                                     uint32_t len,
                                     uint8_t access_category)
{
    struct hostdesc *host = &txdesc->host;
    struct mic_calc mic;
    struct txl_buffer_tag *buffer = txl_buffer_get(txdesc);
    struct txl_buffer_idx_tag *idx = &txl_buffer_env.buf_idx[access_category][buffer->user_idx];
    uint32_t pool_size = TX_BUFFER_POOL_SIZE * sizeof_b(uint32_t);
    uint32_t pool_start = CPU2HW(idx->pool);
    uint32_t pool_end = pool_start + pool_size - 1;
    uint32_t end = start + len - 1;
    uint32_t clen = len;
    uint32_t mic_start = end + 1, mic_end;
    uint32_t mic_addr = CPU2HW(&mic.mic_key_least);

    // Initialize MIC computation
    me_mic_init(&mic, mic_key, &host->eth_dest_addr, &host->eth_src_addr, host->tid);

    // Check if buffer is split
    if (end > pool_end)
    {
        clen = pool_end - start + 1;

        // Buffer is split
        me_mic_calc(&mic, start, clen);

        // Compute the parameters of the next computation
        clen = len - clen;
        start = pool_start;
    }

    me_mic_calc(&mic, start, clen);

    // End the MIC computation
    me_mic_end(&mic);

    // Copy the MIC in the packet
    if (mic_start > pool_end)
        mic_start -= pool_size;
    mic_end = mic_start + 7;
    clen = 8;
    if (mic_end > pool_end)
    {
        clen = pool_end - mic_start + 1;

        // Copy the first part of the MIC in the TX buffer
        co_copy8p(mic_start, mic_addr, clen);

        // Compute the parameters of the next computation
        mic_addr += clen;
        clen = 8 - clen;
        mic_start = pool_start;
    }

    // Copy the remaining part of the MIC in the TX buffer
    co_copy8p(mic_start, mic_addr, clen);
}
#endif //NX_UMAC_PRESENT

void txl_buffer_reinit(void);

void txl_buffer_reset(uint8_t access_category);

#if NX_AMSDU_TX
struct txl_buffer_tag *txl_buffer_alloc(struct txdesc *txdesc, uint8_t access_category,
                                        uint8_t user_idx, uint8_t pkt_idx);
#else
struct txl_buffer_tag *txl_buffer_alloc(struct txdesc *txdesc, uint8_t access_category,
                                        uint8_t user_idx);
#endif

bool txl_buffer_free(struct txl_buffer_tag *buf, uint8_t access_category);

void txl_buffer_free_all(struct txdesc *txdesc, uint8_t access_category);

__INLINE uint32_t txl_buffer_used(uint8_t access_category, uint8_t user_idx)
{
    return txl_buffer_env.buf_idx[access_category][user_idx].used_area;
}

__INLINE uint8_t txl_buffer_count(uint8_t access_category, uint8_t user_idx)
{
    struct txl_buffer_idx_tag *idx = &txl_buffer_env.buf_idx[access_category][user_idx];

    return(idx->count);
}
#endif 


void txl_buffer_init(void);




#endif 

---