/*
 * Copyright (c) 2012-2013 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.
 */

/**
 * @file ol_txrx_encap.c
 * @brief Provide functions to encap/decap on txrx frames.
 * @details
 *  This file contains functions for data frame encap/decap:
 *  ol_tx_encap: encap outgoing data frames.
 *  ol_rx_decap: decap incoming data frames.
 */
#ifdef QCA_SUPPORT_SW_TXRX_ENCAP

#include <adf_nbuf.h>         /* adf_nbuf_t, etc. */
#include <ieee80211_common.h>         /* ieee80211_frame */
#include <net.h>               /* struct llc,struct struct ether_header, etc. */
#include <ol_txrx_internal.h> /* TXRX_ASSERT1 */
#include <ol_txrx_types.h>    /* struct ol_txrx_vdev_t,struct ol_txrx_pdev_t,etc. */
#include <ol_txrx_encap.h>    /* struct ol_rx_decap_info_t*/

#define OL_TX_COPY_NATIVE_WIFI_HEADER(wh, msdu, hdsize, localbuf) \
    do { \
        wh = (struct ieee80211_frame*)adf_nbuf_data(msdu); \
        if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) { \
            hdsize = sizeof(struct ieee80211_frame_addr4); \
        } else { \
            hdsize = sizeof(struct ieee80211_frame); \
        } \
        if ( adf_nbuf_len(msdu) < hdsize) { \
            return A_ERROR; \
        } \
        adf_os_mem_copy(localbuf, wh, hdsize); \
        wh = (struct ieee80211_frame*)localbuf; \
    } while (0);

static inline A_STATUS
ol_tx_copy_native_wifi_header(
    adf_nbuf_t msdu,
    u_int8_t *hdsize,
    u_int8_t *localbuf)
{
    struct ieee80211_frame *wh = (struct ieee80211_frame*)adf_nbuf_data(msdu);
    if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
        *hdsize = sizeof(struct ieee80211_frame_addr4);
    } else {
        *hdsize = sizeof(struct ieee80211_frame);
    }
    if (adf_nbuf_len(msdu) < *hdsize) {
        return A_ERROR;
    }
    adf_os_mem_copy(localbuf, wh, *hdsize);
    return A_OK;
}

static inline A_STATUS
ol_tx_encap_from_native_wifi (
    struct ol_txrx_vdev_t *vdev,
    struct ol_tx_desc_t *tx_desc,
    adf_nbuf_t msdu,
    struct ol_txrx_msdu_info_t *tx_msdu_info
)
{
    u_int8_t localbuf[sizeof(struct ieee80211_qosframe_htc_addr4)];
    struct ieee80211_frame *wh;
    u_int8_t hdsize, new_hdsize;
    struct ieee80211_qoscntl *qos_cntl;
    struct ol_txrx_peer_t *peer;

    if (tx_msdu_info->htt.info.frame_type != htt_frm_type_data) {
        return A_OK;
    }
    peer = tx_msdu_info->peer;
    /*
     * for unicast,the peer should not be NULL.
     * for multicast, the peer is AP.
     */
    if (tx_msdu_info->htt.info.is_unicast
        && peer->qos_capable)
    {
        if (A_OK != ol_tx_copy_native_wifi_header(msdu, &hdsize, localbuf))
            return A_ERROR;
        wh = (struct ieee80211_frame*)localbuf;

        /*add qos cntl*/
        qos_cntl = (struct ieee80211_qoscntl*)(localbuf + hdsize);
        qos_cntl->i_qos[0] = tx_msdu_info->htt.info.ext_tid & IEEE80211_QOS_TID;

#if 0
        if ( wmmParam[ac].wmep_noackPolicy ) {
            qos_cntl->i_qos[0]|= 1 << IEEE80211_QOS_ACKPOLICY_S;
        }
#endif

        qos_cntl->i_qos[1] = 0;
        wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_QOS;
        /* count for qos field */
        new_hdsize = hdsize + sizeof(struct ieee80211_qosframe) - sizeof(struct ieee80211_frame);

        /*add ht control field if needed */

        /* copy new hd to bd */
        adf_os_mem_copy(
                       (void*)htt_tx_desc_mpdu_header(tx_desc->htt_tx_desc, new_hdsize),
                       localbuf,
                       new_hdsize);
        adf_nbuf_pull_head(msdu, hdsize);
        tx_msdu_info->htt.info.l3_hdr_offset = new_hdsize;
        tx_desc->orig_l2_hdr_bytes = hdsize;
    }
    /* Set Protected Frame bit in MAC header */
    if (vdev->pdev->sw_pf_proc_enable && tx_msdu_info->htt.action.do_encrypt) {
        if (tx_desc->orig_l2_hdr_bytes) {
            wh = (struct ieee80211_frame*)htt_tx_desc_mpdu_header(tx_desc->htt_tx_desc,
                tx_msdu_info->htt.info.l3_hdr_offset);
        } else {
            if (A_OK != ol_tx_copy_native_wifi_header(msdu, &hdsize, localbuf))
                return A_ERROR;
            wh = (struct ieee80211_frame*)htt_tx_desc_mpdu_header(tx_desc->htt_tx_desc, hdsize);
            adf_os_mem_copy((void*)wh, localbuf, hdsize);
            adf_nbuf_pull_head(msdu, hdsize);
            tx_msdu_info->htt.info.l3_hdr_offset = hdsize;
            tx_desc->orig_l2_hdr_bytes = hdsize;
        }
        wh->i_fc[1] |= IEEE80211_FC1_WEP;
    }
    return A_OK;
}

static inline A_STATUS
ol_tx_encap_from_8023 (
    struct ol_txrx_vdev_t *vdev,
    struct ol_tx_desc_t *tx_desc,
    adf_nbuf_t msdu,
    struct ol_txrx_msdu_info_t *tx_msdu_info
)
{
    u_int8_t localbuf[ sizeof(struct ieee80211_qosframe_htc_addr4) \
                       + sizeof(struct llc_snap_hdr_t)];
    struct llc_snap_hdr_t *llc_hdr;
    struct ethernet_hdr_t *eth_hdr;
    struct ieee80211_frame *wh;
    u_int8_t hdsize, new_l2_hdsize, new_hdsize;
    struct ieee80211_qoscntl *qos_cntl;
    const u_int8_t ethernet_II_llc_snap_header_prefix[] = \
                                { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
    struct ol_txrx_peer_t *peer;
    u_int16_t ether_type;

    if (tx_msdu_info->htt.info.frame_type != htt_frm_type_data)
        return A_OK;

    /*
     * for unicast,the peer should not be NULL.
     * for multicast, the peer is AP.
     */
    peer = tx_msdu_info->peer;

    eth_hdr = (struct ethernet_hdr_t *)adf_nbuf_data(msdu);
    hdsize = sizeof(struct ethernet_hdr_t);
    wh = (struct ieee80211_frame *)localbuf;
    wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;
    *(u_int16_t *)wh->i_dur = 0;
    new_hdsize = 0;

    switch (vdev->opmode) {
    case wlan_op_mode_ap:
        /* DA , BSSID , SA*/
        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr,
                        IEEE80211_ADDR_LEN);
        adf_os_mem_copy(wh->i_addr2, &vdev->mac_addr.raw,
                        IEEE80211_ADDR_LEN);
        adf_os_mem_copy(wh->i_addr3, eth_hdr->src_addr,
                        IEEE80211_ADDR_LEN);
        wh->i_fc[1] = IEEE80211_FC1_DIR_FROMDS;
        new_hdsize = sizeof(struct ieee80211_frame);
        break;
    case wlan_op_mode_ibss:
        /* DA, SA, BSSID */
        adf_os_mem_copy(wh->i_addr1, eth_hdr->dest_addr,
                        IEEE80211_ADDR_LEN);
        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr,
                        IEEE80211_ADDR_LEN);
         /* need to check the bssid behaviour for IBSS vdev */
        adf_os_mem_copy(wh->i_addr3, &vdev->mac_addr.raw,
                        IEEE80211_ADDR_LEN);
        wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
        new_hdsize = sizeof(struct ieee80211_frame);
        break;
    case wlan_op_mode_sta:
        /* BSSID, SA , DA*/
        adf_os_mem_copy(wh->i_addr1, &peer->mac_addr.raw,
                        IEEE80211_ADDR_LEN);
        adf_os_mem_copy(wh->i_addr2, eth_hdr->src_addr,
                        IEEE80211_ADDR_LEN);
        adf_os_mem_copy(wh->i_addr3, eth_hdr->dest_addr,
                        IEEE80211_ADDR_LEN);
        wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
        new_hdsize = sizeof(struct ieee80211_frame);
        break;
    case wlan_op_mode_monitor:
    default:
        return A_ERROR;
    }
    /*add qos cntl*/
    if (tx_msdu_info->htt.info.is_unicast && peer->qos_capable ) {
        qos_cntl = (struct ieee80211_qoscntl*)(localbuf + new_hdsize);
        qos_cntl->i_qos[0] = tx_msdu_info->htt.info.ext_tid & IEEE80211_QOS_TID;
        wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_QOS;
#if 0
        if ( wmmParam[ac].wmep_noackPolicy ) {
            qos_cntl->i_qos[0]|= 1 << IEEE80211_QOS_ACKPOLICY_S;
        }
#endif
        qos_cntl->i_qos[1] = 0;
        new_hdsize += sizeof(struct ieee80211_qoscntl);

        /*add ht control field if needed */
    }
    /* Set Protected Frame bit in MAC header */
    if (vdev->pdev->sw_pf_proc_enable && tx_msdu_info->htt.action.do_encrypt) {
        wh->i_fc[1] |= IEEE80211_FC1_WEP;
    }
    new_l2_hdsize = new_hdsize;
    /* add llc snap if needed */
    if (vdev->pdev->sw_tx_llc_proc_enable) {
        llc_hdr = (struct llc_snap_hdr_t *) (localbuf + new_hdsize);
        ether_type = (eth_hdr->ethertype[0]<<8) |(eth_hdr->ethertype[1]);
        if ( ether_type >= IEEE8023_MAX_LEN ) {
            adf_os_mem_copy(llc_hdr,
                            ethernet_II_llc_snap_header_prefix,
                            sizeof(ethernet_II_llc_snap_header_prefix));
            if ( ether_type == ETHERTYPE_AARP || ether_type == ETHERTYPE_IPX) {
                llc_hdr->org_code[2] = BTEP_SNAP_ORGCODE_2;// 0xf8; bridge tunnel header
            }
            llc_hdr->ethertype[0] = eth_hdr->ethertype[0];
            llc_hdr->ethertype[1] = eth_hdr->ethertype[1];
            new_hdsize += sizeof(struct llc_snap_hdr_t);
        }
        else {
            /*llc ready, and it's in payload pdu, do we need to move to BD pdu?*/
        }
    }
    adf_os_mem_copy(
                    (void*)htt_tx_desc_mpdu_header(tx_desc->htt_tx_desc,new_l2_hdsize),
                    localbuf,
                    new_hdsize);
    adf_nbuf_pull_head(msdu,hdsize);
    tx_msdu_info->htt.info.l3_hdr_offset = new_l2_hdsize;
    tx_desc->orig_l2_hdr_bytes = hdsize;
    return A_OK;
}

A_STATUS
ol_tx_encap(
    struct ol_txrx_vdev_t *vdev,
    struct ol_tx_desc_t *tx_desc,
    adf_nbuf_t msdu,
    struct ol_txrx_msdu_info_t *msdu_info)
{
    struct ol_txrx_pdev_t *pdev = vdev->pdev;

    if (pdev->frame_format == wlan_frm_fmt_native_wifi) {
        return ol_tx_encap_from_native_wifi(vdev, tx_desc, msdu,msdu_info);
    } else if (pdev->frame_format == wlan_frm_fmt_802_3) {
        return ol_tx_encap_from_8023(vdev, tx_desc, msdu, msdu_info);
    } else {
        /* todo for other types */
        return A_ERROR;
    }
}

static inline void
ol_rx_decap_to_native_wifi(
    struct ol_txrx_vdev_t *vdev,
    adf_nbuf_t msdu,
    struct ol_rx_decap_info_t *info,
    struct ethernet_hdr_t *ethr_hdr)
{
    struct ieee80211_frame_addr4 *wh;
    u_int16_t hdsize;

    /*
     * we need to remove Qos control field and HT control.
     * MSFT: http://msdn.microsoft.com/en-us/library/windows/hardware/ff552608(v=vs.85).aspx
     */
    wh = (struct ieee80211_frame_addr4 *)info->hdr;
    if ( (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) {
        hdsize = sizeof(struct ieee80211_frame_addr4);
    }
    else {
        hdsize = sizeof(struct ieee80211_frame);
    }
    wh = (struct ieee80211_frame_addr4 *) adf_nbuf_push_head(msdu, hdsize);
    TXRX_ASSERT2(wh != NULL);
    TXRX_ASSERT2(hdsize <= info->hdr_len);
    adf_os_mem_copy ((u_int8_t *)wh, info->hdr, hdsize);

    /* amsdu subfrm handling if ethr_hdr is not NULL  */
    if (ethr_hdr != NULL) {
        switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
        case IEEE80211_FC1_DIR_NODS:
            adf_os_mem_copy(wh->i_addr1, ethr_hdr->dest_addr, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(wh->i_addr2, ethr_hdr->src_addr, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_TODS:
            adf_os_mem_copy(wh->i_addr2, ethr_hdr->src_addr, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(wh->i_addr3, ethr_hdr->dest_addr, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_FROMDS:
            adf_os_mem_copy(wh->i_addr1, ethr_hdr->dest_addr, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(wh->i_addr3, ethr_hdr->src_addr, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_DSTODS:
            adf_os_mem_copy(wh->i_addr3, ethr_hdr->dest_addr, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(wh->i_addr4, ethr_hdr->src_addr, ETHERNET_ADDR_LEN);
            break;
        }
    }
    if (IEEE80211_QOS_HAS_SEQ(wh) ) {
        if (wh->i_fc[1] & IEEE80211_FC1_ORDER) {
            wh->i_fc[1] &= ~IEEE80211_FC1_ORDER;
        }
        wh->i_fc[0] &= ~IEEE80211_FC0_SUBTYPE_QOS;
    }
}

static inline void
ol_rx_decap_to_8023 (
    struct ol_txrx_vdev_t *vdev,
    adf_nbuf_t msdu,
    struct ol_rx_decap_info_t *info,
    struct ethernet_hdr_t *ethr_hdr)
{
    struct llc_snap_hdr_t *llc_hdr;
    u_int16_t ether_type;
    u_int16_t l2_hdr_space;
    struct ieee80211_frame_addr4 *wh;
    u_int8_t local_buf[ETHERNET_HDR_LEN];
    u_int8_t *buf;

    /*
    * populate Ethernet header,
    * if ethr_hdr is null, rx frame is 802.11 format(HW ft disabled)
    * if ethr_hdr is not null, rx frame is "subfrm of amsdu".
    */
    buf = (u_int8_t *)adf_nbuf_data(msdu);
    llc_hdr = (struct llc_snap_hdr_t *)buf;
    ether_type = (llc_hdr->ethertype[0] << 8)|llc_hdr->ethertype[1];
    /* do llc remove if needed */
    l2_hdr_space = 0;
    if (IS_SNAP(llc_hdr)) {
        if (IS_BTEP(llc_hdr)) {
            /* remove llc*/
            l2_hdr_space += sizeof(struct llc_snap_hdr_t);
            llc_hdr = NULL;
        }
        else if (IS_RFC1042(llc_hdr)) {
            if ( !(ether_type == ETHERTYPE_AARP ||
                  ether_type == ETHERTYPE_IPX) ) {
                /* remove llc*/
                l2_hdr_space += sizeof(struct llc_snap_hdr_t);
                llc_hdr = NULL;
            }
        }
    }
    if (l2_hdr_space > ETHERNET_HDR_LEN) {
        buf = adf_nbuf_pull_head(msdu, l2_hdr_space - ETHERNET_HDR_LEN);
    }
    else if (l2_hdr_space <  ETHERNET_HDR_LEN) {
        buf = adf_nbuf_push_head(msdu, ETHERNET_HDR_LEN - l2_hdr_space);
    }

    /* normal msdu(non-subfrm of A-MSDU) if ethr_hdr is null */
    if (ethr_hdr == NULL) {
        /* mpdu hdr should be present in info,re-create ethr_hdr based on mpdu hdr*/
        TXRX_ASSERT2(info->hdr_len != 0);
        wh = (struct ieee80211_frame_addr4 *)info->hdr;
        ethr_hdr = (struct ethernet_hdr_t *)local_buf;
        switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
        case IEEE80211_FC1_DIR_NODS:
            adf_os_mem_copy(ethr_hdr->dest_addr, wh->i_addr1, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(ethr_hdr->src_addr, wh->i_addr2, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_TODS:
            adf_os_mem_copy(ethr_hdr->dest_addr, wh->i_addr3, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(ethr_hdr->src_addr, wh->i_addr2, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_FROMDS:
            adf_os_mem_copy(ethr_hdr->dest_addr, wh->i_addr1, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(ethr_hdr->src_addr, wh->i_addr3, ETHERNET_ADDR_LEN);
            break;
        case IEEE80211_FC1_DIR_DSTODS:
            adf_os_mem_copy(ethr_hdr->dest_addr, wh->i_addr3, ETHERNET_ADDR_LEN);
            adf_os_mem_copy(ethr_hdr->src_addr, wh->i_addr4, ETHERNET_ADDR_LEN);
            break;
        }
    }
    if (llc_hdr == NULL) {
        ethr_hdr->ethertype[0] = (ether_type >> 8) & 0xff;
        ethr_hdr->ethertype[1] = (ether_type) & 0xff;
    }
    else {
        u_int32_t pktlen = adf_nbuf_len(msdu) - sizeof(ethr_hdr->ethertype);
        TXRX_ASSERT2(pktlen <= ETHERNET_MTU);
        ether_type = (u_int16_t)pktlen;
        ether_type = adf_nbuf_len(msdu) - sizeof(struct ethernet_hdr_t);
        ethr_hdr->ethertype[0] = (ether_type >> 8) & 0xff;
        ethr_hdr->ethertype[1] = (ether_type) & 0xff;
    }
    adf_os_mem_copy(buf, ethr_hdr, ETHERNET_HDR_LEN);
}

static inline A_STATUS
ol_rx_decap_subfrm_amsdu(
    struct ol_txrx_vdev_t *vdev,
    adf_nbuf_t msdu,
    struct ol_rx_decap_info_t *info)
{
    struct ol_txrx_pdev_t *pdev = vdev->pdev;
    u_int8_t * subfrm_hdr;
    u_int8_t localbuf[ETHERNET_HDR_LEN];
    struct ethernet_hdr_t *ether_hdr = (struct ethernet_hdr_t*)localbuf;

    subfrm_hdr = (u_int8_t *)adf_nbuf_data(msdu);
    if (pdev->frame_format == wlan_frm_fmt_native_wifi) {
        /* decap to native wifi */
        adf_os_mem_copy(ether_hdr,
                        subfrm_hdr,
                        ETHERNET_HDR_LEN);
        adf_nbuf_pull_head(msdu, ETHERNET_HDR_LEN);
        ol_rx_decap_to_native_wifi(vdev,
                                msdu,
                                info,
                                ether_hdr);
    }
    else if (pdev->frame_format == wlan_frm_fmt_802_3) {
        if (pdev->sw_rx_llc_proc_enable)  {
             /* remove llc snap hdr if it's necessary according to
             * 802.11 table P-3
             */
            adf_os_mem_copy(ether_hdr,
                            subfrm_hdr,
                            ETHERNET_HDR_LEN);
            adf_nbuf_pull_head(msdu, ETHERNET_HDR_LEN);
            ol_rx_decap_to_8023(vdev,
                                msdu,
                                info,
                                ether_hdr);
        }
        else {
            /* subfrm of A-MSDU is already in 802.3 format.
             * if target HW or FW has done LLC rmv process,
             * we do nothing here.
             */
        }
    }
    else {
        /* todo for othertype*/
    }
    return A_OK;

}

static inline A_STATUS
ol_rx_decap_msdu(
    struct ol_txrx_vdev_t *vdev,
    adf_nbuf_t msdu,
    struct ol_rx_decap_info_t *info)
{
    struct ol_txrx_pdev_t *pdev = vdev->pdev;
    struct ieee80211_frame *wh;
    wh = (struct ieee80211_frame *)adf_nbuf_data(msdu);

    if (pdev->frame_format == wlan_frm_fmt_native_wifi) {
        /* Decap to native wifi because according to MSFT(
         * MSFT: http://msdn.microsoft.com/en-us/library/windows/hardware/ff552608(v=vs.85).aspx),
         * we need to remove Qos and HTC field before indicate to OS.
         */
        if (IEEE80211_QOS_HAS_SEQ(wh) ) {
            info->hdr_len = ol_txrx_ieee80211_hdrsize(wh);
            TXRX_ASSERT2(info->hdr_len <= sizeof(info->hdr));
            adf_os_mem_copy(info->hdr, /* use info->hdr as temp buf.*/
                            wh,
                            info->hdr_len);
            adf_nbuf_pull_head(msdu, info->hdr_len);
            ol_rx_decap_to_native_wifi(vdev,
                                       msdu,
                                       info, /* 802.11 hdr*/
                                       NULL); /* ethernet hdr*/
        }
    }
    else if (pdev->frame_format == wlan_frm_fmt_802_3) {
        if (pdev->sw_rx_llc_proc_enable)  {
            info->hdr_len = ol_txrx_ieee80211_hdrsize(wh);
            TXRX_ASSERT2(info->hdr_len <= sizeof(info->hdr));
            adf_os_mem_copy(info->hdr, /* use info->hdr as temp buf.*/
                            wh,
                            info->hdr_len);
            adf_nbuf_pull_head(msdu, info->hdr_len);
            /* remove llc snap hdr if it's necessary according to
             * 802.11 table P-3
             */
            ol_rx_decap_to_8023(vdev,
                                msdu,
                                info, /* 802.11 hdr*/
                                NULL); /* ethernet hdr*/
        }
        else {
            /* Subfrm of A-MSDU is already in 802.3 format.
             * And if target HW or FW has done LLC rmv process (
             * sw_rx_lc_proc_enable == 0), we do nothing here.
             */
        }
    }
    else {
         /* todo for othertype*/
    }
    return A_OK;

}

A_STATUS
ol_rx_decap(
    struct ol_txrx_vdev_t *vdev,
    struct ol_txrx_peer_t *peer,
    adf_nbuf_t msdu,
    struct ol_rx_decap_info_t *info)
{
    A_STATUS status;
    u_int8_t *mpdu_hdr;

    if (!info->is_subfrm) {
        if (info->is_msdu_cmpl_mpdu && !info->is_first_subfrm) {
            /* It's normal MSDU. */
        } else {
            /* It's a first subfrm of A-MSDU and may also be the last subfrm of A-MSDU */
            info->is_subfrm = 1;
            info->hdr_len = 0;
            if (vdev->pdev->sw_subfrm_hdr_recovery_enable) {
                /* we save the first subfrm mpdu hdr for subsequent
                 * subfrm 802.11 header recovery in certain chip(such as Riva).
                 */
                mpdu_hdr = adf_nbuf_data(msdu);
                info->hdr_len = ol_txrx_ieee80211_hdrsize(mpdu_hdr);
                TXRX_ASSERT2(info->hdr_len <= sizeof(info->hdr));
                adf_os_mem_copy(info->hdr, mpdu_hdr, info->hdr_len);
                adf_nbuf_pull_head(msdu, info->hdr_len);
            }
        }
    }

    if (info->is_subfrm && vdev->pdev->sw_subfrm_hdr_recovery_enable) {
       /*
        * This case is enabled for some HWs(such as Riva).The HW de-aggregate
        * doesn't have capability to generate 802.11 header for non-first subframe
        * of A-MSDU.That means sw needs to cache the first subfrm mpdu header
        * to generate the subsequent subfrm's 802.11 header.
        */
        TXRX_ASSERT2(info->hdr_len != 0);
        status = ol_rx_decap_subfrm_amsdu(vdev, msdu, info);
    } else {
        status = ol_rx_decap_msdu(vdev, msdu, info);
    }

    if (info->is_msdu_cmpl_mpdu) {
        info->is_subfrm =
        info->is_first_subfrm =
        info->hdr_len = 0;
    }
    return status;
}
#endif