/*******************************************************************************
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.

******************************************************************************/
/*******************************************************************************
* tpm_ctc_cm.c
*
*
*  MODULE : TPM
*
*  DESCRIPTION : This file config CTC CnM rule
*
*  MODIFICATION HISTORY:
*           7Feb12   jinghua - initial version created.
*
* FILE REVISION NUMBER:
*       Revision: 1.12
*******************************************************************************/
#include "tpm_common.h"
#include "tpm_header.h"
#include "tpm_ctc_cm.h"
#include "tpm_pkt_proc_logic.h"

#define IF_ERROR(ret)		\
	if (ret != TPM_OK) {\
		TPM_OS_ERROR(TPM_CTC_CM_MOD, " recvd ret_code(%d)\n", ret);\
		return(ret);\
	}

/*******************************************************************************
* tpm_ctc_cm_rule_add()
*
* DESCRIPTION:    Main function for adding CnM API rule.
*
* INPUTS:
* ipv4_key_idx       - key for IPv4 sub pattern.
* Other inputs/outputs are same as API call
*
* OUTPUTS:
* rule_index         - CTC CnM rule index
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_rule_add(uint32_t owner_id,
				     tpm_src_port_type_t src_port,
				     uint32_t precedence,
				     tpm_parse_fields_t l2_parse_rule_bm,
				     tpm_parse_fields_t ipv4_parse_rule_bm,
				     tpm_parse_fields_t ipv6_parse_rule_bm,
				     tpm_l2_acl_key_t   *l2_key,
				     tpm_ipv4_acl_key_t *ipv4_key,
				     tpm_ipv6_acl_key_t *ipv6_key,
				     tpm_pkt_frwd_t *pkt_frwd,
				     tpm_pkt_action_t pkt_act,
				     uint32_t pbits,
				     uint32_t ipv4_key_idx,
				     uint32_t *rule_index)
{
	tpm_error_code_t ret_code = ERR_GENERAL;

	if (l2_parse_rule_bm)
		ret_code = tpm_proc_add_l2_cnm_rule(owner_id, src_port, precedence, l2_parse_rule_bm, l2_key,
						    ipv4_parse_rule_bm, ipv4_key, ipv4_key_idx, pkt_frwd,
						    pkt_act, pbits, rule_index);
	else if (ipv4_parse_rule_bm)
		ret_code = tpm_proc_add_ipv4_cnm_rule(owner_id, src_port, precedence, ipv4_parse_rule_bm,
						      ipv4_key, pkt_frwd, pkt_act, pbits, rule_index);
	else if (ipv6_parse_rule_bm)
		ret_code = tpm_proc_add_ipv6_cnm_rule(owner_id, src_port, precedence, ipv6_parse_rule_bm,
						      ipv6_key, pkt_frwd, pkt_act, pbits, rule_index);
	return ret_code;
}

/*******************************************************************************
* tpm_ctc_cm_acl_rule_del()
*
* DESCRIPTION:    Main function for deleting CnM API rule.
*
* INPUTS:
*
* owner_id           - APP owner id  should be used for all API calls.
* cm_rule            - CTC CnM rule data pointer
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_rule_del(uint32_t owner_id, tpm_db_ctc_cm_rule_entry_t  *cm_rule)
{
	tpm_error_code_t ret_code = ERR_GENERAL;

	if ((cm_rule)->l2_parse_rule_bm)
		ret_code = tpm_proc_del_l2_cnm_rule(owner_id, cm_rule->cm_main_rule_index);
	else if ((cm_rule)->ipv4_parse_rule_bm)
		ret_code = tpm_proc_del_ipv4_cnm_rule(owner_id, cm_rule->cm_main_rule_index);
	else if ((cm_rule)->ipv6_parse_rule_bm)
		ret_code = tpm_proc_del_ipv4_cnm_rule(owner_id, cm_rule->cm_main_rule_index);

	return ret_code;
}
/*******************************************************************************
* tpm_ctc_cm_add_rule_check()
*
* DESCRIPTION:    The function checks consistency of the tpm_ctc_cm_acl_rule_add params.
*
* INPUTS:
*                 - See tpm_ctc_cm_acl_rule_add
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_add_rule_check(uint32_t owner_id,
					   tpm_src_port_type_t src_port,
					   uint32_t precedence,
					   tpm_parse_fields_t l2_parse_rule_bm,
					   tpm_parse_fields_t ipv4_parse_rule_bm,
					   tpm_parse_fields_t ipv6_parse_rule_bm,
					   tpm_l2_acl_key_t *l2_key,
					   tpm_ipv4_acl_key_t *ipv4_key,
					   tpm_ipv6_acl_key_t *ipv6_key,
					   tpm_pkt_frwd_t *pkt_frwd,
					   tpm_pkt_action_t pkt_act,
					   uint32_t pbits)
{
	int32_t int_ret_code;
	uint32_t num_rules, dummy_entry = 0;
	uint8_t is_range_full;
	tpm_db_ctc_cm_enable_t ctc_cm_enable = TPM_CTC_CM_DISABLED;
	tpm_db_ctc_cm_ipv6_parse_win_t ctc_cm_ipv6_parse_win;

	tpm_db_ctc_cm_enable_get(&ctc_cm_enable);

	/* if CTC CnM enabled */
	if (ctc_cm_enable == TPM_CTC_CM_DISABLED) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "CTC CnM is disabled!\n");
		return(ERR_GENERAL);
	}

	if (src_port < TPM_SRC_PORT_UNI_0 || src_port > TPM_SRC_PORT_UNI_VIRT) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "src_port (%d) illegal!\n", src_port);
		return(ERR_SRC_PORT_INVALID);
	}

	if (!tpm_db_eth_port_valid(src_port)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "src_port (%d) illegal!\n", src_port);
		return(ERR_SRC_PORT_INVALID);
	}

	if (precedence >= TPM_MAX_NUM_CTC_PRECEDENCE) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "precedence (%d) illegal!\n", precedence);
		return(ERR_CTC_CM_PREC_INVALID);
	}

	num_rules = tpm_db_ctc_cm_get_num_rules(src_port);
	if (precedence > num_rules) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "precedence (%d) must be continous!\n", precedence);
		return(ERR_CTC_CM_PREC_INVALID);
	}

	if (!l2_parse_rule_bm && !ipv4_parse_rule_bm && !ipv6_parse_rule_bm) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "both l2_parse_rule_bm and ipv4_parse_rule_bm are Zero!\n");
		return(ERR_PARSE_MAP_INVALID);
	}

	if (l2_parse_rule_bm & ~(TPM_L2_PARSE_MAC_DA | TPM_L2_PARSE_MAC_SA | TPM_L2_PARSE_ONE_VLAN_TAG |
				 TPM_L2_PARSE_TWO_VLAN_TAG | TPM_L2_PARSE_ETYPE)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "l2_parse_rule_bm (%d) is invalid!\n", l2_parse_rule_bm);
		return(ERR_PARSE_MAP_INVALID);
	}

	if (ipv4_parse_rule_bm & ~(TPM_IPv4_PARSE_SIP | TPM_IPv4_PARSE_DIP | TPM_IPv4_PARSE_DSCP |
				   TPM_IPv4_PARSE_PROTO | TPM_PARSE_L4_SRC | TPM_PARSE_L4_DST)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "ipv4_parse_rule_bm (%d) is invalid!\n", ipv4_parse_rule_bm);
		return(ERR_PARSE_MAP_INVALID);
	}

	/* ipv6_parse_rule_bm depends on ipv6 CnM parse window */
	tpm_db_ctc_cm_ipv6_parse_win_get(&ctc_cm_ipv6_parse_win);
	if(TPM_CTC_CM_IPv6_FIRST_24B == ctc_cm_ipv6_parse_win) {
		if (ipv6_parse_rule_bm & ~(TPM_IPv6_PARSE_SIP | TPM_IPv6_PARSE_DSCP | TPM_IPv6_PARSE_NH |
					   TPM_IPv6_PARSE_HOPL)) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, "ipv6_parse_rule_bm (%d) is invalid!\n", ipv6_parse_rule_bm);
			return(ERR_PARSE_MAP_INVALID);
		}
	} else {
		if (ipv6_parse_rule_bm & ~(TPM_IPv6_PARSE_DIP | TPM_PARSE_L4_SRC | TPM_PARSE_L4_DST)) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, "ipv6_parse_rule_bm (%d) is invalid!\n", ipv6_parse_rule_bm);
			return(ERR_PARSE_MAP_INVALID);
		}
	}

	if (l2_parse_rule_bm && (NULL == l2_key)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "l2_key can not be NULL!\n");
		return(ERR_NULL_POINTER);
	}

	if (ipv4_parse_rule_bm && (NULL == ipv4_key)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "ipv4_key can not be NULL!\n");
		return(ERR_NULL_POINTER);
	}

	if (ipv6_parse_rule_bm && (NULL == ipv6_key)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "ipv6_key can not be NULL!\n");
		return(ERR_NULL_POINTER);
	}

	if (!pkt_act) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "pkt_act is Zero!\n");
		return(ERR_ACTION_INVALID);
	}

	if ((pkt_act & (TPM_ACTION_SET_TARGET_PORT | TPM_ACTION_SET_TARGET_QUEUE)) &&
		(NULL == pkt_frwd)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "pkt_frwd is NULL when TPM_ACTION_SET_TARGET_PORT or"
					     " TPM_ACTION_SET_TARGET_QUEUE!\n");
		return(ERR_NULL_POINTER);
	}

	if (pkt_frwd->trg_port < TPM_TRG_PORT_WAN || pkt_frwd->trg_port > TPM_TRG_LLID_7) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "trg_port (%d) is invalid!\n", pkt_frwd->trg_port);
		return(ERR_FRWD_INVALID);
	}

	if (pkt_act & ~(TPM_ACTION_SET_TARGET_PORT | TPM_ACTION_SET_TARGET_QUEUE | TPM_ACTION_SET_PKT_MOD)) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "pkt_act (%d) is invalid!\n", pkt_act);
		return(ERR_ACTION_INVALID);
	}

	if (pkt_act & TPM_ACTION_SET_PKT_MOD) {
		if (pbits > 7) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, "pbits (%d) is invalid!\n", pbits);
			return(ERR_L2_KEY_INVALID);
		}

		int_ret_code = tpm_db_split_mod_get_index_by_p_bits(pbits, &dummy_entry);
		if (int_ret_code != TPM_DB_OK) {
			TPM_OS_ERROR(TPM_TPM_LOG_MOD, " unsupported p-bit value: %d\n", pbits);
			return(ERR_MOD_INVALID);
		}
	}

	if (l2_parse_rule_bm && ipv4_parse_rule_bm) {
		is_range_full = tpm_proc_if_ipv4_pre_range_is_full(src_port, ipv4_parse_rule_bm, ipv4_key);
		if (is_range_full != TPM_FALSE) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, "not enough room for new ipv4 pre-filter key!\n");
			return(ERR_OUT_OF_RESOURCES);
		}
	}

	is_range_full = tpm_proc_if_cnm_main_range_is_full(src_port, precedence);
	if (is_range_full != TPM_FALSE) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "not enough room for new cnm rule!\n");
		return(ERR_OUT_OF_RESOURCES);
	}

	return TPM_RC_OK;
}

/*******************************************************************************
* tpm_ctc_cm_acl_rule_add()
*
* DESCRIPTION:    Main function for adding CnM API rule.
*
* INPUTS:
*           All inputs/outputs are same as API call
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_acl_rule_add(uint32_t owner_id,
					 tpm_src_port_type_t src_port,
					 uint32_t precedence,
					 tpm_parse_fields_t l2_parse_rule_bm,
					 tpm_parse_fields_t ipv4_parse_rule_bm,
					 tpm_parse_fields_t ipv6_parse_rule_bm,
					 tpm_l2_acl_key_t *l2_key,
					 tpm_ipv4_acl_key_t *ipv4_key,
					 tpm_ipv6_acl_key_t *ipv6_key,
					 tpm_pkt_frwd_t *pkt_frwd,
					 tpm_pkt_action_t pkt_act,
					 uint32_t pbits)
{
	tpm_error_code_t            ret_code;
	tpm_db_error_t              db_ret;
	tpm_db_ctc_cm_rule_entry_t  cm_rule;
	uint32_t                    ipv4_sub_pattern_key_idx = TPM_CNM_INVALID_IPV4_PRE_FILTER_KEY_ID;
	uint32_t                    rule_index;
	uint32_t                    rule_index_tmp;
	uint32_t                    num_prec;
	int32_t                     loop;
	int32_t                     prece_tmp;

	/* Check parameters */
	ret_code = tpm_ctc_cm_add_rule_check(owner_id, src_port, precedence, l2_parse_rule_bm, ipv4_parse_rule_bm,
					     ipv6_parse_rule_bm, l2_key, ipv4_key, ipv6_key, pkt_frwd, pkt_act, pbits);
	IF_ERROR(ret_code);

	/* add IPv4_Pre of Combo rule */
	if (l2_parse_rule_bm && ipv4_parse_rule_bm) {
		ret_code = tpm_proc_add_cnm_ipv4_pre_filter_key(owner_id, src_port, ipv4_parse_rule_bm, ipv4_key,
								&ipv4_sub_pattern_key_idx);
		IF_ERROR(ret_code);
	}

	/* insert new rule */
	ret_code = tpm_ctc_cm_rule_add(owner_id, src_port, precedence, l2_parse_rule_bm, ipv4_parse_rule_bm,
				       ipv6_parse_rule_bm, l2_key, ipv4_key, ipv6_key, pkt_frwd, pkt_act, pbits,
				       ipv4_sub_pattern_key_idx, &rule_index);
	IF_ERROR(ret_code);

	/* update existing rules if needed */
	num_prec = tpm_db_ctc_cm_get_num_rules(src_port);

	/* from the lowest precedence to current precedence, decreased by 1 */
	for (loop = num_prec; loop > precedence; loop--) {

		prece_tmp = loop - 1;
		db_ret = tpm_db_ctc_cm_rule_get(src_port, prece_tmp, &cm_rule);
		if (TPM_DB_OK != db_ret) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
			return ERR_CTC_CM_DB_ERR;
		}

		/* first remvoe the old one, then add the new one  */
		ret_code = tpm_ctc_cm_rule_del(owner_id, &cm_rule);
		IF_ERROR(ret_code);

		/* last prece is 7, do not need to add the rule which has just
		 * been remvoed.
		 */
		if ((TPM_MAX_NUM_CTC_PRECEDENCE - 1) == prece_tmp)
			continue;

		/* add this rule with prece++ */
		ret_code = tpm_ctc_cm_rule_add(owner_id, src_port, prece_tmp + 1, cm_rule.l2_parse_rule_bm,
					       cm_rule.ipv4_parse_rule_bm, cm_rule.ipv6_parse_rule_bm,
					       &(cm_rule.l2_key), &(cm_rule.ipv4_key), &(cm_rule.ipv6_key),
					       &(cm_rule.pkt_frwd), (cm_rule.pkt_act), cm_rule.pbits,
					       cm_rule.ipv4_sub_pattern_key, &rule_index_tmp);
		IF_ERROR(ret_code);

		/* overwrite DB entry of lower precedence */
		db_ret = tpm_db_ctc_cm_rule_set(src_port, prece_tmp + 1, cm_rule.l2_parse_rule_bm,
						cm_rule.ipv4_parse_rule_bm, cm_rule.ipv6_parse_rule_bm,
						&(cm_rule.l2_key), &(cm_rule.ipv4_key), &(cm_rule.ipv6_key),
						&(cm_rule.pkt_frwd), (cm_rule.pkt_act),
						cm_rule.pbits, cm_rule.ipv4_sub_pattern_key, rule_index_tmp);
		if (TPM_DB_OK != db_ret) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
			return ERR_CTC_CM_DB_ERR;
		}

	}

	/* set db of this CnM rule */
	db_ret = tpm_db_ctc_cm_rule_set(src_port, precedence, l2_parse_rule_bm, ipv4_parse_rule_bm,
					ipv6_parse_rule_bm, l2_key, ipv4_key,
					ipv6_key, pkt_frwd, pkt_act, pbits,
					ipv4_sub_pattern_key_idx, rule_index);
	if (TPM_DB_OK != db_ret) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
		return ERR_CTC_CM_DB_ERR;
	}

	return TPM_RC_OK;
}
/*******************************************************************************
* tpm_ctc_cm_del_rule_check()
*
* DESCRIPTION:    The function checks consistency of the tpm_ctc_cm_del_rule_check params.
*
* INPUTS:
*                 - See tpm_ctc_cm_del_rule_check
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_del_rule_check(uint32_t owner_id,
					   tpm_src_port_type_t src_port,
					   uint32_t precedence)
{
	tpm_db_error_t   db_ret;
	tpm_db_ctc_cm_rule_entry_t    cm_rule;
	tpm_db_ctc_cm_enable_t ctc_cm_enable = TPM_CTC_CM_DISABLED;

	tpm_db_ctc_cm_enable_get(&ctc_cm_enable);

	/* if CTC CnM enabled */
	if (ctc_cm_enable == TPM_CTC_CM_DISABLED) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "CTC CnM is disabled!\n");
		return(ERR_GENERAL);
	}

	if (src_port < TPM_SRC_PORT_UNI_0 || src_port > TPM_SRC_PORT_UNI_VIRT) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "src_port (%d) illegal!\n", src_port);
		return(ERR_SRC_PORT_INVALID);
	}

	if (precedence >= TPM_MAX_NUM_CTC_PRECEDENCE) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "precedence (%d) illegal!\n", precedence);
		return(ERR_CTC_CM_PREC_INVALID);
	}

	db_ret = tpm_db_ctc_cm_rule_get(src_port, precedence, &cm_rule);
	if (TPM_DB_OK != db_ret) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "get DB failed, ret_code: (%d), src_port: (%d), precedence: (%d)\n",
			 db_ret, src_port, precedence);
		return(ERR_CTC_CM_DB_ERR);
	}

	return TPM_RC_OK;
}

/*******************************************************************************
* tpm_ctc_cm_acl_rule_del()
*
* DESCRIPTION:    Main function for deleting CnM API rule.
*
* INPUTS:
*		  All inputs/outputs are same as API call
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_acl_rule_del(uint32_t owner_id,
					 tpm_src_port_type_t src_port,
					 uint32_t precedence)
{
	tpm_error_code_t ret_code;
	tpm_db_error_t   db_ret;
	tpm_db_ctc_cm_rule_entry_t  cm_rule;
	uint32_t                    rule_index;
	uint32_t                    num_prec;
	uint32_t                    loop;

	/* Check parameters */
	ret_code = tpm_ctc_cm_del_rule_check(owner_id, src_port, precedence);
	IF_ERROR(ret_code);

	db_ret = tpm_db_ctc_cm_rule_get(src_port, precedence, &cm_rule);
	if (TPM_DB_OK != db_ret) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "get DB failed, ret_code: (%d), src_port: (%d), precedence: (%d)\n",
			     db_ret, src_port, precedence);
		return(ERR_CTC_CM_DB_ERR);
	}

	/* remove rule */
	ret_code = tpm_ctc_cm_rule_del(owner_id, &cm_rule);
	IF_ERROR(ret_code);

	/* remove IPv4_Pre of Combo rule */
	if (cm_rule.l2_parse_rule_bm && cm_rule.ipv4_parse_rule_bm) {
		ret_code = tpm_proc_del_cnm_ipv4_pre_filter_key(owner_id, src_port, cm_rule.ipv4_sub_pattern_key);
		IF_ERROR(ret_code);
	}

	/* update existing rules if needed */
	num_prec = tpm_db_ctc_cm_get_num_rules(src_port);

	/* from the next lower-to current precedence to the lowest precedence, increased by 1 */
	for (loop = precedence + 1; loop < num_prec; loop++) {

		db_ret = tpm_db_ctc_cm_rule_get(src_port, loop, &cm_rule);
		if (TPM_DB_OK != db_ret) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
			return ERR_CTC_CM_DB_ERR;
		}

		/* add this rule with prece++ */
		ret_code = tpm_ctc_cm_rule_add(owner_id, src_port, loop - 1, cm_rule.l2_parse_rule_bm, cm_rule.ipv4_parse_rule_bm,
					       cm_rule.ipv6_parse_rule_bm, &(cm_rule.l2_key), &(cm_rule.ipv4_key),
					       &(cm_rule.ipv6_key), &(cm_rule.pkt_frwd),
					       cm_rule.pkt_act, cm_rule.pbits, cm_rule.ipv4_sub_pattern_key, &rule_index);
		IF_ERROR(ret_code);

		/* overwrite DB entry of higher precedence */
		db_ret = tpm_db_ctc_cm_rule_set(src_port, loop - 1, cm_rule.l2_parse_rule_bm, cm_rule.ipv4_parse_rule_bm,
					cm_rule.ipv6_parse_rule_bm, &(cm_rule.l2_key),
					&(cm_rule.ipv4_key), &(cm_rule.ipv6_key),
					&(cm_rule.pkt_frwd), cm_rule.pkt_act,
					cm_rule.pbits, cm_rule.ipv4_sub_pattern_key, rule_index);
		if (TPM_DB_OK != db_ret) {
			TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
			return ERR_CTC_CM_DB_ERR;
		}

		/* remove the old one */
		ret_code = tpm_ctc_cm_rule_del(owner_id, &cm_rule);
		IF_ERROR(ret_code);
	}

	/* reset the db of last rule */
	db_ret = tpm_db_ctc_cm_rule_delete(src_port, num_prec - 1);
	if (TPM_DB_OK != db_ret) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, " DB failed, recvd ret_code(%d)\n", db_ret);
		return ERR_CTC_CM_DB_ERR;
	}

	return ret_code;
}

/*******************************************************************************
* tpm_ctc_cm_ipv4_rule2cm()
*
* DESCRIPTION:    check if this rule can goto CnM stage from IPv4 stage.
*
* INPUTS:
* parse_flags_bm     - Bitmap containing the significant flags result of the primary ACL filtering.
* pkt_act            - Action associated to the rule
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns true. On error returns false.
*
* COMMENTS:
*
*******************************************************************************/
bool tpm_ctc_cm_ipv4_rule2cm(tpm_parse_flags_t parse_flags_bm, tpm_rule_action_t *rule_action)
{
	tpm_db_ctc_cm_enable_t ctc_cm_enable = TPM_CTC_CM_DISABLED;

	tpm_db_ctc_cm_enable_get(&ctc_cm_enable);

	if (ctc_cm_enable == TPM_CTC_CM_DISABLED) {
		/* CTC CnM is disabled */
		return false;
	}

	/* not MTM, not to CPU */
	if (     (parse_flags_bm & TPM_PARSE_FLAG_MTM_FALSE)
	     && !(rule_action->pkt_act & TPM_ACTION_TO_CPU))
		return true;
	else
		return false;
}
/*******************************************************************************
* tpm_ctc_cm_l3_rule2cm_sram()
*
* DESCRIPTION:    check if this rule can goto CnM stage from ETH stage when building sram of ETH rule.
*
* INPUTS:
* parse_flags_bm     - Bitmap containing the significant flags result of the primary ACL filtering.
* pkt_act            - Action associated to the rule
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns true. On error returns false.
*
* COMMENTS:
*
*******************************************************************************/
bool tpm_ctc_cm_l3_rule2cm_sram(tpm_parse_flags_t parse_flags_bm, tpm_rule_action_t *rule_action)
{
	tpm_db_ctc_cm_enable_t ctc_cm_enable = TPM_CTC_CM_DISABLED;

	tpm_db_ctc_cm_enable_get(&ctc_cm_enable);

	if (ctc_cm_enable == TPM_CTC_CM_DISABLED) {
		/* CTC CnM is disabled */
		return false;
	}

	/* [!mac-to-me] */
	if (parse_flags_bm & TPM_PARSE_FLAG_MTM_FALSE)
		return true;
	else
		return false;
}
/*******************************************************************************
* tpm_ctc_cm_l3_rule2cm_sram()
*
* DESCRIPTION:    check if this rule can goto CnM stage from ETH stage when building tcam of ETH rule.
*
* INPUTS:
* parse_flags_bm     - Bitmap containing the significant flags result of the primary ACL filtering.
* l3_key             - Structure for PPPoE proto or ether type. In order to define a rule for
*                      any ether type, the ether type value should be set to 0xFFFF
* rule_action        -used to get the next_stage of this rule

* OUTPUTS:
*
* RETURNS:
* On success, the function returns true. On error returns false.
*
* COMMENTS:
*
*******************************************************************************/
bool tpm_ctc_cm_l3_rule2cm_tcam(tpm_parse_flags_t parse_flags_bm, tpm_l3_type_key_t *l3_key, tpm_rule_action_t *rule_action)
{
	tpm_db_ctc_cm_enable_t ctc_cm_enable = TPM_CTC_CM_DISABLED;

	tpm_db_ctc_cm_enable_get(&ctc_cm_enable);

	if (ctc_cm_enable == TPM_CTC_CM_DISABLED) {
		/* CTC CnM is disabled */
		return false;
	}

	/* not ipv4/6 or pppoe and [!mac-to-me] */
	if (   (0x0800 != l3_key->ether_type_key)
	    && (0x86dd != l3_key->ether_type_key)
	    && (ETH_P_PPP_SES != l3_key->ether_type_key)
	    && (parse_flags_bm & TPM_PARSE_FLAG_MTM_FALSE)
	    && (STAGE_CTC_CM == rule_action->next_phase))
		return true;
	else
		return false;
}

/*******************************************************************************
* tpm_ctc_cm_ipv6_acl_rule_add()
*
* DESCRIPTION:    Main function for adding CnM API rule.
*
* INPUTS:
*           All inputs/outputs are same as API call
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_ipv6_acl_rule_add(uint32_t owner_id,
					      tpm_src_port_type_t src_port,
					      uint32_t precedence,
					      tpm_parse_fields_t ipv6_parse_rule_bm,
					      tpm_ipv6_acl_key_t *ipv6_key,
					      tpm_pkt_frwd_t *pkt_frwd,
					      tpm_pkt_action_t pkt_act,
					      uint32_t pbits)
{
	tpm_error_code_t            ret_code;
	tpm_parse_fields_t          ipv4_parse_rule_bm = 0;
	tpm_parse_fields_t	    l2_parse_rule_bm = 0;
	tpm_l2_acl_key_t            l2_key;
	tpm_ipv4_acl_key_t          ipv4_key;

	ret_code = tpm_ctc_cm_acl_rule_add(owner_id, src_port, precedence, l2_parse_rule_bm,
					   ipv4_parse_rule_bm, ipv6_parse_rule_bm, &l2_key,
					   &ipv4_key, ipv6_key, pkt_frwd, pkt_act, pbits);
	IF_ERROR(ret_code);

	return TPM_RC_OK;
}
/*******************************************************************************
* tpm_ctc_cm_set_ipv6_parse_win()
*
* DESCRIPTION:    Main function for adding CnM API rule.
*
* INPUTS:
*           All inputs/outputs are same as API call
*
* OUTPUTS:
*
* RETURNS:
* On success, the function returns TPM_RC_OK. On error different types are returned
* according to the case - see tpm_db_err_t.
*
* COMMENTS:
*
*******************************************************************************/
tpm_error_code_t tpm_ctc_cm_set_ipv6_parse_win(uint32_t owner_id, tpm_ctc_cm_ipv6_parse_win_t ipv6_parse_window)
{
	uint32_t                    entry_id;
	uint32_t                    ipv6_rule_nums;
	int32_t                     ret_code = TPM_OK;
	tpm_db_ctc_cm_ipv6_parse_win_t ipv6_parse_win_orig;

	tpm_db_ctc_cm_ipv6_parse_win_get(&ipv6_parse_win_orig);
	if (ipv6_parse_window == ipv6_parse_win_orig) {
		TPM_OS_INFO(TPM_CTC_CM_MOD, "ipv6 parse win remains the same\n");
		return TPM_OK;
	}

	/* if there is still IPv6 CnM rule exist, reture error */
	ipv6_rule_nums = tpm_db_ctc_cm_get_ipv6_num_rules();
	if (0 != ipv6_rule_nums) {
		TPM_OS_ERROR(TPM_CTC_CM_MOD, "there is still IPv6 CnM rule exist, remove first!\n");
		return ERR_CTC_CM_DB_ERR;
	}

	/* get ipv6_ety_rule_num */
	tpm_db_ctc_cm_ipv6_ety_rule_num_get(&entry_id);

	ret_code = tpm_pncl_init_cnm_main_ety_ipv6(entry_id, ipv6_parse_window);
	IF_ERROR(ret_code);

	/* set new ipv6 parse window */
	tpm_db_ctc_cm_ipv6_parse_win_set(ipv6_parse_window);

	return TPM_RC_OK;
}