/*
*
* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef __STACKX_PBUF_H__
#define __STACKX_PBUF_H__

#include "cc.h"

#include "common_mem_base_type.h"
#include "stackx_pbuf_comm.h"
#include "common_mem_mbuf.h"

#ifdef HAL_LIB
#else
#include "common_pal_bitwide_adjust.h"
#endif

#ifdef __cplusplus
/* *INDENT-OFF* */
extern "C" {
/* *INDENT-ON* */
#endif

extern u16_t g_offSetArry[SPL_PBUF_MAX_LAYER];

/** indicates this pbuf is loop buf .*/
#define PBUF_FLAG_LOOPBUF 0x08U

#define PBUF_SET_LOOP_FLAG(buf) ((buf)->flags |= PBUF_FLAG_LOOPBUF)
#define PBUF_IS_LOOP_BUF(buf) ((buf)->flags & PBUF_FLAG_LOOPBUF)

/*Add 1 parameter, the last one, indicating which dpdk_malloc
 *should be allocated from the pool; non-PBUF_ALLOC type regardless of this parameter*/
struct spl_pbuf *spl_pbuf_alloc_hugepage(spl_pbuf_layer l, u16_t length,
                                         spl_pbuf_type type,
                                         u16_t thread_index, void *net_conn);
struct pbuf *spl_convert_spl_pbuf_to_pbuf(struct spl_pbuf *p_from);
err_t
splpbuf_to_pbuf_transport_copy(struct pbuf *p_to, struct spl_pbuf *p_from);

err_t pbuf_to_splpbuf_copy(struct spl_pbuf *p_to, struct pbuf *p_from);
err_t splpbuf_to_pbuf_copy(struct pbuf *p_to, struct spl_pbuf *p_from);
spl_pbuf_layer get_pbuf_layer_from_pbuf_payload(struct pbuf *buf);
void print_pbuf_payload_info(struct pbuf *buf, bool send);

static inline u8_t
spl_pbuf_header(struct spl_pbuf *p, s16_t header_size_increment)
{
    u8_t pbuf_ret;
    /* header max len is tcp len+ ip len:  0xf*4+PBUF_IP_HLEN */
    if (unlikely
        (((header_size_increment) < 0 && (-(header_size_increment)) > p->len)
         || (header_size_increment > 0
             && (header_size_increment) >= (0xf * 4 + SPL_PBUF_IP_HLEN))))
    {
        pbuf_ret = 1;
    }
    else
    {
        p->payload_a = p->payload_a - (header_size_increment);
        p->len += (header_size_increment);
        p->tot_len += (header_size_increment);
        pbuf_ret = 0;
    }
    return pbuf_ret;
}

void spl_pbuf_realloc(struct spl_pbuf *p, u32_t size);

void spl_pbuf_cat(struct spl_pbuf *head, struct spl_pbuf *tail);
void spl_pbuf_free(struct spl_pbuf *p);

#define pbuf_free_safe(x)\
{\
    spl_pbuf_free((x));\
    (x) = NULL;\
}

/**
 * Count number of pbufs in a chain
 *
 * @param p first pbuf of chain
 * @return the number of pbufs in a chain
 */
static inline u16_t spl_pbuf_clen(struct spl_pbuf *p)
{
    u16_t len = 0;
    while (p != NULL)
    {
        ++len;
        p = (struct spl_pbuf *) ADDR_SHTOL(p->next_a);
    }
    return len;
}

static inline u16_t mbuf_count(struct spl_pbuf *p)
{
    u16_t count = 0;
    struct spl_pbuf *buf = p;
    struct common_mem_mbuf *mbuf;
    while (buf)
    {
        mbuf =
            (struct common_mem_mbuf *) ((char *) buf -
                                        sizeof(struct common_mem_mbuf));
        while (mbuf)
        {
            count++;
#ifdef HAL_LIB
#else
            mbuf = mbuf->next;
#endif
        }
        buf = (struct spl_pbuf *) ADDR_SHTOL(buf->next_a);      //buf->next;
    }
    return count;
}

static inline u16_t mbuf_count_in_one_pbuf(struct spl_pbuf *p)
{

    u16_t cnt = 0;
    struct common_mem_mbuf *mbuf;
    if (NULL == p)
    {
        NSPOL_LOGERR("Invalid param : p(null) !");
        return 0;
    }

    mbuf =
        (struct common_mem_mbuf *) ((char *) p -
                                    sizeof(struct common_mem_mbuf));

    /* no need to check mbuf itself */
#ifdef HAL_LIB
#else
    if (!mbuf->next)
#endif
        return 1;

    while (mbuf)
    {
        ++cnt;
#ifdef HAL_LIB
#else
        mbuf = mbuf->next;
#endif
    }

    return cnt;
}

inline int pbuf_internal_copy(struct spl_pbuf *dst, struct spl_pbuf *src);

#ifdef __cplusplus
/* *INDENT-OFF* */
}
/* *INDENT-ON* */
#endif

#endif /* __STACKX_PBUF_H__ */