/*
 * Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved.
 * 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.
 */


/**
 * @defgroup isis_ip ISIS_NAT
 * @{
 */

#include "sw.h"
#include "hsl.h"
#include "hsl_dev.h"
#include "hsl_port_prop.h"
#include "isis_nat.h"
#include "isis_reg.h"
#if defined(IN_NAT_HELPER)
#include "isis_nat_helper.h"
#endif


#define ISIS_HOST_ENTRY_DATA0_ADDR              0x0e48
#define ISIS_HOST_ENTRY_DATA1_ADDR              0x0e4c
#define ISIS_HOST_ENTRY_DATA2_ADDR              0x0e50
#define ISIS_HOST_ENTRY_DATA3_ADDR              0x0e54
#define ISIS_HOST_ENTRY_DATA4_ADDR              0x0e58

#define ISIS_NAT_ENTRY_FLUSH                    1
#define ISIS_NAT_ENTRY_ADD                      2
#define ISIS_NAT_ENTRY_DEL                      3
#define ISIS_NAT_ENTRY_NEXT                     4
#define ISIS_NAT_ENTRY_SEARCH                   5

#define ISIS_ENTRY_NAPT                         0
#define ISIS_ENTRY_NAT                          2
#define ISIS_ENTRY_ARP                          3

#define ISIS_PUB_ADDR_NUM                       16
#define ISIS_PUB_ADDR_TBL0_ADDR                 0x5aa00
#define ISIS_PUB_ADDR_TBL1_ADDR                 0x5aa04
#define ISIS_PUB_ADDR_EDIT0_ADDR                0x02100
#define ISIS_PUB_ADDR_EDIT1_ADDR                0x02104
#define ISIS_PUB_ADDR_OFFLOAD_ADDR              0x2a000
#define ISIS_PUB_ADDR_VALID_ADDR                0x2a040

#define ISIS_NAT_ENTRY_NUM                      32
#define ISIS_NAPT_ENTRY_NUM                     1024

#define ISIS_NAT_COUTER_ADDR                    0x2b000

#define ISIS_NAT_PORT_NUM                       255

static a_uint32_t isis_nat_snap[SW_MAX_NR_DEV] = { 0 };
extern a_uint32_t isis_nat_global_status;

static sw_error_t
_isis_nat_feature_check(a_uint32_t dev_id)
{
    sw_error_t rv;
    a_uint32_t entry = 0;

    HSL_REG_FIELD_GET(rv, dev_id, MASK_CTL, 0, DEVICE_ID,
                      (a_uint8_t *) (&entry), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (S17_DEVICE_ID == entry)
    {
        return SW_OK;
    }
    else
    {
        return SW_NOT_SUPPORTED;
    }
}

static sw_error_t
_isis_ip_prvaddr_sw_to_hw(a_uint32_t dev_id, fal_ip4_addr_t sw_addr,
                          a_uint32_t * hw_addr)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        *hw_addr = (sw_addr & 0xff) | (((sw_addr >> 16) & 0xf) << 8);
    }
    else
    {
        *hw_addr = sw_addr & 0xfff;
    }

    return SW_OK;
}

static sw_error_t
_isis_ip_prvaddr_hw_to_sw(a_uint32_t dev_id, a_uint32_t hw_addr,
                          fal_ip4_addr_t * sw_addr)
{
    sw_error_t rv;
    a_uint32_t data = 0, addr = 0;

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&addr), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        *sw_addr = ((addr & 0xff) << 8) | (((addr >> 8) & 0xfff) << 8)
                   | (hw_addr & 0xff) | (((hw_addr >> 8) & 0xf) << 16);
    }
    else
    {
        *sw_addr = (addr << 12) | (hw_addr & 0xfff);
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_counter_get(a_uint32_t dev_id, a_uint32_t cnt_id,
                      a_uint32_t counter[4])
{
    sw_error_t rv;
    a_uint32_t i, addr;

    addr = ISIS_NAT_COUTER_ADDR + (cnt_id << 4);
    for (i = 0; i < 4; i++)
    {
        HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&(counter[i])),
                              sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);

        addr += 4;
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_entry_commit(a_uint32_t dev_id, a_uint32_t entry_type, a_uint32_t op)
{
    a_uint32_t busy = 1, i = 0x100, entry = 0;
    sw_error_t rv;

    while (busy && --i)
    {
        HSL_REG_ENTRY_GET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&entry),
                          sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
        SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_BUSY, busy, entry);
        aos_udelay(500);
    }

    if (i == 0)
    {
        printk("%s BUSY\n", __FUNCTION__);
        return SW_BUSY;
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_BUSY, 1, entry);
    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_SEL, entry_type, entry);
    SW_SET_REG_BY_FIELD(HOST_ENTRY4, ENTRY_FUNC, op, entry);

    HSL_REG_ENTRY_SET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&entry),
                      sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    busy = 1;
    i = 0x100;
    while (busy && --i)
    {
        HSL_REG_ENTRY_GET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&entry),
                          sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
        SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_BUSY, busy, entry);
        aos_udelay(500);
#if 1
        if(ISIS_NAT_ENTRY_SEARCH == op &&  busy) break;
#endif
    }

    if (i == 0)
    {
        printk("%s BUSY\n", __FUNCTION__);
        return SW_BUSY;
    }

    /* hardware requirement, we should delay... */
    if ((ISIS_NAT_ENTRY_FLUSH == op) && (ISIS_ENTRY_NAPT == entry_type))
    {
        aos_mdelay(10);
    }

    /* hardware requirement, we should read again... */
    HSL_REG_ENTRY_GET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&entry),
                      sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_STAUS, busy, entry);
    if (!busy)
    {
        if (ISIS_NAT_ENTRY_NEXT == op)
        {
            return SW_NO_MORE;
        }
        else if (ISIS_NAT_ENTRY_SEARCH == op)
        {
            return SW_NOT_FOUND;
        }
        else
        {
            return SW_FAIL;
        }
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_sw_to_hw(a_uint32_t dev_id, fal_nat_entry_t * entry, a_uint32_t reg[])
{
    sw_error_t rv;
    a_uint32_t data;

    if (FAL_NAT_ENTRY_TRANS_IPADDR_INDEX & entry->flags)
    {
        return SW_BAD_PARAM;
    }

    reg[0] = entry->trans_addr;

    if (FAL_NAT_ENTRY_PORT_CHECK & entry->flags)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, PORT_EN, 1, reg[2]);
        SW_SET_REG_BY_FIELD(NAT_ENTRY1, PORT_RANGE, entry->port_range, reg[1]);
        if (ISIS_NAT_PORT_NUM < entry->port_range)
        {
            return SW_BAD_PARAM;
        }
        SW_SET_REG_BY_FIELD(NAT_ENTRY1, PORT_NUM, entry->port_num, reg[1]);
    }
    else
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, PORT_EN, 0, reg[2]);
    }

    rv = _isis_ip_prvaddr_sw_to_hw(dev_id, entry->src_addr, &data);
    SW_RTN_ON_ERROR(rv);

    SW_SET_REG_BY_FIELD(NAT_ENTRY1, PRV_IPADDR0, data, reg[1]);
    SW_SET_REG_BY_FIELD(NAT_ENTRY2, PRV_IPADDR1, (data >> 8), reg[2]);

    if (FAL_MAC_FRWRD == entry->action)
    {
        if (A_TRUE == entry->mirror_en)
        {
            SW_SET_REG_BY_FIELD(NAT_ENTRY2, ACTION, 0, reg[2]);
        }
        else
        {
            SW_SET_REG_BY_FIELD(NAT_ENTRY2, ACTION, 3, reg[2]);
        }
    }
    else if (FAL_MAC_CPY_TO_CPU == entry->action)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, ACTION, 2, reg[2]);
    }
    else if (FAL_MAC_RDT_TO_CPU == entry->action)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, ACTION, 1, reg[2]);
    }
    else
    {
        return SW_NOT_SUPPORTED;
    }

    if (A_TRUE == entry->counter_en)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, CNT_EN, 1, reg[2]);
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, CNT_IDX, entry->counter_id, reg[2]);
    }

    if (FAL_NAT_ENTRY_PROTOCOL_ANY & entry->flags)
    {
        data = 3;
    }
    else if ((FAL_NAT_ENTRY_PROTOCOL_TCP & entry->flags)
             && (FAL_NAT_ENTRY_PROTOCOL_UDP & entry->flags))
    {
        data = 2;
    }
    else if (FAL_NAT_ENTRY_PROTOCOL_TCP & entry->flags)
    {
        data = 0;
    }
    else if (FAL_NAT_ENTRY_PROTOCOL_UDP & entry->flags)
    {
        data = 1;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    SW_SET_REG_BY_FIELD(NAT_ENTRY2, PRO_TYP, data, reg[2]);

    SW_SET_REG_BY_FIELD(NAT_ENTRY2, HASH_KEY, entry->slct_idx, reg[2]);

    SW_SET_REG_BY_FIELD(NAT_ENTRY2, ENTRY_VALID, 1, reg[2]);
    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);
    return SW_OK;
}

static sw_error_t
_isis_nat_hw_to_sw(a_uint32_t dev_id, a_uint32_t reg[], fal_nat_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t data, cnt[4] = {0};

    entry->trans_addr = reg[0];

    SW_GET_FIELD_BY_REG(NAT_ENTRY2, PORT_EN, data, reg[2]);
    if (data)
    {
        entry->flags |= FAL_NAT_ENTRY_PORT_CHECK;
        SW_GET_FIELD_BY_REG(NAT_ENTRY1, PORT_RANGE, data, reg[1]);
        entry->port_range = data;
        SW_GET_FIELD_BY_REG(NAT_ENTRY1, PORT_NUM, data, reg[1]);
        entry->port_num = data;
    }

    SW_GET_FIELD_BY_REG(NAT_ENTRY1, PRV_IPADDR0, data, reg[1]);
    entry->src_addr = data;
    SW_GET_FIELD_BY_REG(NAT_ENTRY2, PRV_IPADDR1, data, reg[2]);
    data = (entry->src_addr & 0xff) | (data << 8);

    rv = _isis_ip_prvaddr_hw_to_sw(dev_id, data, &(entry->src_addr));
    SW_RTN_ON_ERROR(rv);

    SW_GET_FIELD_BY_REG(NAT_ENTRY2, ACTION, data, reg[2]);
    entry->action = FAL_MAC_FRWRD;
    if (0 == data)
    {
        entry->mirror_en = A_TRUE;
    }
    else if (2 == data)
    {
        entry->action = FAL_MAC_CPY_TO_CPU;
    }
    else if (1 == data)
    {
        entry->action = FAL_MAC_RDT_TO_CPU;
    }

    SW_GET_FIELD_BY_REG(NAT_ENTRY2, CNT_EN, data, reg[2]);
    if (data)
    {
        entry->counter_en = A_TRUE;
        SW_GET_FIELD_BY_REG(NAT_ENTRY2, CNT_IDX, entry->counter_id, reg[2]);

        rv = _isis_nat_counter_get(dev_id, entry->counter_id, cnt);
        SW_RTN_ON_ERROR(rv);

        entry->ingress_packet = cnt[0];
        entry->ingress_byte = cnt[1];
        entry->egress_packet = cnt[2];
        entry->egress_byte = cnt[3];
    }
    else
    {
        entry->counter_en = A_FALSE;
    }

    SW_GET_FIELD_BY_REG(NAT_ENTRY2, PRO_TYP, data, reg[2]);
    if (3 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_ANY;
    }
    else if (2 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_TCP;
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_UDP;
    }
    else if (1 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_UDP;
    }
    else if (0 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_TCP;
    }

    SW_GET_FIELD_BY_REG(NAT_ENTRY2, HASH_KEY, data, reg[2]);
    entry->slct_idx = data;

    return SW_OK;
}

static sw_error_t
_isis_napt_sw_to_hw(a_uint32_t dev_id, fal_napt_entry_t * entry,
                    a_uint32_t reg[])
{
    sw_error_t rv;
    a_uint32_t data;

    reg[0] = entry->dst_addr;

    SW_SET_REG_BY_FIELD(NAPT_ENTRY1, DST_PORT, entry->dst_port, reg[1]);
    SW_SET_REG_BY_FIELD(NAPT_ENTRY1, SRC_PORT, entry->src_port, reg[1]);
    SW_SET_REG_BY_FIELD(NAPT_ENTRY2, TRANS_PORT, entry->trans_port, reg[2]);

    rv = _isis_ip_prvaddr_sw_to_hw(dev_id, entry->src_addr, &data);
    SW_RTN_ON_ERROR(rv);
    SW_SET_REG_BY_FIELD(NAPT_ENTRY2, SRC_IPADDR, data, reg[2]);

    if (!(FAL_NAT_ENTRY_TRANS_IPADDR_INDEX & entry->flags))
    {
        return SW_BAD_PARAM;
    }
    SW_SET_REG_BY_FIELD(NAPT_ENTRY2, TRANS_IPADDR, entry->trans_addr, reg[2]);

    if (FAL_MAC_FRWRD == entry->action)
    {
        if (A_TRUE == entry->mirror_en)
        {
            SW_SET_REG_BY_FIELD(NAPT_ENTRY3, ACTION, 0, reg[3]);
        }
        else
        {
            SW_SET_REG_BY_FIELD(NAPT_ENTRY3, ACTION, 3, reg[3]);
        }
    }
    else if (FAL_MAC_CPY_TO_CPU == entry->action)
    {
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, ACTION, 2, reg[3]);
    }
    else if (FAL_MAC_RDT_TO_CPU == entry->action)
    {
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, ACTION, 1, reg[3]);
    }
    else
    {
        return SW_NOT_SUPPORTED;
    }

    if (A_TRUE == entry->counter_en)
    {
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, CNT_EN, 1, reg[3]);
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, CNT_IDX, entry->counter_id, reg[3]);
    }

    data = 2;
    if (FAL_NAT_ENTRY_PROTOCOL_TCP & entry->flags)
    {
        data = 0;
    }
    else if (FAL_NAT_ENTRY_PROTOCOL_UDP & entry->flags)
    {
        data = 1;
    }
    else if (FAL_NAT_ENTRY_PROTOCOL_PPTP & entry->flags)
    {
        data = 3;
    }
    SW_SET_REG_BY_FIELD(NAPT_ENTRY3, PROT_TYP, data, reg[3]);

    SW_SET_REG_BY_FIELD(NAPT_ENTRY3, AGE_FLAG, entry->status, reg[3]);
    return SW_OK;
}

static sw_error_t
_isis_napt_hw_to_sw(a_uint32_t dev_id, a_uint32_t reg[],
                    fal_napt_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t data, cnt[4] = {0};

    entry->dst_addr = reg[0];

    SW_GET_FIELD_BY_REG(NAPT_ENTRY1, DST_PORT, entry->dst_port, reg[1]);
    SW_GET_FIELD_BY_REG(NAPT_ENTRY1, SRC_PORT, entry->src_port, reg[1]);
    SW_GET_FIELD_BY_REG(NAPT_ENTRY2, TRANS_PORT, entry->trans_port, reg[2]);

    SW_GET_FIELD_BY_REG(NAPT_ENTRY2, SRC_IPADDR, data, reg[2]);
    rv = _isis_ip_prvaddr_hw_to_sw(dev_id, data, &(entry->src_addr));
    SW_RTN_ON_ERROR(rv);

    entry->flags |= FAL_NAT_ENTRY_TRANS_IPADDR_INDEX;
    SW_GET_FIELD_BY_REG(NAPT_ENTRY2, TRANS_IPADDR, entry->trans_addr, reg[2]);

    SW_GET_FIELD_BY_REG(NAPT_ENTRY3, ACTION, data, reg[3]);
    entry->action = FAL_MAC_FRWRD;
    if (0 == data)
    {
        entry->mirror_en = A_TRUE;
    }
    else if (2 == data)
    {
        entry->action = FAL_MAC_CPY_TO_CPU;
    }
    else if (1 == data)
    {
        entry->action = FAL_MAC_RDT_TO_CPU;
    }

    SW_GET_FIELD_BY_REG(NAPT_ENTRY3, CNT_EN, data, reg[3]);
    if (data)
    {
        entry->counter_en = A_TRUE;
        SW_GET_FIELD_BY_REG(NAPT_ENTRY3, CNT_IDX, entry->counter_id, reg[3]);

        rv = _isis_nat_counter_get(dev_id, entry->counter_id, cnt);
        SW_RTN_ON_ERROR(rv);

        entry->ingress_packet = cnt[0];
        entry->ingress_byte = cnt[1];
        entry->egress_packet = cnt[2];
        entry->egress_byte = cnt[3];
    }
    else
    {
        entry->counter_en = A_FALSE;
    }

    SW_GET_FIELD_BY_REG(NAPT_ENTRY3, PROT_TYP, data, reg[3]);
    if (0 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_TCP;
    }
    else if (1 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_UDP;
    }
    else if (3 == data)
    {
        entry->flags |= FAL_NAT_ENTRY_PROTOCOL_PPTP;
    }

    SW_GET_FIELD_BY_REG(NAPT_ENTRY3, AGE_FLAG, entry->status, reg[3]);
    return SW_OK;
}

static sw_error_t
_isis_nat_down_to_hw(a_uint32_t dev_id, a_uint32_t reg[])
{
    sw_error_t rv;
    a_uint32_t i, addr;

    for (i = 0; i < 5; i++)
    {
        addr = ISIS_HOST_ENTRY_DATA0_ADDR + (i << 2);
        HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&reg[i]), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_up_to_sw(a_uint32_t dev_id, a_uint32_t reg[])
{
    sw_error_t rv;
    a_uint32_t i, addr;

    for (i = 0; i < 5; i++)
    {
        addr = ISIS_HOST_ENTRY_DATA0_ADDR + (i << 2);
        HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&reg[i]), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_add(a_uint32_t dev_id, fal_nat_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t i, reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    for (i = 0; i < ISIS_NAT_ENTRY_NUM; i++)
    {
        if (!(isis_nat_snap[dev_id] & (0x1 << i)))
        {
            break;
        }
    }

    if (ISIS_NAT_ENTRY_NUM == i)
    {
        return SW_NO_RESOURCE;
    }

    entry->entry_id = i;

    rv = _isis_nat_sw_to_hw(dev_id, entry, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_ADD);
    SW_RTN_ON_ERROR(rv);

    isis_nat_snap[dev_id] |= (0x1 << i);
    entry->entry_id = i;
    return SW_OK;
}

static sw_error_t
_isis_nat_del(a_uint32_t dev_id, a_uint32_t del_mode, fal_nat_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NAT_ENTRY_ID_EN & del_mode)
    {
        SW_SET_REG_BY_FIELD(HOST_ENTRY4, ENTRY_FUNC, ISIS_NAT_ENTRY_DEL, reg[4]);
        SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);

        rv = _isis_nat_down_to_hw(dev_id, reg);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_DEL);
        SW_RTN_ON_ERROR(rv);

        isis_nat_snap[dev_id] &= (~(0x1 << entry->entry_id));
    }
    else
    {
        rv = _isis_nat_down_to_hw(dev_id, reg);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_FLUSH);
        SW_RTN_ON_ERROR(rv);

        isis_nat_snap[dev_id] = 0;
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_get(a_uint32_t dev_id, a_uint32_t get_mode, fal_nat_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NAT_ENTRY_ID_EN != get_mode)
    {
        return SW_NOT_SUPPORTED;
    }

    if (!(isis_nat_snap[dev_id] & (0x1 << entry->entry_id)))
    {
        return SW_NOT_FOUND;
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_SEARCH);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_hw_to_sw(dev_id, reg, entry);
    return rv;
}

static sw_error_t
_isis_nat_next(a_uint32_t dev_id, a_uint32_t next_mode,
               fal_nat_entry_t * nat_entry)
{
    a_uint32_t i, idx, reg[5] = { 0 };
    sw_error_t rv;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NEXT_ENTRY_FIRST_ID == nat_entry->entry_id)
    {
        idx = 0;
    }
    else
    {
        if ((ISIS_NAT_ENTRY_NUM - 1) == nat_entry->entry_id)
        {
            return SW_NO_MORE;
        }
        else
        {
            idx = nat_entry->entry_id + 1;
        }
    }

    for (i = idx; i < ISIS_NAT_ENTRY_NUM; i++)
    {
        if (isis_nat_snap[dev_id] & (0x1 << i))
        {
            break;
        }
    }

    if (ISIS_NAT_ENTRY_NUM == i)
    {
        return SW_NO_MORE;
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, i, reg[4]);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_SEARCH);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    aos_mem_zero(nat_entry, sizeof (fal_nat_entry_t));

    rv = _isis_nat_hw_to_sw(dev_id, reg, nat_entry);
    SW_RTN_ON_ERROR(rv);

    nat_entry->entry_id = i;
    return SW_OK;
}

static sw_error_t
_isis_nat_counter_bind(a_uint32_t dev_id, a_uint32_t entry_id,
                       a_uint32_t cnt_id, a_bool_t enable)
{
    sw_error_t rv;
    a_uint32_t reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (!(isis_nat_snap[dev_id] & (0x1 << entry_id)))
    {
        return SW_NOT_FOUND;
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, entry_id, reg[4]);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_SEARCH);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    if (A_FALSE == enable)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, CNT_EN, 0, reg[2]);
    }
    else if (A_TRUE == enable)
    {
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, CNT_EN, 1, reg[2]);
        SW_SET_REG_BY_FIELD(NAT_ENTRY2, CNT_IDX, cnt_id, reg[2]);
    }
    else
    {
        return SW_BAD_PARAM;
    }

    /* needn't set TBL_IDX, keep hardware register value */

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_DEL);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    /* needn't set TBL_IDX, keep hardware register value */

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_ADD);
    return rv;
}

static sw_error_t
_isis_napt_add(a_uint32_t dev_id, fal_napt_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_napt_sw_to_hw(dev_id, entry, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_ADD);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);
    return SW_OK;
}

static sw_error_t
_isis_napt_del(a_uint32_t dev_id, a_uint32_t del_mode, fal_napt_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t data, reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NAT_ENTRY_ID_EN & del_mode)
    {
        return SW_NOT_SUPPORTED;
    }

    if (FAL_NAT_ENTRY_KEY_EN & del_mode)
    {
        rv = _isis_napt_sw_to_hw(dev_id, entry, reg);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_down_to_hw(dev_id, reg);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_DEL);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_up_to_sw(dev_id, reg);
        SW_RTN_ON_ERROR(rv);

        SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);
        return SW_OK;
    }
    else
    {
        if (FAL_NAT_ENTRY_PUBLIC_IP_EN & del_mode)
        {
            SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_PIP, 1, reg[4]);
            SW_SET_REG_BY_FIELD(NAPT_ENTRY2, TRANS_IPADDR, entry->trans_addr, reg[2]);
        }

        if (FAL_NAT_ENTRY_SOURCE_IP_EN & del_mode)
        {
            SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_SIP, 1, reg[4]);
            rv = _isis_ip_prvaddr_sw_to_hw(dev_id, entry->src_addr, &data);
            SW_RTN_ON_ERROR(rv);
            SW_SET_REG_BY_FIELD(NAPT_ENTRY2, SRC_IPADDR, data, reg[2]);
        }

        if (FAL_NAT_ENTRY_AGE_EN & del_mode)
        {
            SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_STATUS, 1, reg[4]);
            SW_SET_REG_BY_FIELD(NAPT_ENTRY3, AGE_FLAG, entry->status, reg[3]);
        }

        rv = _isis_nat_down_to_hw(dev_id, reg);
        SW_RTN_ON_ERROR(rv);

        rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_FLUSH);
        return rv;
    }
}

static sw_error_t
_isis_napt_get(a_uint32_t dev_id, a_uint32_t get_mode, fal_napt_entry_t * entry)
{
    sw_error_t rv;
    a_uint32_t found, age, reg[5] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

#if 0
    if (FAL_NAT_ENTRY_ID_EN != get_mode)
    {
        return SW_NOT_SUPPORTED;
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, entry->entry_id, reg[4]);
#else
    rv = _isis_napt_sw_to_hw(dev_id, entry, reg);
    SW_RTN_ON_ERROR(rv);
#endif

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_SEARCH);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_STAUS, found, reg[4]);
    SW_GET_FIELD_BY_REG(NAPT_ENTRY3, AGE_FLAG,  age, reg[3]);
    if (found && age)
    {
        found = 1;
    }
    else
    {
        found = 0;
    }

    rv = _isis_napt_hw_to_sw(dev_id, reg, entry);
    SW_RTN_ON_ERROR(rv);

    if (!found)
    {
        return SW_NOT_FOUND;
    }

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_IDX,   entry->entry_id, reg[4]);
    return SW_OK;
}

static sw_error_t
_isis_napt_next(a_uint32_t dev_id, a_uint32_t next_mode,
                fal_napt_entry_t * napt_entry)
{
    a_uint32_t data, idx, reg[5] = { 0 };
    sw_error_t rv;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NEXT_ENTRY_FIRST_ID == napt_entry->entry_id)
    {
        idx = ISIS_NAPT_ENTRY_NUM - 1;
    }
    else
    {
        if ((ISIS_NAPT_ENTRY_NUM - 1) == napt_entry->entry_id)
        {
            return SW_NO_MORE;
        }
        else
        {
            idx = napt_entry->entry_id;
        }
    }

    if (FAL_NAT_ENTRY_PUBLIC_IP_EN & next_mode)
    {
        SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_PIP, 1, reg[4]);
        SW_SET_REG_BY_FIELD(NAPT_ENTRY2, TRANS_IPADDR, napt_entry->trans_addr, reg[2]);
    }

    if (FAL_NAT_ENTRY_SOURCE_IP_EN & next_mode)
    {
        SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_SIP, 1, reg[4]);
        rv = _isis_ip_prvaddr_sw_to_hw(dev_id, napt_entry->src_addr, &data);
        SW_RTN_ON_ERROR(rv);
        SW_SET_REG_BY_FIELD(NAPT_ENTRY2, SRC_IPADDR, data, reg[2]);
    }

    if (FAL_NAT_ENTRY_AGE_EN & next_mode)
    {
        SW_SET_REG_BY_FIELD(HOST_ENTRY4, SPEC_STATUS, 1, reg[4]);
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, AGE_FLAG, napt_entry->status, reg[3]);
    }

    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, idx, reg[4]);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_NEXT);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    aos_mem_zero(napt_entry, sizeof (fal_nat_entry_t));

    rv = _isis_napt_hw_to_sw(dev_id, reg, napt_entry);
    SW_RTN_ON_ERROR(rv);

#if 0
    a_uint32_t temp=0, complete=0;

    HSL_REG_ENTRY_GET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&temp),
                      sizeof (a_uint32_t));

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_STAUS, complete, temp);

    if (!complete)
    {
        return SW_NO_MORE;
    }
#endif

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_IDX, napt_entry->entry_id, reg[4]);
    return SW_OK;
}

static sw_error_t
_isis_napt_counter_bind(a_uint32_t dev_id, a_uint32_t entry_id,
                        a_uint32_t cnt_id, a_bool_t enable)
{
    sw_error_t rv;
    a_uint32_t reg[5] = { 0 }, tbl_idx;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    tbl_idx = (entry_id - 1) & 0x3ff;
    SW_SET_REG_BY_FIELD(HOST_ENTRY4, TBL_IDX, tbl_idx, reg[4]);

    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_NEXT);
    if (SW_OK != rv)
    {
        return SW_NOT_FOUND;
    }

    rv = _isis_nat_up_to_sw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    SW_GET_FIELD_BY_REG(HOST_ENTRY4, TBL_IDX, tbl_idx, reg[4]);
    if (entry_id != tbl_idx)
    {
        return SW_NOT_FOUND;
    }

    if (A_FALSE == enable)
    {
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, CNT_EN, 0, reg[3]);
    }
    else if (A_TRUE == enable)
    {
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, CNT_EN, 1, reg[3]);
        SW_SET_REG_BY_FIELD(NAPT_ENTRY3, CNT_IDX, cnt_id, reg[3]);
    }
    else
    {
        return SW_BAD_PARAM;
    }

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_DEL);
    SW_RTN_ON_ERROR(rv);

    reg[4] = 0x0;
    rv = _isis_nat_down_to_hw(dev_id, reg);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_ADD);
    return rv;
}

static sw_error_t
_isis_nat_status_set(a_uint32_t dev_id, a_bool_t enable)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (A_TRUE == enable)
    {
        data = 1;
    }
    else if (A_FALSE == enable)
    {
        data = 0;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    HSL_REG_FIELD_SET(rv, dev_id, NAT_CTRL, 0, NAT_EN,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_status_get(a_uint32_t dev_id, a_bool_t * enable)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, NAT_CTRL, 0, NAT_EN,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        *enable = A_TRUE;
    }
    else
    {
        *enable = A_FALSE;
    }

    return rv;
}

static sw_error_t
_isis_napt_status_set(a_uint32_t dev_id, a_bool_t enable)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (A_TRUE == enable)
    {
        data = 1;
    }
    else if (A_FALSE == enable)
    {
        data = 0;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    HSL_REG_FIELD_SET(rv, dev_id, NAT_CTRL, 0, NAPT_EN,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_napt_status_get(a_uint32_t dev_id, a_bool_t * enable)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, NAT_CTRL, 0, NAPT_EN,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        *enable = A_TRUE;
    }
    else
    {
        *enable = A_FALSE;
    }

    return rv;
}

static sw_error_t
_isis_napt_mode_set(a_uint32_t dev_id, fal_napt_mode_t mode)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NAPT_FULL_CONE == mode)
    {
        data = 0;
    }
    else if (FAL_NAPT_STRICT_CONE == mode)
    {
        data = 1;
    }
    else if ((FAL_NAPT_PORT_STRICT == mode)
             || (FAL_NAPT_SYNMETRIC == mode))
    {
        data = 2;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    HSL_REG_FIELD_SET(rv, dev_id, NAT_CTRL, 0, NAPT_MODE,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_napt_mode_get(a_uint32_t dev_id, fal_napt_mode_t * mode)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, NAT_CTRL, 0, NAPT_MODE,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (0 == data)
    {
        *mode = FAL_NAPT_FULL_CONE;
    }
    else if (1 == data)
    {
        *mode = FAL_NAPT_STRICT_CONE;
    }
    else
    {
        *mode = FAL_NAPT_PORT_STRICT;
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_hash_mode_set(a_uint32_t dev_id, a_uint32_t mode)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if ((FAL_NAT_HASH_KEY_PORT & mode)
            && (FAL_NAT_HASH_KEY_IPADDR & mode))
    {
        data = 2;
    }
    else if (FAL_NAT_HASH_KEY_PORT & mode)
    {
        data = 0;
    }
    else if (FAL_NAT_HASH_KEY_IPADDR & mode)
    {
        data = 1;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    HSL_REG_FIELD_SET(rv, dev_id, NAT_CTRL, 0, NAT_HASH_MODE,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_hash_mode_get(a_uint32_t dev_id, a_uint32_t * mode)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, NAT_CTRL, 0, NAT_HASH_MODE,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    *mode = 0;
    if (0 == data)
    {
        *mode = FAL_NAT_HASH_KEY_PORT;
    }
    else if (1 == data)
    {
        *mode = FAL_NAT_HASH_KEY_IPADDR;
    }
    else if (2 == data)
    {
        *mode = FAL_NAT_HASH_KEY_PORT;
        *mode |= FAL_NAT_HASH_KEY_IPADDR;
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_prv_base_addr_set(a_uint32_t dev_id, fal_ip4_addr_t addr)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        data = (((addr >> 20) & 0xfff) << 8) | ((addr >> 8) & 0xff);
    }
    else
    {
        data = (addr >> 12) & 0xfffff;
    }

    HSL_REG_FIELD_SET(rv, dev_id, PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_SET(rv, dev_id, OFFLOAD_PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_prv_base_addr_get(a_uint32_t dev_id, fal_ip4_addr_t * addr)
{
    sw_error_t rv;
    a_uint32_t data = 0, tmp = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&tmp), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (tmp)
    {
        *addr = ((data & 0xff) << 8) | (((data >> 8) & 0xfff) << 20);
    }
    else
    {
        *addr = (data & 0xfffff) << 12;
    }

    return SW_OK;
}

#if 0
static sw_error_t
_isis_nat_psr_prv_base_addr_set(a_uint32_t dev_id, fal_ip4_addr_t addr)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        data = (((addr >> 20) & 0xfff) << 8) | ((addr >> 8) & 0xff);
    }
    else
    {
        data = (addr >> 12) & 0xfffff;
    }

    HSL_REG_FIELD_SET(rv, dev_id, PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_psr_prv_base_addr_get(a_uint32_t dev_id, fal_ip4_addr_t * addr)
{
    sw_error_t rv;
    a_uint32_t data, tmp = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&tmp), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, IP4_BASEADDR,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (tmp)
    {
        *addr = ((data & 0xff) << 8) | (((data >> 8) & 0xfff) << 20);
    }
    else
    {
        *addr = (data & 0xfffff) << 12;
    }

    return SW_OK;
}
#endif

static sw_error_t
_isis_nat_prv_addr_mode_set(a_uint32_t dev_id, a_bool_t map_en)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (A_TRUE == map_en)
    {
        data = 1;
    }
    else if (A_FALSE == map_en)
    {
        data = 0;
    }
    else
    {
        return SW_BAD_PARAM;
    }

    HSL_REG_FIELD_SET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_prv_addr_mode_get(a_uint32_t dev_id, a_bool_t * map_en)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, PRVIP_CTL, 0, BASEADDR_SEL,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (data)
    {
        *map_en = A_TRUE;
    }
    else
    {
        *map_en = A_FALSE;
    }

    return SW_OK;
}

static sw_error_t
_isis_nat_pub_addr_commit(a_uint32_t dev_id, fal_nat_pub_addr_t * entry,
                          a_uint32_t op, a_uint32_t * empty)
{
    a_uint32_t index, addr, data, tbl[2] = { 0 };
    sw_error_t rv;

    *empty = ISIS_PUB_ADDR_NUM;
    for (index = 0; index < ISIS_PUB_ADDR_NUM; index++)
    {
        addr = ISIS_PUB_ADDR_TBL1_ADDR + (index << 4);
        HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&(tbl[1])), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);

        SW_GET_FIELD_BY_REG(PUB_ADDR1, ADDR_VALID, data, tbl[1]);
        if (data)
        {
            addr = ISIS_PUB_ADDR_TBL0_ADDR + (index << 4);
            HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                                  (a_uint8_t *) (&(tbl[0])),
                                  sizeof (a_uint32_t));
            SW_RTN_ON_ERROR(rv);

            if (!aos_mem_cmp
                    ((void *) &(entry->pub_addr), (void *) &(tbl[0]),
                     sizeof (fal_ip4_addr_t)))
            {
                if (ISIS_NAT_ENTRY_DEL == op)
                {
                    addr = ISIS_PUB_ADDR_TBL1_ADDR + (index << 4);
                    tbl[1] = 0;
                    HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                                          (a_uint8_t *) (&(tbl[1])),
                                          sizeof (a_uint32_t));
                    *empty = index;
                    return rv;
                }
                else if (ISIS_NAT_ENTRY_ADD == op)
                {
                    entry->entry_id = index;
                    return SW_ALREADY_EXIST;
                }
            }
        }
        else
        {
            *empty = index;
        }
    }

    return SW_NOT_FOUND;
}

static sw_error_t
_isis_nat_pub_addr_add(a_uint32_t dev_id, fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;
    a_uint32_t i, empty, addr, data = 0, tbl[2] = { 0 };

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    tbl[0] = entry->pub_addr;
    tbl[1] = 1;

    rv = _isis_nat_pub_addr_commit(dev_id, entry, ISIS_NAT_ENTRY_ADD, &empty);
    if (SW_ALREADY_EXIST == rv)
    {
        return rv;
    }

    if (ISIS_PUB_ADDR_NUM == empty)
    {
        return SW_NO_RESOURCE;
    }

    for (i = 0; i < 1; i++)
    {
        addr = ISIS_PUB_ADDR_EDIT0_ADDR + (empty << 4) + (i << 2);
        HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&(tbl[i])), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
    }

    addr = ISIS_PUB_ADDR_OFFLOAD_ADDR + (empty << 2);
    HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&(tbl[0])), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    addr = ISIS_PUB_ADDR_VALID_ADDR;
    HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    data |= (0x1 << empty);
    HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    for (i = 0; i < 2; i++)
    {
        addr = ISIS_PUB_ADDR_TBL0_ADDR + (empty << 4) + (i << 2);
        HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&(tbl[i])), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
    }

    entry->entry_id = empty;
    return SW_OK;
}

static sw_error_t
_isis_nat_pub_addr_del(a_uint32_t dev_id, a_uint32_t del_mode,
                       fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;
    a_uint32_t empty, addr, data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_pub_addr_commit(dev_id, entry, ISIS_NAT_ENTRY_DEL, &empty);
    SW_RTN_ON_ERROR(rv);

    addr = ISIS_PUB_ADDR_VALID_ADDR;
    HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    data &= (~(0x1 << empty));
    HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&data), sizeof (a_uint32_t));

    return rv;
}

static sw_error_t
_isis_nat_pub_addr_next(a_uint32_t dev_id, a_uint32_t next_mode,
                        fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;
    a_uint32_t data, addr, idx, index, tbl[2] = {0};

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_NEXT_ENTRY_FIRST_ID == entry->entry_id)
    {
        idx = 0;
    }
    else
    {
        if ((ISIS_PUB_ADDR_NUM - 1) == entry->entry_id)
        {
            return SW_NO_MORE;
        }
        else
        {
            idx = entry->entry_id + 1;
        }
    }

    for (index = idx; index < ISIS_PUB_ADDR_NUM; index++)
    {
        addr = ISIS_PUB_ADDR_TBL1_ADDR + (index << 4);
        HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&(tbl[1])), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);

        SW_GET_FIELD_BY_REG(PUB_ADDR1, ADDR_VALID, data, tbl[1]);
        if (data)
        {
            break;
        }
    }

    if (ISIS_PUB_ADDR_NUM == index)
    {
        return SW_NO_MORE;
    }

    addr = ISIS_PUB_ADDR_TBL0_ADDR + (index << 4);
    HSL_REG_ENTRY_GEN_GET(rv, dev_id, addr, sizeof (a_uint32_t),
                          (a_uint8_t *) (&(tbl[0])), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    entry->entry_id = index;
    entry->pub_addr = tbl[0];

    return SW_OK;
}

static sw_error_t
_isis_nat_unk_session_cmd_set(a_uint32_t dev_id, fal_fwd_cmd_t cmd)
{
    sw_error_t rv;
    a_uint32_t data;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    if (FAL_MAC_DROP == cmd)
    {
        data = 1;
    }
    else if (FAL_MAC_RDT_TO_CPU == cmd)
    {
        data = 0;
    }
    else
    {
        return SW_NOT_SUPPORTED;
    }

    HSL_REG_FIELD_SET(rv, dev_id, FORWARD_CTL0, 0, NAT_NOT_FOUND_DROP,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    return rv;
}

static sw_error_t
_isis_nat_unk_session_cmd_get(a_uint32_t dev_id, fal_fwd_cmd_t * cmd)
{
    sw_error_t rv;
    a_uint32_t data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_FIELD_GET(rv, dev_id, FORWARD_CTL0, 0, NAT_NOT_FOUND_DROP,
                      (a_uint8_t *) (&data), sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    if (0 == data)
    {
        *cmd = FAL_MAC_RDT_TO_CPU;
    }
    else
    {
        *cmd = FAL_MAC_DROP;
    }

    return SW_OK;
}

sw_error_t
isis_nat_reset(a_uint32_t dev_id)
{
    sw_error_t rv;
    a_uint32_t index, addr, data = 0;

    HSL_DEV_ID_CHECK(dev_id);

    rv = _isis_nat_feature_check(dev_id);
    SW_RTN_ON_ERROR(rv);

    isis_nat_snap[dev_id] = 0;

    HSL_REG_ENTRY_SET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&data),
                      sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAT, ISIS_NAT_ENTRY_FLUSH);
    SW_RTN_ON_ERROR(rv);

    HSL_REG_ENTRY_SET(rv, dev_id, HOST_ENTRY4, 0, (a_uint8_t *) (&data),
                      sizeof (a_uint32_t));
    SW_RTN_ON_ERROR(rv);

    rv = _isis_nat_entry_commit(dev_id, ISIS_ENTRY_NAPT, ISIS_NAT_ENTRY_FLUSH);
    SW_RTN_ON_ERROR(rv);

    for (index = 0; index < ISIS_PUB_ADDR_NUM; index++)
    {
        addr = ISIS_PUB_ADDR_TBL1_ADDR + (index << 4);
        HSL_REG_ENTRY_GEN_SET(rv, dev_id, addr, sizeof (a_uint32_t),
                              (a_uint8_t *) (&data), sizeof (a_uint32_t));
        SW_RTN_ON_ERROR(rv);
    }

    return SW_OK;
}

/**
 * @brief Add one NAT entry to one particular device.
 *   @details Comments:
       Before NAT entry added ip4 private base address must be set
       at first.
       In parameter nat_entry entry flags must be set
       Hardware entry id will be returned.
 * @param[in] dev_id device id
 * @param[in] nat_entry NAT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_add(a_uint32_t dev_id, fal_nat_entry_t * nat_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_add(dev_id, nat_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Del NAT entries from one particular device.
 * @param[in] dev_id device id
 * @param[in] del_mode NAT entry delete operation mode
 * @param[in] nat_entry NAT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_del(a_uint32_t dev_id, a_uint32_t del_mode,
             fal_nat_entry_t * nat_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_del(dev_id, del_mode, nat_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get one NAT entry from one particular device.
 * @param[in] dev_id device id
 * @param[in] get_mode NAT entry get operation mode
 * @param[in] nat_entry NAT entry parameter
 * @param[out] nat_entry NAT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_get(a_uint32_t dev_id, a_uint32_t get_mode,
             fal_nat_entry_t * nat_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_get(dev_id, get_mode, nat_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Next NAT entries from one particular device.
 * @param[in] dev_id device id
 * @param[in] next_mode NAT entry next operation mode
 * @param[in] nat_entry NAT entry parameter
 * @param[out] nat_entry NAT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_next(a_uint32_t dev_id, a_uint32_t next_mode,
              fal_nat_entry_t * nat_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_next(dev_id, next_mode, nat_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Bind one counter entry to one NAT entry to one particular device.
 * @param[in] dev_id device id
 * @param[in] entry_id NAT entry id
 * @param[in] cnt_id counter entry id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_counter_bind(a_uint32_t dev_id, a_uint32_t entry_id, a_uint32_t cnt_id,
                      a_bool_t enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_counter_bind(dev_id, entry_id, cnt_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Add one NAPT entry to one particular device.
 *   @details Comments:
       Before NAPT entry added related ip4 private base address must be set
       at first.
       In parameter napt_entry related entry flags must be set
       Hardware entry id will be returned.
 * @param[in] dev_id device id
 * @param[in] napt_entry NAPT entry parameter
 * @return SW_OK or error code
 */

HSL_LOCAL sw_error_t
isis_napt_add(a_uint32_t dev_id, fal_napt_entry_t * napt_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_add(dev_id, napt_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Del NAPT entries from one particular device.
 * @param[in] dev_id device id
 * @param[in] del_mode NAPT entry delete operation mode
 * @param[in] napt_entry NAPT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_del(a_uint32_t dev_id, a_uint32_t del_mode,
              fal_napt_entry_t * napt_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_del(dev_id, del_mode, napt_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get one NAPT entry from one particular device.
 * @param[in] dev_id device id
 * @param[in] get_mode NAPT entry get operation mode
 * @param[in] nat_entry NAPT entry parameter
 * @param[out] nat_entry NAPT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_get(a_uint32_t dev_id, a_uint32_t get_mode,
              fal_napt_entry_t * napt_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_get(dev_id, get_mode, napt_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Next NAPT entries from one particular device.
 * @param[in] dev_id device id
 * @param[in] next_mode NAPT entry next operation mode
 * @param[in] napt_entry NAPT entry parameter
 * @param[out] napt_entry NAPT entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_next(a_uint32_t dev_id, a_uint32_t next_mode,
               fal_napt_entry_t * napt_entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_next(dev_id, next_mode, napt_entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Bind one counter entry to one NAPT entry to one particular device.
 * @param[in] dev_id device id
 * @param[in] entry_id NAPT entry id
 * @param[in] cnt_id counter entry id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_counter_bind(a_uint32_t dev_id, a_uint32_t entry_id,
                       a_uint32_t cnt_id, a_bool_t enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_counter_bind(dev_id, entry_id, cnt_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set working status of NAT engine on a particular device
 * @param[in] dev_id device id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_status_set(a_uint32_t dev_id, a_bool_t enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_status_set(dev_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get working status of NAT engine on a particular device
 * @param[in] dev_id device id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_status_get(a_uint32_t dev_id, a_bool_t * enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_status_get(dev_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set NAT hash mode on a particular device
 * @param[in] dev_id device id
 * @param[in] mode NAT hash mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_hash_mode_set(a_uint32_t dev_id, a_uint32_t mode)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_hash_mode_set(dev_id, mode);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get NAT hash mode on a particular device
 * @param[in] dev_id device id
 * @param[out] mode NAT hash mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_hash_mode_get(a_uint32_t dev_id, a_uint32_t * mode)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_hash_mode_get(dev_id, mode);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set working status of NAPT engine on a particular device
 * @param[in] dev_id device id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_status_set(a_uint32_t dev_id, a_bool_t enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_status_set(dev_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get working status of NAPT engine on a particular device
 * @param[in] dev_id device id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_status_get(a_uint32_t dev_id, a_bool_t * enable)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_status_get(dev_id, enable);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set working mode of NAPT engine on a particular device
 * @param[in] dev_id device id
 * @param[in] mode NAPT mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_mode_set(a_uint32_t dev_id, fal_napt_mode_t mode)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_mode_set(dev_id, mode);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get working mode of NAPT engine on a particular device
 * @param[in] dev_id device id
 * @param[out] mode NAPT mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_napt_mode_get(a_uint32_t dev_id, fal_napt_mode_t * mode)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_napt_mode_get(dev_id, mode);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set IP4 private base address on a particular device
 *   @details Comments:
        Only 20bits is meaning which 20bits is determined by private address mode.
 * @param[in] dev_id device id
 * @param[in] addr private base address
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_prv_base_addr_set(a_uint32_t dev_id, fal_ip4_addr_t addr)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_prv_base_addr_set(dev_id, addr);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get IP4 private base address on a particular device
 * @param[in] dev_id device id
 * @param[out] addr private base address
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_prv_base_addr_get(a_uint32_t dev_id, fal_ip4_addr_t * addr)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_prv_base_addr_get(dev_id, addr);
    HSL_API_UNLOCK;
    return rv;
}

#if 0
/**
 * @brief Set IP4 private base address on a particular device
 *   @details Comments:
        Only 20bits is meaning which 20bits is determined by private address mode.
 * @param[in] dev_id device id
 * @param[in] addr private base address
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_psr_prv_base_addr_set(a_uint32_t dev_id, fal_ip4_addr_t addr)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_psr_prv_base_addr_set(dev_id, addr);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get IP4 private base address on a particular device
 * @param[in] dev_id device id
 * @param[out] addr private base address
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_psr_prv_base_addr_get(a_uint32_t dev_id, fal_ip4_addr_t * addr)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_psr_prv_base_addr_get(dev_id, addr);
    HSL_API_UNLOCK;
    return rv;
}
#endif

/**
 * @brief Set IP4 private base address mode on a particular device
 *   @details Comments:
        If map_en equal true means bits31-20 bits15-8 are base address
        else bits31-12 are base address.
 * @param[in] dev_id device id
 * @param[in] map_en private base mapping mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_prv_addr_mode_set(a_uint32_t dev_id, a_bool_t map_en)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_prv_addr_mode_set(dev_id, map_en);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get IP4 private base address mode on a particular device
 * @param[in] dev_id device id
 * @param[out] map_en private base mapping mode
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_prv_addr_mode_get(a_uint32_t dev_id, a_bool_t * map_en)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_prv_addr_mode_get(dev_id, map_en);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Add one public address entry to one particular device.
 *   @details Comments:
       Hardware entry id will be returned.
 * @param[in] dev_id device id
 * @param[in] entry public address entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_pub_addr_add(a_uint32_t dev_id, fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_pub_addr_add(dev_id, entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Delete one public address entry from one particular device.
 * @param[in] dev_id device id
 * @param[in] del_mode delete operaton mode
 * @param[in] entry public address entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_pub_addr_del(a_uint32_t dev_id, a_uint32_t del_mode,
                      fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_pub_addr_del(dev_id, del_mode, entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Next public address entries from one particular device.
 * @param[in] dev_id device id
 * @param[in] next_mode next operaton mode
 * @param[out] entry public address entry parameter
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_pub_addr_next(a_uint32_t dev_id, a_uint32_t next_mode,
                       fal_nat_pub_addr_t * entry)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_pub_addr_next(dev_id, next_mode, entry);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set forwarding command for those packets miss NAT entries on a particular device.
 * @param[in] dev_id device id
 * @param[in] cmd forwarding command
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_unk_session_cmd_set(a_uint32_t dev_id, fal_fwd_cmd_t cmd)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_unk_session_cmd_set(dev_id, cmd);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Get forwarding command for those packets miss NAT entries on a particular device.
 * @param[in] dev_id device id
 * @param[out] cmd forwarding command
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_unk_session_cmd_get(a_uint32_t dev_id, fal_fwd_cmd_t * cmd)
{
    sw_error_t rv;

    HSL_API_LOCK;
    rv = _isis_nat_unk_session_cmd_get(dev_id, cmd);
    HSL_API_UNLOCK;
    return rv;
}

/**
 * @brief Set working status of NAT engine on a particular device
 * @param[in] dev_id device id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
HSL_LOCAL sw_error_t
isis_nat_global_set(a_uint32_t dev_id, a_bool_t enable, a_uint32_t portbmp)
{
    sw_error_t rv = SW_OK;

    HSL_API_LOCK;
    printk("enable:%d\n", enable);
    if(enable) {
        if(isis_nat_global_status == 0) {
            isis_nat_global_status = 1;
#if defined(IN_NAT_HELPER)
            ISIS_NAT_HELPER_INIT(rv, dev_id, portbmp);
#endif
        }
    } else {
        if(isis_nat_global_status == 1) {
            isis_nat_global_status = 0;
#if defined(IN_NAT_HELPER)
            ISIS_NAT_HELPER_CLEANUP(rv, dev_id);
#endif
        }
    }
    //rv = SW_OK;
    HSL_API_UNLOCK;
    return rv;
}


sw_error_t
isis_nat_init(a_uint32_t dev_id)
{
    sw_error_t rv;

    HSL_DEV_ID_CHECK(dev_id);

    rv = isis_nat_reset(dev_id);
    SW_RTN_ON_ERROR(rv);

#ifndef HSL_STANDALONG
    {
        hsl_api_t *p_api;

        SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id));

        p_api->nat_add = isis_nat_add;
        p_api->nat_del = isis_nat_del;
        p_api->nat_get = isis_nat_get;
        p_api->nat_next = isis_nat_next;
        p_api->nat_counter_bind = isis_nat_counter_bind;
        p_api->napt_add = isis_napt_add;
        p_api->napt_del = isis_napt_del;
        p_api->napt_get = isis_napt_get;
        p_api->napt_next = isis_napt_next;
        p_api->napt_counter_bind = isis_napt_counter_bind;
        p_api->nat_status_set = isis_nat_status_set;
        p_api->nat_status_get = isis_nat_status_get;
        p_api->nat_hash_mode_set = isis_nat_hash_mode_set;
        p_api->nat_hash_mode_get = isis_nat_hash_mode_get;
        p_api->napt_status_set = isis_napt_status_set;
        p_api->napt_status_get = isis_napt_status_get;
        p_api->napt_mode_set = isis_napt_mode_set;
        p_api->napt_mode_get = isis_napt_mode_get;
        p_api->nat_prv_base_addr_set = isis_nat_prv_base_addr_set;
        p_api->nat_prv_base_addr_get = isis_nat_prv_base_addr_get;
        p_api->nat_prv_addr_mode_set = isis_nat_prv_addr_mode_set;
        p_api->nat_prv_addr_mode_get = isis_nat_prv_addr_mode_get;
        p_api->nat_pub_addr_add = isis_nat_pub_addr_add;
        p_api->nat_pub_addr_del = isis_nat_pub_addr_del;
        p_api->nat_pub_addr_next = isis_nat_pub_addr_next;
        p_api->nat_unk_session_cmd_set = isis_nat_unk_session_cmd_set;
        p_api->nat_unk_session_cmd_get = isis_nat_unk_session_cmd_get;
		p_api->nat_global_set = isis_nat_global_set;
    }
#endif

    return SW_OK;
}

/**
 * @}
 */