/*******************************************************************************
Copyright (C) Marvell International Ltd. and its affiliates

This software file (the "File") is owned and distributed by Marvell 
International Ltd. and/or its affiliates ("Marvell") under the following
alternative licensing terms.  Once you have made an election to distribute the
File under one of the following license alternatives, please (i) delete this
introductory statement regarding license alternatives, (ii) delete the two
license alternatives that you have not elected to use and (iii) preserve the
Marvell copyright notice above.

********************************************************************************
Marvell Commercial License Option

If you received this File from Marvell and you have entered into a commercial
license agreement (a "Commercial License") with Marvell, the File is licensed
to you under the terms of the applicable Commercial License.

********************************************************************************
Marvell GPL License Option

If you received this File from Marvell, you may opt to use, redistribute and/or 
modify this File in accordance with the terms and conditions of the General 
Public License Version 2, June 1991 (the "GPL License"), a copy of which is 
available along with the File in the license.txt file or by writing to the Free 
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or 
on the worldwide web at http://www.gnu.org/licenses/gpl.txt. 

THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED 
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY 
DISCLAIMED.  The GPL License provides additional details about this warranty 
disclaimer.
********************************************************************************
Marvell BSD License Option

If you received this File from Marvell, you may opt to use, redistribute and/or 
modify this File under the following licensing terms. 
Redistribution and use in source and binary forms, with or without modification, 
are permitted provided that the following conditions are met:

    *   Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer. 

    *   Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution. 

    *   Neither the name of Marvell nor the names of its contributors may be 
        used to endorse or promote products derived from this software without 
        specific prior written permission. 
    
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************
* mv_cph_db.c
*
* DESCRIPTION: Marvell CPH(CPH Packet Handler) data base implementation
*
* DEPENDENCIES:
*               None
*
* CREATED BY:   VictorGu
*
* DATE CREATED: 22Jan2013
*
* FILE REVISION NUMBER:
*               Revision: 1.0
*
*
*******************************************************************************/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/poll.h>
#include <linux/clk.h>
#include <linux/fs.h>
#include <linux/vmalloc.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/miscdevice.h>

#include "mv_cph_header.h"
#include "ezxml.h"


/******************************************************************************
 * Variable Definition
 ******************************************************************************/
static CPH_APP_DB_T g_cph_app_db;
CHAR *g_cph_xml_cfg_file         = US_CPH_XML_CFG_FILE;
CHAR *g_onu_profile_xml_cfg_file = US_ONU_PROFILE_XML_CFG_FILE;


/******************************************************************************
 * Function Definition
 ******************************************************************************/
/******************************************************************************
* cph_db_set_param()
* _____________________________________________________________________________
*
* DESCRIPTION: Set CPH DB parameter
*
* INPUTS:
*       param   - The parameter type
*       value   - Parameter value
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_set_param (CPH_DB_PARAM_E param, VOID *value)
{
    MV_STATUS rc = MV_OK;

    switch (param)
    {
        case CPH_DB_PARAM_PROFILE_ID:
            g_cph_app_db.profile_id   = *(tpm_eth_complex_profile_t *)value;
            break;
        case CPH_DB_PARAM_ACTIVE_PORT:
            g_cph_app_db.active_port  = *(MV_APP_GMAC_PORT_E *)value;
            break;
        case CPH_DB_PARAM_APP_SUPPORT:
            g_cph_app_db.app_support  = *(BOOL *)value;
            break;            
        case CPH_DB_PARAM_IGMP_SUPPORT:
            g_cph_app_db.igmp_support = *(BOOL *)value;
            break;
        case CPH_DB_PARAM_BC_SUPPORT:
            g_cph_app_db.bc_support   = *(BOOL *)value;
            break;
        case CPH_DB_PARAM_FLOW_SUPPORT:
            g_cph_app_db.flow_support = *(BOOL *)value;
            break;
        case CPH_DB_PARAM_UDP_SUPPORT:
            g_cph_app_db.udp_support  = *(BOOL *)value;            
            break;
        case CPH_DB_PARAM_BC_COUNTER:
            g_cph_app_db.bc_count     = *(UINT32 *)value;            
            break;
        default:
            break;
    }

    return rc;
}

/******************************************************************************
* cph_db_get_param()
* _____________________________________________________________________________
*
* DESCRIPTION: Get CPH DB parameter
*
* INPUTS:
*       param   - The parameter type
*
* OUTPUTS:
*       value   - Parameter value
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_get_param (CPH_DB_PARAM_E param, VOID *value)
{
    MV_STATUS rc = MV_OK;

    switch (param)
    {
        case CPH_DB_PARAM_PROFILE_ID:
            *(tpm_eth_complex_profile_t *)value = g_cph_app_db.profile_id;
            break;
        case CPH_DB_PARAM_ACTIVE_PORT:
            *(MV_APP_GMAC_PORT_E *)value = g_cph_app_db.active_port;
            break;
        case CPH_DB_PARAM_APP_SUPPORT:
            *(BOOL *)value = g_cph_app_db.app_support;
            break;            
        case CPH_DB_PARAM_IGMP_SUPPORT:
            *(BOOL *)value = g_cph_app_db.igmp_support;
            break;
        case CPH_DB_PARAM_BC_SUPPORT:
            *(BOOL *)value = g_cph_app_db.bc_support;
            break;
        case CPH_DB_PARAM_FLOW_SUPPORT:
            *(BOOL *)value = g_cph_app_db.flow_support;
            break;
        case CPH_DB_PARAM_UDP_SUPPORT:
            *(BOOL *)value = g_cph_app_db.udp_support;
            break;
        case CPH_DB_PARAM_BC_COUNTER:
            *(UINT32 *)value = g_cph_app_db.bc_count;
            break;            
        default:
            break;
    }
    return rc;
}

/******************************************************************************
* cph_db_compare_rules()
* _____________________________________________________________________________
*
* DESCRIPTION: Compare the parse_bm and parse_key of two rules
*
* INPUTS:
*       parse_bm_1   - Parsing bitmap of first CPH rule
*       parse_key_1  - Parsing key of first CPH rule
*       parse_bm_2   - Parsing bitmap of second CPH rule
*       parse_key_2  - Parsing key of second CPH rule
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       In case same, return TRUE, 
*       In case different, return FALSE.
*******************************************************************************/
BOOL cph_db_compare_rules (
    CPH_APP_PARSE_FIELD_E parse_bm_1, 
    CPH_APP_PARSE_T      *parse_key_1, 
    CPH_APP_PARSE_FIELD_E parse_bm_2,
    CPH_APP_PARSE_T      *parse_key_2)
{
    if (parse_bm_1 == parse_bm_2)
    {
        /* Compare direction */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_DIR)
        {
            if (parse_key_1->dir != parse_key_2->dir)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old dir[%d], new dir[%d] \n", parse_key_1->dir, parse_key_2->dir);
                return FALSE;
            }
        }

        /* Compare RX direction */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_RX_TX)
        {
            if (parse_key_1->rx_tx != parse_key_2->rx_tx)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old rx_tx[%d], new rx_tx[%d] \n", parse_key_1->rx_tx, parse_key_2->rx_tx);
                return FALSE;
            }
        }
        
        /* Compare Marvell header */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_MH)
        {
            if (parse_key_1->mh != parse_key_2->mh)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old mh[%d], new mh[%d] \n", parse_key_1->mh, parse_key_2->mh);
                return FALSE;
            }
        }

        /* Compare Eth type */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_ETH_TYPE)
        {
            if (parse_key_1->eth_type!= parse_key_2->eth_type)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old eth_type[%d], new eth_type[%d] \n", parse_key_1->eth_type, parse_key_2->eth_type);
                return FALSE;
            }
        }
        
        /* Compare Eth subtype */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_ETH_SUBTYPE)
        {
            if (parse_key_1->eth_subtype != parse_key_2->eth_subtype)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old eth_subtype[%d], new eth_subtype[%d] \n", parse_key_1->eth_subtype, parse_key_2->eth_subtype);
                return FALSE;
            }
        }

        /* Compare IPV4 type */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_IPV4_TYPE)
        {
            if (parse_key_1->ipv4_type != parse_key_2->ipv4_type)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old ipv4_type[%d], new ipv4_type[%d] \n", parse_key_1->ipv4_type, parse_key_2->ipv4_type);
                return FALSE;
            }
        }

        /* Compare IPV6 type */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_IPV6_NH1)
        {
            if (parse_key_1->ipv6_nh1 != parse_key_2->ipv6_nh1)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old ipv6_nh1[%d], new ipv6_nh1[%d] \n", parse_key_1->ipv6_nh1, parse_key_2->ipv6_nh1);
                return FALSE;
            }
        }

        /* Compare IPv6 NH */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_IPV6_NH2)
        {
            if (parse_key_1->ipv6_nh2!= parse_key_2->ipv6_nh2)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old ipv6_nh2[%d], new ipv6_nh2[%d] \n", parse_key_1->ipv6_nh2, parse_key_2->ipv6_nh2);
                return FALSE;
            }
        }

        /* Compare ICMPv6 type */
        if (parse_bm_1 & CPH_APP_PARSE_FIELD_ICMPV6_TYPE)
        {
            if (parse_key_1->icmpv6_type != parse_key_2->icmpv6_type)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Old icmpv6_type[%d], new icmpv6_type[%d] \n", parse_key_1->icmpv6_type, parse_key_2->icmpv6_type);
                return FALSE;
            }
        }

        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/******************************************************************************
* cph_db_compare_rule_and_packet()
* _____________________________________________________________________________
*
* DESCRIPTION: Compare the parse_bm and parse_key of CPH and the packet
*
* INPUTS:
*       parse_bm_rule     - Parsing bitmap of CPH rule
*       parse_key_rule    - Parsing key of CPH rule
*       parse_bm_packet   - Parsing bitmap of packet
*       parse_key_packet  - Parsing key of packet
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       In case same, return TRUE, 
*       In case different, return FALSE.
*******************************************************************************/
BOOL cph_db_compare_rule_and_packet (
    CPH_APP_PARSE_FIELD_E parse_bm_rule,
    CPH_APP_PARSE_T      *parse_key_rule,
    CPH_APP_PARSE_FIELD_E parse_bm_packet,
    CPH_APP_PARSE_T      *parse_key_packet)
{  
    /* Check direction */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_DIR)
    {
        if (parse_key_rule->dir != CPH_DIR_NOT_CARE)
        {
            if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_DIR))
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no dir field\n");
                return FALSE;
            }
            
            if (parse_key_rule->dir != parse_key_packet->dir)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet dir[%d] is different with rule dir[%d], mis-mathced!\n", parse_key_packet->dir, parse_key_rule->dir);
                return FALSE;
            }
        }
    }

    /* Check RX/TX direction */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_RX_TX)
    {
        if (parse_key_rule->rx_tx != CPH_RX_TX_NOT_CARE)
        {
            if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_RX_TX))
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no dir RX/TX field\n");
                return FALSE;
            }
            
            if (parse_key_rule->rx_tx != parse_key_packet->rx_tx)
            {
                MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet rx_tx[%d] is different with rule rx_tx[%d], mis-mathced!\n", parse_key_packet->rx_tx, parse_key_rule->rx_tx);
                return FALSE;
            }
        }
    }

    /* Check Marvell header */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_MH)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_MH))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no MH field\n");
            return FALSE;
        }
        
        if (parse_key_rule->mh != parse_key_packet->mh)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet mh[0x%x] is different with rule mh[0x%x], mis-mathced!\n", parse_key_packet->mh, parse_key_rule->mh);
            return FALSE;
        }
    }

    /* Check Eth type */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_ETH_TYPE)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_ETH_TYPE))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no eth_type field\n");
            return FALSE;
        }
        
        if (parse_key_rule->eth_type != parse_key_packet->eth_type)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet eth_type[0x%x] is different with rule eth_type[0x%x], mis-mathced!\n", parse_key_packet->eth_type, parse_key_rule->eth_type);
            return FALSE;
        }
    }

    /* Check Eth subtype */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_ETH_SUBTYPE)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_ETH_SUBTYPE))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no eth_subtype field\n");
            return FALSE;
        }
        
        if (parse_key_rule->eth_subtype != parse_key_packet->eth_subtype)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet eth_subtype[%d] is different with rule eth_subtype[%d], mis-mathced!\n", parse_key_packet->eth_subtype, parse_key_rule->eth_subtype);
            return FALSE;
        }
    }

    /* Check IPV4 type */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_IPV4_TYPE)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_IPV4_TYPE))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no ipv4_type field\n");
            return FALSE;
        }
        
        if (parse_key_rule->ipv4_type != parse_key_packet->ipv4_type)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet ipv4_type[%d] is different with rule ipv4_type[%d], mis-mathced!\n", parse_key_packet->ipv4_type, parse_key_rule->ipv4_type);
            return FALSE;
        }
    }

    /* Check IPV6 NH1 */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_IPV6_NH1)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_IPV6_NH1))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no ipv6_nh1 field\n");
            return FALSE;
        }
        
        if (parse_key_rule->ipv6_nh1 != parse_key_packet->ipv6_nh1)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet ipv6_nh1[%d] is different with rule ipv6_nh1[%d], mis-mathced!\n", parse_key_packet->ipv6_nh1, parse_key_rule->ipv6_nh1);
            return FALSE;
        }
    }

    /* Check IPv6 NH2 */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_IPV6_NH2)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_IPV6_NH2))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no ipv6_nh2 field\n");
            return FALSE;
        }
        
        if (parse_key_rule->ipv6_nh2 != parse_key_packet->ipv6_nh2)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet ipv6_nh2[%d] is different with rule ipv6_nh2[%d], mis-mathced!\n", parse_key_packet->ipv6_nh2, parse_key_rule->ipv6_nh2);
            return FALSE;
        }
    }

    /* Check ICMPv6 type */
    if (parse_bm_rule & CPH_APP_PARSE_FIELD_ICMPV6_TYPE)
    {
        if (! (parse_bm_packet & CPH_APP_PARSE_FIELD_ICMPV6_TYPE))
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet has no icmpv6_type field\n");
            return FALSE;
        }
        
        if (parse_key_rule->icmpv6_type != parse_key_packet->icmpv6_type)
        {
            MV_CPH_PRINT(CPH_DEBUG_LEVEL, "Packet icmpv6_type[%d] is different with rule icmpv6_type[%d], mis-mathced!\n", parse_key_packet->icmpv6_type, parse_key_rule->icmpv6_type);
            return FALSE;
        }
    }

    return TRUE;
}

/******************************************************************************
* cph_db_check_duplicate_rule()
* _____________________________________________________________________________
*
* DESCRIPTION: Check whether there is duplicate CPH rule w/ same parse bitmap
*              value
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       In case has duplicated rule, return TRUE, 
*       In case has not duplicated rule, return FALSE.
*******************************************************************************/
BOOL cph_db_check_duplicate_rule (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    BOOL             rc          = FALSE;
   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            rc = cph_db_compare_rules(p_cph_rule->parse_bm, &p_cph_rule->parse_key, parse_bm, parse_key);
            if (rc == TRUE)
            {
                return rc;
            }
        }
    }

    return rc;
}

/******************************************************************************
* cph_db_add_app_rule()
* _____________________________________________________________________________
*
* DESCRIPTION: Add application type CPH rule to data base
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*       mod_bm     - Modification bitmap
*       mod_value  - Modification value
*       frwd_bm    - Forwarding bitmap
*       frwd_value - Forwarding value
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_add_app_rule (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key,
    CPH_APP_MOD_FIELD_E   mod_bm,
    CPH_APP_MOD_T        *mod_value,
    CPH_APP_FRWD_FIELD_E  frwd_bm, 
    CPH_APP_FRWD_T       *frwd_value)
{
    UINT32           idx        = 0;
    CPH_APP_RULE_T  *p_cph_rule = NULL;
    BOOL             rc         = TRUE;
    unsigned long    flags;
    
    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);
    /* Seach for an free entry */
    for (idx = 0; idx < CPH_APP_MAX_RULE_NUM; idx++)
    {
        if (g_cph_app_db.cph_rule[idx].valid == FALSE)
            break;
    }

    /* No free entry */
    if (idx == CPH_APP_MAX_RULE_NUM)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "No free CPH entry \n");
        spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
        return MV_FULL;
    }

    /* Do not add new rule if there is already duplicated rule */
    rc = cph_db_check_duplicate_rule(parse_bm, parse_key);
    if (rc == TRUE)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "Already has duplicated rule, could not add new CPH rule \n");
        spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
        return MV_ERROR;
    }        
    
    /* Save CPH rule for application packet */
    p_cph_rule = &g_cph_app_db.cph_rule[idx];
    p_cph_rule->parse_bm = parse_bm;
    memcpy(&p_cph_rule->parse_key,  parse_key,  sizeof(CPH_APP_PARSE_T));
    p_cph_rule->mod_bm   = mod_bm;
    memcpy(&p_cph_rule->mod_value,  mod_value,  sizeof(CPH_APP_MOD_T));
    p_cph_rule->frwd_bm  = frwd_bm;
    memcpy(&p_cph_rule->frwd_value, frwd_value, sizeof(CPH_APP_FRWD_T));
    p_cph_rule->valid    = TRUE;
    g_cph_app_db.rule_num ++;

    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
    return MV_OK;
}

/******************************************************************************
* cph_db_del_app_rule()
* _____________________________________________________________________________
*
* DESCRIPTION: Delete application type CPH rule from data base
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_del_app_rule (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    BOOL             rc          = FALSE;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            rc = cph_db_compare_rules(p_cph_rule->parse_bm, &p_cph_rule->parse_key, parse_bm, parse_key);
            if (rc == TRUE)
            {
                memset(p_cph_rule, 0, sizeof(CPH_APP_RULE_T));
                p_cph_rule->valid = FALSE;
                g_cph_app_db.rule_num --;
                
                spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                return MV_OK;
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return MV_OK;
}

/******************************************************************************
* cph_db_update_app_rule()
* _____________________________________________________________________________
*
* DESCRIPTION: Update application type CPH rule from data base 
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*       mod_bm     - Modification bitmap
*       mod_value  - Modification value
*       frwd_bm    - Forwarding bitmap
*       frwd_value - Forwarding value
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_update_app_rule (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key,  
    CPH_APP_MOD_FIELD_E   mod_bm, 
    CPH_APP_MOD_T        *mod_value, 
    CPH_APP_FRWD_FIELD_E  frwd_bm, 
    CPH_APP_FRWD_T       *frwd_value)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    BOOL             rc          = FALSE;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            rc = cph_db_compare_rules(p_cph_rule->parse_bm, &p_cph_rule->parse_key, parse_bm, parse_key);
            if (rc == TRUE)
            {
                p_cph_rule->mod_bm   = mod_bm;
                memcpy(&p_cph_rule->mod_value,  mod_value,  sizeof(CPH_APP_MOD_T));
                p_cph_rule->frwd_bm  = frwd_bm;
                memcpy(&p_cph_rule->frwd_value, frwd_value, sizeof(CPH_APP_FRWD_T));

                spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                return MV_OK;
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return MV_OK;
}

/******************************************************************************
* cph_db_get_app_rule()
* _____________________________________________________________________________
*
* DESCRIPTION: Get application type CPH rule from data base 
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*
* OUTPUTS:
*       mod_bm     - Modification bitmap
*       mod_value  - Modification value
*       frwd_bm    - Forwarding bitmap
*       frwd_value - Forwarding value
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_get_app_rule (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key,  
    CPH_APP_MOD_FIELD_E  *mod_bm, 
    CPH_APP_MOD_T        *mod_value, 
    CPH_APP_FRWD_FIELD_E *frwd_bm, 
    CPH_APP_FRWD_T       *frwd_value)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    BOOL             rc          = FALSE;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            rc = cph_db_compare_rule_and_packet(p_cph_rule->parse_bm, &p_cph_rule->parse_key, parse_bm, parse_key);
            if (rc == TRUE)
            {   
                if (p_cph_rule->mod_value.state == TRUE) 
                {
                    *mod_bm  = p_cph_rule->mod_bm;
                    memcpy(mod_value, &p_cph_rule->mod_value, sizeof(CPH_APP_MOD_T));
                    *frwd_bm = p_cph_rule->frwd_bm;
                    memcpy(frwd_value, &p_cph_rule->frwd_value, sizeof(CPH_APP_FRWD_T));

                    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                    return MV_OK;
               }
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return MV_FAIL;
}

/******************************************************************************
* cph_db_get_app_rule_by_dir_proto()
* _____________________________________________________________________________
*
* DESCRIPTION: Get application type CPH rule from data base by protocol type
*
* INPUTS:
*       dir        - Direction
*       proto_type - SKB protocol type
*
* OUTPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*       mod_bm     - Modification bitmap
*       mod_value  - Modification value
*       frwd_bm    - Forwarding bitmap
*       frwd_value - Forwarding value
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_get_app_rule_by_dir_proto (
    CPH_DIR_E              dir,
    UINT16                 proto_type,
    CPH_APP_PARSE_FIELD_E *parse_bm,
    CPH_APP_PARSE_T       *parse_key,    
    CPH_APP_MOD_FIELD_E   *mod_bm, 
    CPH_APP_MOD_T         *mod_value, 
    CPH_APP_FRWD_FIELD_E  *frwd_bm, 
    CPH_APP_FRWD_T        *frwd_value)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            if ((p_cph_rule->mod_bm & CPH_APP_RX_MOD_REPLACE_PROTO_TYPE) &&
                (p_cph_rule->mod_value.proto_type == proto_type) &&
                (p_cph_rule->mod_value.state      == TRUE))
            {
                if ((p_cph_rule->parse_bm & CPH_APP_PARSE_FIELD_DIR) &&
                    ((p_cph_rule->parse_key.dir == CPH_DIR_NOT_CARE)||(p_cph_rule->parse_key.dir == dir)) &&
                     (p_cph_rule->parse_bm & CPH_APP_PARSE_FIELD_RX_TX) &&
                     (p_cph_rule->parse_key.rx_tx == CPH_DIR_TX))
                {
                    *parse_bm = p_cph_rule->parse_bm;
                    memcpy(parse_key, &p_cph_rule->parse_key, sizeof(CPH_APP_PARSE_T));
                    *mod_bm   = p_cph_rule->mod_bm;
                    memcpy(mod_value, &p_cph_rule->mod_value, sizeof(CPH_APP_MOD_T));
                    *frwd_bm  = p_cph_rule->frwd_bm;
                    memcpy(frwd_value, &p_cph_rule->frwd_value, sizeof(CPH_APP_FRWD_T));

                    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                    return MV_OK;
                }
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return MV_FAIL;
}

/******************************************************************************
* cph_db_increase_counter()
* _____________________________________________________________________________
*
* DESCRIPTION: Increase RX counter
*
* INPUTS:
*       parse_bm   - Parsing bitmap
*       parse_key  - Parsing key
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_increase_counter (
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    BOOL             rc          = MV_FAIL;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare parse_bm and parse_key */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            rc = cph_db_compare_rule_and_packet(p_cph_rule->parse_bm, &p_cph_rule->parse_key, parse_bm, parse_key);
            if (rc == TRUE)
            {   
                if (p_cph_rule->mod_value.state == TRUE) 
                {
                    p_cph_rule->count++;

                    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                    return MV_OK;
               }
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return rc;
}

/******************************************************************************
* cph_db_increase_counter_by_dir_proto()
* _____________________________________________________________________________
*
* DESCRIPTION:  Increase RX counter according to protocol type
*
* INPUTS:
*       dir        - Direction
*       proto_type - SKB protocol type
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_increase_counter_by_dir_proto (CPH_DIR_E dir,
    UINT16    proto_type)
{
    UINT32           idx         = 0;
    UINT32           rule_idx    = 0;
    CPH_APP_RULE_T  *p_cph_rule  = NULL;
    unsigned long    flags;

    spin_lock_irqsave(&g_cph_app_db.app_lock, flags);   
    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        
        /* Compare dir and protocol type */
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;

            if ((p_cph_rule->mod_bm & CPH_APP_RX_MOD_REPLACE_PROTO_TYPE) &&
                (p_cph_rule->mod_value.proto_type == proto_type) &&
                (p_cph_rule->mod_value.state      == TRUE))
            {
               if ((p_cph_rule->parse_bm & CPH_APP_PARSE_FIELD_DIR) &&
                    ((p_cph_rule->parse_key.dir == CPH_DIR_NOT_CARE) || 
                     (p_cph_rule->parse_key.dir == dir)) &&
                     (p_cph_rule->parse_bm & CPH_APP_PARSE_FIELD_RX_TX) &&
                     (p_cph_rule->parse_key.rx_tx == CPH_DIR_TX))
                {
                    p_cph_rule->count++;

                    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);
                    return MV_OK;
                }            
            }
        }
    }
    spin_unlock_irqrestore(&g_cph_app_db.app_lock, flags);

    return MV_OK;

}

/******************************************************************************
* cph_db_get_xml_param()
* _____________________________________________________________________________
*
* DESCRIPTION: Get the XML parameter
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_get_xml_param(VOID)
{
    ezxml_t     xml_head;
    ezxml_t     xml_element;
    ezxml_t     xml_attr;
    UINT32      attr_value = 0;
    BOOL        bool_value = TRUE;
    const CHAR *name       = NULL;
    const CHAR *value      = NULL;  
    INT32       rc         = MV_OK;

    /* Read ONU profile XML file */
    if ((xml_head = ezxml_parse_file(g_onu_profile_xml_cfg_file)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_parse_file() of %s failed", __FUNCTION__, g_onu_profile_xml_cfg_file);
        rc = MV_NOT_FOUND;        
        goto free_exit;
    }

    if ((xml_element = ezxml_get(xml_head, XML_PROFILE_ELM_CAPABILITY, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_PROFILE_ELM_CAPABILITY);
        rc = MV_FAIL;        
        goto free_exit;

    }
    
    for (xml_attr = ezxml_child(xml_element, XML_PROFILE_ELM_ATTRIB); xml_attr; xml_attr = xml_attr->next)
    { 
        /* Parse attribute type and value */
        name = ezxml_attr(xml_attr, XML_PROFILE_ATTR_NAME);
        if (name == NULL)
        {
            MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_attr() of %s failed\n", __FUNCTION__, XML_PROFILE_ATTR_NAME);
            rc = MV_NOT_FOUND;        
            goto free_exit;
        }

        if (strcmp(name, XML_PROFILE_NAME_PROFILE) == 0)
        {
            value = ezxml_attr(xml_attr, XML_PROFILE_ATTR_VALUE);
            if (value == NULL)
            {
                MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_attr() of %s failed\n", __FUNCTION__, XML_PROFILE_ATTR_VALUE);
                rc = MV_NOT_FOUND;        
                goto free_exit;
            }
            attr_value = mtype_get_digit_num(value);

            cph_db_set_param(CPH_DB_PARAM_PROFILE_ID, &attr_value);
        } 
        else if (strcmp(name, XML_PROFILE_NAME_ACTIVE_PORT) == 0)
        {
            value = ezxml_attr(xml_attr, XML_PROFILE_ATTR_VALUE);
            if (value == NULL)
            {
                MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_attr() of %s failed\n", __FUNCTION__, XML_PROFILE_ATTR_VALUE);
                rc = MV_NOT_FOUND;        
                goto free_exit;
            }
            attr_value = mtype_get_digit_num(value);

            cph_db_set_param(CPH_DB_PARAM_ACTIVE_PORT, &attr_value);
            break;
        }
    }
    ezxml_free(xml_head);

    /* Read CPH XML file */
    if ((xml_head = ezxml_parse_file(g_cph_xml_cfg_file)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_parse_file() of %s failed", __FUNCTION__, g_cph_xml_cfg_file);
        rc = MV_NOT_FOUND;        
        goto free_exit;
    }

    /* Read application support flag*/
    if ((xml_element = ezxml_get(xml_head, XML_CPH_ELM_APP_SUPPORT, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_CPH_ELM_APP_SUPPORT);
        rc = MV_FAIL;        
        goto free_exit;
    }
    if (xml_element->txt == NULL)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: xml_element->txt == NULL \n", __FUNCTION__);
        rc = MV_FAIL;        
        goto free_exit;
    }
    attr_value = mtype_get_digit_num(xml_element->txt);
    bool_value = (attr_value != 0)? TRUE:FALSE;
    cph_db_set_param(CPH_DB_PARAM_APP_SUPPORT, &bool_value);

    /* Read IGMP support flag*/
    if ((xml_element = ezxml_get(xml_head, XML_CPH_ELM_IGMP_SUPPORT, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_CPH_ELM_IGMP_SUPPORT);
        rc = MV_FAIL;        
        goto free_exit;
    }
    if (xml_element->txt == NULL)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: xml_element->txt == NULL \n", __FUNCTION__);
        rc = MV_FAIL;        
        goto free_exit;
    }
    attr_value = mtype_get_digit_num(xml_element->txt);
    bool_value = (attr_value != 0)? TRUE:FALSE;
    cph_db_set_param(CPH_DB_PARAM_IGMP_SUPPORT, &bool_value);

    /* Read BC support flag*/
    if ((xml_element = ezxml_get(xml_head, XML_CPH_ELM_BC_SUPPORT, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_CPH_ELM_BC_SUPPORT);
        rc = MV_FAIL;        
        goto free_exit;
    }
    if (xml_element->txt == NULL)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: xml_element->txt == NULL \n", __FUNCTION__);
        rc = MV_FAIL;        
        goto free_exit;
    }
    attr_value = mtype_get_digit_num(xml_element->txt);
    bool_value = (attr_value != 0)? TRUE:FALSE;
    cph_db_set_param(CPH_DB_PARAM_BC_SUPPORT, &bool_value);

    /* Read Data flow mapping support flag*/
    if ((xml_element = ezxml_get(xml_head, XML_CPH_ELM_FLOW_SUPPORT, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_CPH_ELM_FLOW_SUPPORT);
        rc = MV_FAIL;        
        goto free_exit;
    }
    if (xml_element->txt == NULL)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: xml_element->txt == NULL \n", __FUNCTION__);
        rc = MV_FAIL;        
        goto free_exit;
    }
    attr_value = mtype_get_digit_num(xml_element->txt);
    bool_value = (attr_value != 0)? TRUE:FALSE;
    cph_db_set_param(CPH_DB_PARAM_FLOW_SUPPORT, &bool_value);

    /* Read UDP port mapping support flag*/
    if ((xml_element = ezxml_get(xml_head, XML_CPH_ELM_UDP_SUPPORT, -1)) == 0)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: ezxml_get() of %s failed\n", __FUNCTION__, XML_CPH_ELM_UDP_SUPPORT);
        rc = MV_FAIL;        
        goto free_exit;
    }
    if (xml_element->txt == NULL)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "%s: xml_element->txt == NULL \n", __FUNCTION__);
        rc = MV_FAIL;        
        goto free_exit;
    }
    attr_value = mtype_get_digit_num(xml_element->txt);
    bool_value = (attr_value != 0)? TRUE:FALSE;
    cph_db_set_param(CPH_DB_PARAM_UDP_SUPPORT, &bool_value);

free_exit:
    ezxml_free(xml_head);
    return rc;        
}

/*******************************************************************************
**
** cph_db_get_tcont_state
** ___________________________________________________________________________
**
** DESCRIPTION: The function get T-CONT state
**
** INPUTS:
**   tcont - T-CONT
**
** OUTPUTS:
**   None. 
**
** RETURNS:     
**   state - State of T-CONT, enabled or disabled.  
**
*******************************************************************************/
BOOL cph_db_get_tcont_state(UINT32 tcont)
{
    /* Check tcont */
    if (tcont >= MV_TCONT_LLID_NUM)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "tcont[%d] is illegal, should be less than [%d]\n", tcont, MV_TCONT_LLID_NUM); 
        return FALSE;
    }

    return g_cph_app_db.tcont_state[tcont];
}

/*******************************************************************************
**
** cph_db_set_tcont_state
** ___________________________________________________________________________
**
** DESCRIPTION: The function sets T-CONT state in mv_cph
**
** INPUTS:
**   tcont - T-CONT
**   state - State of T-CONT, enabled or disabled.
**
** OUTPUTS:
**   None. 
**
** RETURNS:     
**  On success, the function returns (MV_OK). On error different types are 
**  returned according to the case.  
**
*******************************************************************************/
MV_STATUS cph_db_set_tcont_state(UINT32 tcont, BOOL state)
{
    /* Check tcont */
    if (tcont >= MV_TCONT_LLID_NUM)
    {
        MV_CPH_PRINT(CPH_ERR_LEVEL, "tcont[%d] is illegal, should be less than [%d]\n", tcont, MV_TCONT_LLID_NUM); 
        return MV_FAIL;
    }

    /* Apply t-cont state to mv_cph */
    g_cph_app_db.tcont_state[tcont] = state;

    return MV_OK;
}

/******************************************************************************
* cph_db_display_parse_field()
* _____________________________________________________________________________
*
* DESCRIPTION: Display CPH rule parsing field
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_display_parse_field(
    CPH_APP_PARSE_FIELD_E parse_bm, 
    CPH_APP_PARSE_T      *parse_key)
{
    printk(KERN_INFO "Parse field(0x%x): ", parse_bm);    

    /* Print direction */
    if (parse_bm & CPH_APP_PARSE_FIELD_DIR)
    {
        printk(KERN_INFO "Dir(%s), ", cph_app_lookup_dir(parse_key->dir));
    }

    /* Print TX/RX direction */
    if (parse_bm & CPH_APP_PARSE_FIELD_RX_TX)
    {
        printk(KERN_INFO "RX/TX(%s), ", cph_app_lookup_rx_tx(parse_key->rx_tx));
    }

    /* Print Marvell header */
    if (parse_bm & CPH_APP_PARSE_FIELD_MH)
    {
        printk(KERN_INFO "MH(0x%x), ", parse_key->mh);
    }

    /* Print Eth type */
    if (parse_bm & CPH_APP_PARSE_FIELD_ETH_TYPE)
    {
        printk(KERN_INFO "Eth type(0x%04x), ", parse_key->eth_type);
    }

    /* Print Eth subtype */
    if (parse_bm & CPH_APP_PARSE_FIELD_ETH_SUBTYPE)
    {
        printk(KERN_INFO "Eth subtype(%d), ", parse_key->eth_subtype);
    }

    /* Print IPV4 type */
    if (parse_bm & CPH_APP_PARSE_FIELD_IPV4_TYPE)
    {
        printk(KERN_INFO "IPv4 type(%d), ", parse_key->ipv4_type);
    }

    /* Print IPv6 NH1 */
    if (parse_bm & CPH_APP_PARSE_FIELD_IPV6_NH1)
    {
        printk(KERN_INFO "IPv6 NH1(%d), ", parse_key->ipv6_nh1);
    }

    /* Print IPv6 NH2 */
    if (parse_bm & CPH_APP_PARSE_FIELD_IPV6_NH2)
    {
        printk(KERN_INFO "IPv6 NH2(%d), ", parse_key->ipv6_nh2);
    }

    /* Print ICMPv6 type */
    if (parse_bm & CPH_APP_PARSE_FIELD_ICMPV6_TYPE)
    {
        printk(KERN_INFO "ICMPv6 type(%d)", parse_key->icmpv6_type);
    }

    printk(KERN_INFO "\n");

    return MV_OK;
}

/******************************************************************************
* cph_db_display_mod_field()
* _____________________________________________________________________________
*
* DESCRIPTION: Display CPH rule modification field
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_display_mod_field(
    CPH_APP_MOD_FIELD_E   mod_bm,
    CPH_APP_MOD_T        *mod_value)
{
    printk(KERN_INFO "Mod field(0x%x): ", mod_bm);    

    /* Print protocol type */
    if (mod_bm & CPH_APP_RX_MOD_REPLACE_PROTO_TYPE)
    {
        printk(KERN_INFO "Proto type(0x%x), ", mod_value->proto_type);
    }

    printk(KERN_INFO "state(%s)", (mod_value->state==TRUE)?"Enabled":"Disabled");

    printk(KERN_INFO "\n");  

    return MV_OK;
}

/******************************************************************************
* cph_db_display_frwd_field()
* _____________________________________________________________________________
*
* DESCRIPTION: Display CPH rule forwarding field
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_display_frwd_field(
    CPH_APP_FRWD_FIELD_E  frwd_bm, 
    CPH_APP_FRWD_T       *frwd_value)
{
    printk(KERN_INFO "Forward field(0x%x): ", frwd_bm);    

    /* Print target port */
    if (frwd_bm & CPH_APP_FRWD_SET_TRG_PORT)
    {
        printk(KERN_INFO "Target port(%d), ", frwd_value->trg_port);
    }

    /* Print target queue */
    if (frwd_bm & CPH_APP_FRWD_SET_TRG_QUEUE)
    {
        printk(KERN_INFO "Target queue(%d), ", frwd_value->trg_queue);
    }

    /* Print GEM port */
    if (frwd_bm & CPH_APP_FRWD_SET_GEM_PORT)
    {
        printk(KERN_INFO "Gem port(%d)", frwd_value->gem_port);
    }    


    printk(KERN_INFO "\n");  

    return MV_OK;
}


/******************************************************************************
* cph_db_display_all()
* _____________________________________________________________________________
*
* DESCRIPTION: Display all CPH rules in data base
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_display_all(VOID)
{
    CPH_APP_RULE_T *p_cph_rule = NULL;
    UINT32          idx        = 0;
    UINT32          rule_idx   = 0;

    printk(KERN_INFO "CPH Application Data Base, total rule number[%u]\n", g_cph_app_db.rule_num);
    printk(KERN_INFO "-------------------------------------------------------\n");

    printk(KERN_INFO "TPM complex profile: %s, active WAN: %s\n", 
           cph_app_lookup_profile_id(g_cph_app_db.profile_id), 
           cph_app_lookup_gmac(g_cph_app_db.active_port));

    printk(KERN_INFO "Generic application handling suppport: %s\n", 
       (g_cph_app_db.app_support == TRUE)?"Enabled":"Disabled");
    
#ifdef CONFIG_MV_CPH_IGMP_HANDLE
    printk(KERN_INFO "IGMP/MLD handling suppport: %s\n", 
           (g_cph_app_db.igmp_support == TRUE)?"Enabled":"Disabled");
#endif

#ifdef CONFIG_MV_CPH_BC_HANDLE  
    printk(KERN_INFO "Broadcast handling suppport: %s\n", 
           (g_cph_app_db.bc_support == TRUE)?"Enabled":"Disabled");
#endif

#ifdef CONFIG_MV_CPH_FLOW_MAP_HANDLE   
    printk(KERN_INFO "Data flow mapping/modification suppport: %s\n",     
           (g_cph_app_db.flow_support == TRUE)?"Enabled":"Disabled");
#endif

#ifdef CONFIG_MV_CPH_UDP_SAMPLE_HANDLE
    printk(KERN_INFO "UDP port mapping suppport: %s\n",
           (g_cph_app_db.udp_support == TRUE)?"Enabled":"Disabled");
#endif

    printk(KERN_INFO "-------------------------------------------------------\n");
    
    printk(KERN_INFO "CPH total rule number: %d\n", g_cph_app_db.rule_num);    

    for (idx = 0, rule_idx = 0; (idx < CPH_APP_MAX_RULE_NUM) && (rule_idx < g_cph_app_db.rule_num); idx++)
    {
        p_cph_rule = &g_cph_app_db.cph_rule[idx];
        if (p_cph_rule->valid == TRUE)
        {
            rule_idx++;
            
            printk(KERN_INFO "CPH rule: #%d\n", rule_idx);
            printk(KERN_INFO "-----------------------\n");
            cph_db_display_parse_field(p_cph_rule->parse_bm, &p_cph_rule->parse_key);
            cph_db_display_mod_field(p_cph_rule->mod_bm,     &p_cph_rule->mod_value);
            cph_db_display_frwd_field(p_cph_rule->frwd_bm,   &p_cph_rule->frwd_value);
            printk(KERN_INFO "Counter: %d\n\n", p_cph_rule->count);
        }
    }

    printk(KERN_INFO "Mis-matched or broadcast counter: %d\n", g_cph_app_db.bc_count);    

    printk(KERN_INFO "T-CONT State\n");
    for (idx = 0; idx < MV_TCONT_LLID_NUM; idx++)
    {
        printk(KERN_INFO "T-CONT[%d]: %s\n", idx, (g_cph_app_db.tcont_state[idx] == TRUE)?"TRUE":"FALSE");
    }

    return MV_OK;
}


/******************************************************************************
* cph_db_init()
* _____________________________________________________________________________
*
* DESCRIPTION: Initialize CPH data base 
*
* INPUTS:
*       None.
*
* OUTPUTS:
*       None.
*
* RETURNS:
*       On success, the function returns MV_OK. 
*       On error returns error code accordingly.
*******************************************************************************/
MV_STATUS cph_db_init(VOID)
{
    UINT32    idx = 0;
    MV_STATUS rc  = MV_OK;

    memset(&g_cph_app_db, 0, sizeof(g_cph_app_db));
    for (idx = 0; idx < CPH_APP_MAX_RULE_NUM; idx++)
        g_cph_app_db.cph_rule[idx].valid = FALSE;

    /* Set the default value */
    g_cph_app_db.profile_id   = TPM_PON_WAN_DUAL_MAC_INT_SWITCH;
    g_cph_app_db.active_port  = MV_APP_PON_MAC_PORT;
    g_cph_app_db.app_support  = TRUE;
    g_cph_app_db.igmp_support = FALSE;
    g_cph_app_db.bc_support   = FALSE;
    g_cph_app_db.flow_support = FALSE;
    g_cph_app_db.udp_support  = FALSE;

    for (idx = 0; idx < MV_TCONT_LLID_NUM; idx++)
        g_cph_app_db.tcont_state[idx] = FALSE;

    /* Init spin lock */
    spin_lock_init(&g_cph_app_db.app_lock);

    return rc;
}