/*
 * Copyright (c) 2016-2020, 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.
 */

#include "adpt.h"
#include "ssdk_init.h"
#if defined(HPPE)
#include "adpt_hppe.h"
#endif
#if defined(IN_SFP)
#include "adpt_sfp.h"
#endif
#if defined(MP)
#include "adpt_mp.h"
#endif
#include "hsl_phy.h"

adpt_api_t *g_adpt_api[SW_MAX_NR_DEV] = {NULL};

adpt_chip_ver_t g_chip_ver[SW_MAX_NR_DEV] = {{0}};

adpt_api_t *adpt_api_ptr_get(a_uint32_t dev_id)
{
	if (dev_id >= SW_MAX_NR_DEV)
		return NULL;

	return g_adpt_api[dev_id];
}
#if defined (SCOMPHY)
a_uint32_t adapt_scomphy_revision_get(a_uint32_t dev_id)
{
	return g_chip_ver[dev_id].chip_revision;
}
#endif
#if defined(HPPE)
a_uint32_t adpt_hppe_chip_revision_get(a_uint32_t dev_id)
{
	return g_chip_ver[dev_id].chip_revision;
}

static sw_error_t adpt_hppe_module_func_register(a_uint32_t dev_id, a_uint32_t module)
{
	sw_error_t rv= SW_OK;

	switch (module)
	{
		case FAL_MODULE_ACL:
#if defined(IN_ACL)
			rv = adpt_hppe_acl_init(dev_id);
#endif
			break;
		case FAL_MODULE_VSI:
#if defined(IN_VSI)
			rv = adpt_hppe_vsi_init(dev_id);
#endif
			break;
		case FAL_MODULE_IP:
#if defined(IN_IP)
			rv = adpt_hppe_ip_init(dev_id);
#endif
			break;
		case FAL_MODULE_FLOW:
#if defined(IN_FLOW)
			rv = adpt_hppe_flow_init(dev_id);
#endif
			break;
		case FAL_MODULE_QM:
#if defined(IN_QM)
			rv = adpt_hppe_qm_init(dev_id);
#endif
			break;
		case FAL_MODULE_QOS:
#if defined(IN_QOS)
			rv = adpt_hppe_qos_init(dev_id);
#endif
			break;
		case FAL_MODULE_BM:
#if defined(IN_BM)
			rv = adpt_hppe_bm_init(dev_id);
#endif
			break;
		case FAL_MODULE_SERVCODE:
#if defined(IN_SERVCODE)
			rv = adpt_hppe_servcode_init( dev_id);
#endif
			break;
		case FAL_MODULE_RSS_HASH:
#if defined(IN_RSS_HASH)
			rv = adpt_hppe_rss_hash_init( dev_id);
#endif
			break;
		case FAL_MODULE_PPPOE:
#if defined(IN_PPPOE)
			rv = adpt_hppe_pppoe_init(dev_id);
#endif
			break;
		case FAL_MODULE_PORTCTRL:
#if defined(IN_PORTCONTROL)
			rv = adpt_hppe_port_ctrl_init(dev_id);
#endif
			break;
		case FAL_MODULE_SHAPER:
#if defined(IN_SHAPER)
			rv = adpt_hppe_shaper_init( dev_id);
#endif
			break;
		case FAL_MODULE_MIB:
#if defined(IN_MIB)
			rv = adpt_hppe_mib_init(dev_id);
#endif
			break;
		case FAL_MODULE_MIRROR:
#if defined(IN_MIRROR)
			rv = adpt_hppe_mirror_init( dev_id);
#endif
			break;
		case FAL_MODULE_FDB:
#if defined(IN_FDB)
			rv = adpt_hppe_fdb_init(dev_id);
#endif
			break;
		case FAL_MODULE_STP:
#if defined(IN_STP)
			rv = adpt_hppe_stp_init(dev_id);
#endif
			break;
		case FAL_MODULE_TRUNK:
#if defined(IN_TRUNK)
			rv = adpt_hppe_trunk_init( dev_id);
#endif
			break;
		case FAL_MODULE_PORTVLAN:
#if defined(IN_PORTVLAN)
			rv = adpt_hppe_portvlan_init(dev_id);
#endif
			break;
		case FAL_MODULE_CTRLPKT:
#if defined(IN_CTRLPKT)
			rv = adpt_hppe_ctrlpkt_init( dev_id);
#endif
			break;
		case FAL_MODULE_SEC:
#if defined(IN_SEC)
			rv = adpt_hppe_sec_init(dev_id);
#endif
			break;
		case FAL_MODULE_POLICER:
#if defined(IN_POLICER)
			rv = adpt_hppe_policer_init(dev_id);
#endif
			break;
		case FAL_MODULE_MISC:
#if defined(IN_MISC)
			rv = adpt_hppe_misc_init(dev_id);
#endif
			break;
		case FAL_MODULE_PTP:
#if defined(IN_PTP)
			rv = adpt_hppe_ptp_init(dev_id);
#endif
			break;
		case FAL_MODULE_SFP:
#if defined(IN_SFP)
			rv = adpt_sfp_init(dev_id);
#endif
			break;
		default:
			break;
	}

	return rv;
}
#endif

sw_error_t adpt_module_func_ctrl_set(a_uint32_t dev_id,
		a_uint32_t module, fal_func_ctrl_t *func_ctrl)
{
	sw_error_t rv= SW_OK;

	adpt_api_t *p_adpt_api = NULL;

	p_adpt_api = adpt_api_ptr_get(dev_id);

	if(p_adpt_api == NULL)
		return SW_FAIL;

	if(module == FAL_MODULE_ACL){
		p_adpt_api->adpt_acl_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_VSI) {
		p_adpt_api->adpt_vsi_func_bitmap = func_ctrl->bitmap[0];
	}else if (module == FAL_MODULE_IP) {
		p_adpt_api->adpt_ip_func_bitmap[0] = func_ctrl->bitmap[0];
		p_adpt_api->adpt_ip_func_bitmap[1] = func_ctrl->bitmap[1];
	} else if (module == FAL_MODULE_FLOW) {
		p_adpt_api->adpt_flow_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_QM) {
		p_adpt_api->adpt_qm_func_bitmap[0] = func_ctrl->bitmap[0];
		p_adpt_api->adpt_qm_func_bitmap[1] = func_ctrl->bitmap[1];
	} else if (module == FAL_MODULE_QOS) {
		p_adpt_api->adpt_qos_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_BM) {
		p_adpt_api->adpt_bm_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_SERVCODE) {
		p_adpt_api->adpt_servcode_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_RSS_HASH) {
		p_adpt_api->adpt_rss_hash_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_PPPOE) {
		p_adpt_api->adpt_pppoe_func_bitmap = func_ctrl->bitmap[0];
	} else if (module == FAL_MODULE_PORTCTRL) {
		p_adpt_api->adpt_port_ctrl_func_bitmap[0] = func_ctrl->bitmap[0];
		p_adpt_api->adpt_port_ctrl_func_bitmap[1] = func_ctrl->bitmap[1];
		p_adpt_api->adpt_port_ctrl_func_bitmap[2] = func_ctrl->bitmap[2];
	} else if (module == FAL_MODULE_SHAPER) {
		p_adpt_api->adpt_shaper_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_MIB){
		p_adpt_api->adpt_mib_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_MIRROR){
		p_adpt_api->adpt_mirror_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_FDB){
		p_adpt_api->adpt_fdb_func_bitmap[0] = func_ctrl->bitmap[0];
		p_adpt_api->adpt_fdb_func_bitmap[1] = func_ctrl->bitmap[1];
	} else if(module == FAL_MODULE_STP){
		p_adpt_api->adpt_stp_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_TRUNK){
		p_adpt_api->adpt_trunk_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_PORTVLAN){
		p_adpt_api->adpt_portvlan_func_bitmap[0] = func_ctrl->bitmap[0];
		p_adpt_api->adpt_portvlan_func_bitmap[1] = func_ctrl->bitmap[1];
	} else if(module == FAL_MODULE_CTRLPKT){
		p_adpt_api->adpt_ctrlpkt_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_SEC){
		p_adpt_api->adpt_sec_func_bitmap = func_ctrl->bitmap[0];
	} else if(module == FAL_MODULE_POLICER){
		p_adpt_api->adpt_policer_func_bitmap = func_ctrl->bitmap[0];
	}


	switch (g_chip_ver[dev_id].chip_type)
	{
		#if defined(HPPE)
		case CHIP_HPPE:
			rv = adpt_hppe_module_func_register(dev_id, module);
			break;
		#endif
		default:
			break;
	}

	return rv;
}

sw_error_t adpt_module_func_ctrl_get(a_uint32_t dev_id,
		a_uint32_t module, fal_func_ctrl_t *func_ctrl)
{
	adpt_api_t *p_adpt_api = NULL;

	p_adpt_api = adpt_api_ptr_get(dev_id);

	if(p_adpt_api == NULL)
		return SW_FAIL;

	if(module == FAL_MODULE_ACL){
		func_ctrl->bitmap[0] = p_adpt_api->adpt_acl_func_bitmap;
	} else if (module == FAL_MODULE_VSI) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_vsi_func_bitmap;
	} else if (module == FAL_MODULE_IP) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_ip_func_bitmap[0];
		func_ctrl->bitmap[1] = p_adpt_api->adpt_ip_func_bitmap[1];
	} else if (module == FAL_MODULE_FLOW) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_flow_func_bitmap;
	} else if (module == FAL_MODULE_QM) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_qm_func_bitmap[0];
		func_ctrl->bitmap[1] = p_adpt_api->adpt_qm_func_bitmap[1];
	} else if (module == FAL_MODULE_QOS) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_qos_func_bitmap;
	} else if (module == FAL_MODULE_BM) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_bm_func_bitmap;
	} else if (module == FAL_MODULE_SERVCODE) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_servcode_func_bitmap;
	} else if (module == FAL_MODULE_RSS_HASH) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_rss_hash_func_bitmap;
	} else if (module == FAL_MODULE_PPPOE) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_pppoe_func_bitmap;
	} else if (module == FAL_MODULE_PORTCTRL) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_port_ctrl_func_bitmap[0];
		func_ctrl->bitmap[1] = p_adpt_api->adpt_port_ctrl_func_bitmap[1];
		func_ctrl->bitmap[2] = p_adpt_api->adpt_port_ctrl_func_bitmap[2];
	} else if (module == FAL_MODULE_SHAPER) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_shaper_func_bitmap;
	} else if(module == FAL_MODULE_MIB) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_mib_func_bitmap;
	} else if(module == FAL_MODULE_MIRROR) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_mirror_func_bitmap;
	} else if(module == FAL_MODULE_FDB) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_fdb_func_bitmap[0];
		func_ctrl->bitmap[1] = p_adpt_api->adpt_fdb_func_bitmap[1];
	} else if(module == FAL_MODULE_STP) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_stp_func_bitmap;
	} else if(module == FAL_MODULE_TRUNK) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_trunk_func_bitmap;
	} else if(module == FAL_MODULE_PORTVLAN) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_portvlan_func_bitmap[0];
		func_ctrl->bitmap[1] = p_adpt_api->adpt_portvlan_func_bitmap[1];
	} else if(module == FAL_MODULE_CTRLPKT) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_ctrlpkt_func_bitmap;
	} else if(module == FAL_MODULE_SEC) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_sec_func_bitmap;
	} else if(module == FAL_MODULE_POLICER) {
		func_ctrl->bitmap[0] = p_adpt_api->adpt_policer_func_bitmap;
	}

	return SW_OK;
}

sw_error_t adpt_init(a_uint32_t dev_id, ssdk_init_cfg *cfg)
{
	sw_error_t rv= SW_OK;

	switch (cfg->chip_type)
	{
#if defined(HPPE)
		case CHIP_HPPE:
			g_adpt_api[dev_id] = aos_mem_alloc(sizeof(adpt_api_t));
			if(g_adpt_api[dev_id] == NULL)
			{
				printk("%s, %d:malloc fail for adpt api\n", __FUNCTION__, __LINE__);
				return SW_FAIL;
			}
			aos_mem_zero(g_adpt_api[dev_id], sizeof(adpt_api_t));

			g_chip_ver[dev_id].chip_type = cfg->chip_type;
			g_chip_ver[dev_id].chip_revision = cfg->chip_revision;
			g_adpt_api[dev_id]->adpt_mirror_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_MIRROR);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_fdb_func_bitmap[0] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_fdb_func_bitmap[1] = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_FDB);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_stp_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_STP);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_trunk_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_TRUNK);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_portvlan_func_bitmap[0] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_portvlan_func_bitmap[1] = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PORTVLAN);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_ctrlpkt_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_CTRLPKT);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_sec_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SEC);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_acl_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_ACL);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_vsi_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_VSI);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_ip_func_bitmap[0] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_ip_func_bitmap[1] = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_IP);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_flow_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_FLOW);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_qm_func_bitmap[0] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_qm_func_bitmap[1] = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_QM);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_qos_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_QOS);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_bm_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_BM);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_servcode_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SERVCODE);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_rss_hash_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_RSS_HASH);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_pppoe_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PPPOE);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[0] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[1] = 0xffffffff;
			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[2] = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PORTCTRL);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_shaper_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SHAPER);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_mib_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_MIB);
			SW_RTN_ON_ERROR(rv);

			g_adpt_api[dev_id]->adpt_policer_func_bitmap = 0xffffffff;
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_POLICER);
			SW_RTN_ON_ERROR(rv);

			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_MISC);
			SW_RTN_ON_ERROR(rv);

			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PTP);
			SW_RTN_ON_ERROR(rv);

			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SFP);
			SW_RTN_ON_ERROR(rv);

			/* uniphy */
			rv = adpt_hppe_uniphy_init(dev_id);
			SW_RTN_ON_ERROR(rv);

			break;
#endif
#if defined (SCOMPHY)
		case CHIP_SCOMPHY:
			g_chip_ver[dev_id].chip_type = cfg->chip_type;
			g_chip_ver[dev_id].chip_revision = cfg->phy_id;
#if defined (MP)
			if(cfg->phy_id == MP_GEPHY)
			{
				g_adpt_api[dev_id] = aos_mem_alloc(sizeof(adpt_api_t));
				if(g_adpt_api[dev_id] == NULL)
				{
					SSDK_ERROR("malloc fail for adpt api\n");
					return SW_FAIL;
				}
				aos_mem_zero(g_adpt_api[dev_id], sizeof(adpt_api_t));
				rv = adpt_mp_intr_init(dev_id);
				SW_RTN_ON_ERROR(rv);
#if defined (IN_MIB)
				rv = adpt_mp_mib_init(dev_id);
				SW_RTN_ON_ERROR(rv);
#endif
#if defined (IN_PORTCONTROL)
				rv = adpt_mp_portctrl_init(dev_id);
				SW_RTN_ON_ERROR(rv);
#endif
#if defined (IN_UNIPHY)
				rv = adpt_mp_uniphy_init(dev_id);
				SW_RTN_ON_ERROR(rv);
#endif
#if defined (IN_LED)
				rv = adpt_mp_led_init(dev_id);
				SW_RTN_ON_ERROR(rv);
#endif
			}
#endif
			break;
#endif
		default:
			break;
	}
	return rv;
}

sw_error_t adpt_module_func_init(a_uint32_t dev_id, ssdk_init_cfg *cfg)
{
	sw_error_t rv= SW_OK;

	switch (cfg->chip_type)
	{
		#if defined(HPPE)
		case CHIP_HPPE:
			g_adpt_api[dev_id]->adpt_mirror_func_bitmap = 0;
#if defined(IN_MIRROR)
			adpt_hppe_mirror_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_MIRROR);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_fdb_func_bitmap[0] = 0;
			g_adpt_api[dev_id]->adpt_fdb_func_bitmap[1] = 0;
#if defined(IN_FDB)
			adpt_hppe_fdb_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_FDB);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_stp_func_bitmap = 0;
#if defined(IN_STP)
			adpt_hppe_stp_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_STP);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_trunk_func_bitmap = 0;
#if defined(IN_TRUNK)
			adpt_hppe_trunk_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_TRUNK);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_portvlan_func_bitmap[0] = 0;
			g_adpt_api[dev_id]->adpt_portvlan_func_bitmap[1] = 0;
#if defined(IN_PORTVLAN)
			adpt_hppe_portvlan_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PORTVLAN);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_ctrlpkt_func_bitmap = 0;
#if defined(IN_CTRLPKT)
			adpt_hppe_ctrlpkt_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_CTRLPKT);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_sec_func_bitmap = 0;
#if defined(IN_SEC)
			adpt_hppe_sec_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SEC);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_acl_func_bitmap = 0;
#if defined(IN_ACL)
			adpt_hppe_acl_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_ACL);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_vsi_func_bitmap = 0;
#if defined(IN_VSI)
			adpt_hppe_vsi_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_VSI);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_ip_func_bitmap[0] = 0;
			g_adpt_api[dev_id]->adpt_ip_func_bitmap[1] = 0;
#if defined(IN_IP)
			adpt_hppe_ip_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_IP);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_flow_func_bitmap = 0;
#if defined(IN_FLOW)
			adpt_hppe_flow_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_FLOW);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_qm_func_bitmap[0] = 0;
			g_adpt_api[dev_id]->adpt_qm_func_bitmap[1] = 0;
#if defined(IN_QM)
			adpt_hppe_qm_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_QM);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_qos_func_bitmap = 0;
#if defined(IN_QOS)
			adpt_hppe_qos_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_QOS);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_bm_func_bitmap = 0;
#if defined(IN_BM)
			adpt_hppe_bm_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_BM);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_servcode_func_bitmap = 0;
#if defined(IN_SERVCODE)
			adpt_hppe_servcode_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SERVCODE);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_rss_hash_func_bitmap = 0;
#if defined(IN_RSS_HASH)
			adpt_hppe_rss_hash_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_RSS_HASH);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_pppoe_func_bitmap = 0;
#if defined(IN_PPPOE)
			adpt_hppe_pppoe_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PPPOE);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[0] = 0;
			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[1] = 0;
			g_adpt_api[dev_id]->adpt_port_ctrl_func_bitmap[2] = 0;
#if defined(IN_PORTCONTROL)
			adpt_hppe_port_ctrl_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_PORTCTRL);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_shaper_func_bitmap = 0;
#if defined(IN_SHAPER)
			adpt_hppe_shaper_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_SHAPER);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_mib_func_bitmap = 0;
#if defined(IN_MIB)
			adpt_hppe_mib_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_MIB);
			SW_RTN_ON_ERROR(rv);
#endif

			g_adpt_api[dev_id]->adpt_policer_func_bitmap = 0;
#if defined(IN_POLICER)
			adpt_hppe_policer_func_bitmap_init(dev_id);
			rv = adpt_hppe_module_func_register(dev_id, FAL_MODULE_POLICER);
			SW_RTN_ON_ERROR(rv);
#endif

			break;
		#endif
		default:
			break;
	}
	return rv;
}