| /******************************************************************************* |
| 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_db.c |
| * |
| * DESCRIPTION: |
| * Traffic Processor Manager = TPM |
| * |
| * DEPENDENCIES: |
| * None |
| * |
| * CREATED BY: OctaviaP |
| * |
| * DATE CREATED: |
| * |
| * FILE REVISION NUMBER: |
| * Revision: 1.4 |
| * |
| * |
| *******************************************************************************/ |
| |
| #include "tpm_common.h" |
| #include "tpm_header.h" |
| |
| #include <linux/vmalloc.h> |
| |
| /* Local definitions */ |
| #define PNC_RANGE_OPER(x) tpm_db.pnc_range[x].pnc_range_oper |
| #define PNC_RANGE_CONF(x) tpm_db.pnc_range[x].pnc_range_conf |
| #define TPM_DBVAL_CON(dbval) ((dbval == TPM_DB_VALID) ? TPM_TRUE : TPM_FALSE) |
| #define TPM_DB_DIVIDED_BY_32(x) (x >> 5) |
| #define TPM_DB_MOD_32(x) (x & 0x1f) |
| |
| #define MEM_MARGIN_PATTERN (0xA3) |
| #define API_ENT_I(api_sec, i) tpm_db.api_ent_mem_area[(tpm_db.api_section[api_sec].table_start) + i] |
| #define IF_ERROR(ret) \ |
| if (ret != TPM_DB_OK) { \ |
| TPM_OS_ERROR(TPM_DB_MOD, " recvd ret_code(%d)\n", ret); \ |
| return(ret); \ |
| } |
| #define IF_ERROR_I(ret, i) \ |
| if (ret != TPM_DB_OK) { \ |
| TPM_OS_ERROR(TPM_DB_MOD, " For index(%d), recvd ret_code(%d)\n", i, ret); \ |
| return(ret); \ |
| } |
| |
| /* TODO - change to static variable after updating print functions */ |
| tpm_db_t tpm_db; |
| tpm_db_hot_swap_bak_db_t hot_swap_bak_db; |
| |
| static uint32_t mem_alloc_start_ind; |
| |
| const char *entry_state_str[TPM_MOD_ENTRY_STATUS_MAX] = { "F", "B", "O", "R", "S" }; |
| |
| uint32_t *tpm_db_mod2_jump_booked_entry_bm[TPM_MAX_NUM_GMACS]; |
| uint32_t *tpm_db_mod2_jump_occupied_entry_bm[TPM_MAX_NUM_GMACS]; |
| uint32_t *tpm_db_mod2_jump_split_mod_occupied_entry_bm[TPM_MAX_NUM_GMACS]; |
| uint32_t *tpm_db_mod2_jump_split_mod_all_entry_bm[TPM_MAX_NUM_GMACS]; |
| |
| uint32_t tpm_db_mod2_jump_bm_group; |
| |
| uint32_t *tpm_db_mod2_chain_booked_entry_bm[TPM_MAX_NUM_GMACS][TPM_CHAIN_TYPE_MAX]; |
| uint32_t *tpm_db_mod2_chain_occupied_entry_bm[TPM_MAX_NUM_GMACS][TPM_CHAIN_TYPE_MAX]; |
| |
| uint32_t tpm_db_mod2_chain_bm_group[TPM_CHAIN_TYPE_MAX]; |
| |
| tpm_mod2_jump_pmt_info_t *tpm_db_mod2_jump_pmt_info[TPM_MAX_NUM_GMACS]; |
| tpm_mod2_chain_pmt_info_t *tpm_db_mod2_chain_pmt_info[TPM_MAX_NUM_GMACS]; |
| |
| tpm_mod2_chain_info_t *tpm_db_mod2_chain_info[TPM_MAX_NUM_GMACS][TPM_CHAIN_TYPE_MAX]; |
| |
| tpm_mod2_jump_cfg_t tpm_db_mod2_jump_area_cfg; |
| tpm_mod2_chain_cfg_t tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAX]; |
| |
| uint16_t tpm_mod2_chain_area_base; |
| uint16_t tpm_mod2_total_chain_num; |
| |
| uint8_t tpm_mod2_multicast_mh_enable; |
| uint8_t tpm_mod2_pppoe_add_mod_enable; |
| uint8_t tpm_mod2_double_tag_enable; |
| uint8_t tpm_mod2_udp_checksum_use_init_bm_enable; |
| uint8_t tpm_mod2_udp_checksum_enable; |
| |
| tpm_db_mc_stream_entry_t *tpm_db_mc_stream_table[TPM_MC_MAX_STREAM_NUM]; |
| tpm_db_mc_mac_entry_t *tpm_db_mc_mac_table[TPM_MC_MAX_MAC_NUM]; |
| |
| uint32_t tpm_db_mc_lpbk_entries_num; |
| tpm_db_mc_lpbk_entry_t *tpm_db_mc_lpbk_table[TPM_MC_MAX_LPBK_ENTRIES_NUM]; |
| tpm_db_mc_vlan_entry_t *tpm_db_mc_vlan_xits_table[TPM_MC_MAX_MVLAN_XITS_NUM]; |
| |
| uint8_t tpm_db_mc_virt_uni_entry_state_table[TPM_MC_MAX_STREAM_NUM]; |
| |
| uint8_t tpm_db_mc_igmp_proxy_sa_mac[6]; |
| uint8_t tpm_db_mc_igmp_proxy_sa_mac_valid; |
| |
| static uint32_t tpm_db_global_rule_idx = 1000; |
| |
| /* Function Declarations */ |
| int32_t tpm_db_api_freeentry_get(tpm_api_sections_t api_section, int32_t *index); |
| int32_t tpm_db_api_entry_ind_get(tpm_api_sections_t api_section, uint32_t rule_num, int32_t *index); |
| int32_t tpm_db_mod_shdw_par_check(tpm_gmacs_enum_t gmac, uint32_t mod_entry); |
| |
| |
| /******************************************************************************* |
| * tpm_db_eth_port_conf_get() |
| * |
| * DESCRIPTION: Function to get an ethernet port physical configuration from the DB |
| * |
| * INPUTS: |
| * ext_port - External Port Identifier, can be any positive number |
| * |
| * OUTPUTS: |
| * - See explanation in tpm_db_eth_port_conf_t structure |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| bool tpm_db_eth_port_valid(tpm_src_port_type_t src_port_num) |
| { |
| uint32_t i; |
| |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if ((tpm_db.eth_ports[i].port_src == src_port_num) |
| && (tpm_db.eth_ports[i].valid == TPM_DB_VALID)) |
| return (true); |
| } |
| |
| return false; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_eth_port_conf_get() |
| * |
| * DESCRIPTION: Function to get an ethernet port physical configuration from the DB |
| * |
| * INPUTS: |
| * ext_port - External Port Identifier, can be any positive number |
| * |
| * OUTPUTS: |
| * - See explanation in tpm_db_eth_port_conf_t structure |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_eth_port_conf_get(tpm_src_port_type_t src_port_num, |
| tpm_db_chip_conn_t *chip_con, |
| tpm_db_int_conn_t *int_con, |
| uint32_t *switch_port) |
| { |
| uint32_t i; |
| |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if ((tpm_db.eth_ports[i].port_src == src_port_num) |
| && (tpm_db.eth_ports[i].valid == TPM_DB_VALID)) { |
| *chip_con = tpm_db.eth_ports[i].chip_connect; |
| *int_con = tpm_db.eth_ports[i].int_connect; |
| *switch_port = tpm_db.eth_ports[i].switch_port; |
| return (TPM_DB_OK); |
| } |
| } |
| |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_eth_port_switch_port_get() |
| * |
| * DESCRIPTION: Function to get an ethernet port physical configuration from the DB |
| * |
| * INPUTS: |
| * ext_port - UNI Port Identifier, can be any positive number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns the switch port number. |
| * On error, TPM_DB_ERR_PORT_NUM = 0xFF is returned. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_eth_port_switch_port_get(tpm_src_port_type_t src_port) |
| { |
| uint32_t i; |
| |
| if (TPM_SRC_PORT_UNI_VIRT == src_port) { |
| if (TPM_DB_VALID == tpm_db.func_profile.virt_uni_info.enabled) |
| return tpm_db.func_profile.virt_uni_info.switch_port; |
| else |
| return TPM_DB_ERR_PORT_NUM; |
| } else if (TPM_SRC_PORT_WAN == src_port) { |
| for (i = TPM_ENUM_GMAC_0; i < TPM_MAX_GMAC; i++) { |
| /* in case traffic from WAN, the dest is LAN, |
| so we search for switch port connected to GMAC LAN functionality */ |
| if (TPM_GMAC_FUNC_LAN == tpm_db.gmac_func[i]){ |
| if (TPM_GMAC_CON_SWITCH_4 == tpm_db.gmac_port_conf[i].conn) |
| return TPM_GMAC0_AMBER_PORT_NUM; |
| else |
| return TPM_GMAC1_AMBER_PORT_NUM; |
| } |
| } |
| } else { |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if ((tpm_db.eth_ports[i].port_src == src_port) && |
| (TPM_DB_VALID == tpm_db.eth_ports[i].valid)) |
| return (tpm_db.eth_ports[i].switch_port); |
| } |
| |
| } |
| return (TPM_DB_ERR_PORT_NUM); |
| } |
| uint32_t tpm_db_rule_index_get(void) |
| { |
| return tpm_db_global_rule_idx; |
| } |
| int32_t tpm_db_rule_index_set(uint32_t rule_index) |
| { |
| tpm_db_global_rule_idx = rule_index; |
| return TPM_DB_OK; |
| } |
| void tpm_db_rule_index_incrs(void) |
| { |
| tpm_db_global_rule_idx++; |
| } |
| bool tpm_db_gmac1_lpbk_en_get(void) |
| { |
| return tpm_db.func_profile.gmac1_loopback_en; |
| } |
| void tpm_db_gmac1_lpbk_en_set(bool en) |
| { |
| tpm_db.func_profile.gmac1_loopback_en = en; |
| } |
| bool tpm_db_cpu_wan_lpbk_en_get(void) |
| { |
| return tpm_db.func_profile.cpu_wan_loopback_en; |
| } |
| void tpm_db_cpu_wan_lpbk_en_set(bool en) |
| { |
| tpm_db.func_profile.cpu_wan_loopback_en = en; |
| } |
| bool tpm_db_ds_load_bal_en_get(void) |
| { |
| return tpm_db.func_profile.ds_load_bal_en; |
| } |
| void tpm_db_ds_load_bal_en_set(bool en) |
| { |
| tpm_db.func_profile.ds_load_bal_en = en; |
| } |
| bool tpm_db_switch_active_wan_en_get(void) |
| { |
| return tpm_db.func_profile.switch_active_wan_en; |
| } |
| void tpm_db_switch_active_wan_en_set(bool en) |
| { |
| tpm_db.func_profile.switch_active_wan_en = en; |
| } |
| |
| int32_t tpm_db_get_valid_uni_ports_num(uint32_t *num_ports) |
| { |
| uint32_t i, _num_ports = 0; |
| |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if (tpm_db.eth_ports[i].valid == TPM_DB_VALID) { |
| if (tpm_db.eth_ports[i].port_src >= TPM_SRC_PORT_UNI_0 && |
| tpm_db.eth_ports[i].port_src <= TPM_SRC_PORT_UNI_7) |
| _num_ports++; |
| } |
| } |
| |
| if (tpm_db.func_profile.virt_uni_info.enabled == TPM_DB_VALID) |
| _num_ports++; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_phy_convert_port_index() |
| * |
| * DESCRIPTION: Function to get an ethernet port physical configuration from the DB |
| * |
| * INPUTS: |
| * switch_port - External Port Identifier, can be any positive number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns the switch port number. |
| * On error, TPM_DB_ERR_PORT_NUM = 0xFF is returned. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_phy_convert_port_index(int32_t switch_port) |
| { |
| uint32_t i; |
| |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if ((tpm_db.eth_ports[i].switch_port == switch_port) |
| && (tpm_db.eth_ports[i].valid == TPM_DB_VALID)) |
| return (tpm_db.eth_ports[i].port_src); |
| } |
| |
| return (TPM_DB_ERR_PORT_NUM); |
| } |
| EXPORT_SYMBOL(tpm_db_phy_convert_port_index); |
| |
| /******************************************************************************* |
| * tpm_db_eth_cmplx_profile_set() |
| * |
| * DESCRIPTION: Function to set the Ethernet Complex Profile in the DB |
| * |
| * INPUTS: |
| * eth_cmplx_profile - the profile enumartion number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_eth_cmplx_profile_set(tpm_eth_complex_profile_t eth_cmplx_profile) |
| { |
| tpm_db.eth_cmplx_profile = eth_cmplx_profile; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_eth_cmplx_profile_get() |
| * |
| * DESCRIPTION: Function returns the Ethernet Complex Profile from the DB |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * the profile enumartion number |
| * RETURNS: |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| tpm_eth_complex_profile_t tpm_db_eth_cmplx_profile_get(void) |
| { |
| return tpm_db.eth_cmplx_profile; |
| } |
| |
| |
| /******************************************************************************* |
| * tpm_db_mac_func_set() |
| * |
| * DESCRIPTION: Sets all gmacs functionality according to EthCmplx profile |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * |
| * COMMENTS: |
| * On success, returns TPM_OK |
| * On error, returns tpm_db_gmac_func_set error |
| *******************************************************************************/ |
| int32_t tpm_db_mac_func_set(void) |
| { |
| tpm_db_gmac_func_t pon = 0, |
| gmac0 = 0, |
| gmac1 = 0; |
| int32_t ret_code; |
| tpm_db_ds_mac_based_trunk_enable_t ds_mac_based_trunk_enable; |
| #ifdef CONFIG_MV_INCLUDE_PON |
| PON_SHUTDOWN_FUNC pon_callback_func = NULL; |
| #endif |
| switch(tpm_db.eth_cmplx_profile) |
| { |
| case TPM_PON_WAN_DUAL_MAC_INT_SWITCH: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| if (0 != tpm_db.func_profile.virt_uni_info.enabled) |
| gmac1 = TPM_GMAC_FUNC_VIRT_UNI; |
| else |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| break; |
| |
| case TPM_PON_WAN_DUAL_MAC_EXT_SWITCH: |
| /* ofer: phase#2, diferentiate between gmacs */ |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| break; |
| |
| case TPM_PON_WAN_G1_LAN_G0_INT_SWITCH: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| gmac1 = TPM_GMAC_FUNC_LAN_UNI; |
| break; |
| |
| case TPM_PON_WAN_G0_INT_SWITCH: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| break; |
| |
| case TPM_PON_WAN_G0_SINGLE_PORT: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| break; |
| |
| case TPM_G0_WAN_G1_INT_SWITCH: |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac0 = TPM_GMAC_FUNC_WAN; |
| gmac1 = TPM_GMAC_FUNC_LAN; |
| break; |
| |
| case TPM_G1_WAN_G0_INT_SWITCH: |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| gmac1 = TPM_GMAC_FUNC_WAN; |
| break; |
| |
| case TPM_PON_G1_WAN_G0_INT_SWITCH: |
| if (TPM_ENUM_GMAC_1 == tpm_db.init_misc.active_wan) { |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac1 = TPM_GMAC_FUNC_WAN; |
| }else{ |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| pon = TPM_GMAC_FUNC_WAN; |
| } |
| gmac0 = TPM_GMAC_FUNC_LAN; |
| break; |
| |
| case TPM_PON_G1_WAN_G0_SINGLE_PORT: |
| if (TPM_ENUM_GMAC_1 == tpm_db.init_misc.active_wan) { |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac1 = TPM_GMAC_FUNC_WAN; |
| }else{ |
| gmac1 = TPM_GMAC_FUNC_NONE; |
| pon = TPM_GMAC_FUNC_WAN; |
| } |
| gmac0 = TPM_GMAC_FUNC_LAN_UNI; |
| break; |
| |
| case TPM_PON_G0_WAN_G1_INT_SWITCH: |
| if (TPM_ENUM_GMAC_0 == tpm_db.init_misc.active_wan) { |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac0 = TPM_GMAC_FUNC_WAN; |
| }else{ |
| gmac0 = TPM_GMAC_FUNC_NONE; |
| pon = TPM_GMAC_FUNC_WAN; |
| } |
| gmac1 = TPM_GMAC_FUNC_LAN_UNI; |
| break; |
| |
| case TPM_PON_G0_WAN_G1_SINGLE_PORT: |
| if (TPM_ENUM_GMAC_0 == tpm_db.init_misc.active_wan) { |
| pon = TPM_GMAC_FUNC_NONE; |
| gmac0 = TPM_GMAC_FUNC_WAN; |
| }else{ |
| gmac0 = TPM_GMAC_FUNC_NONE; |
| pon = TPM_GMAC_FUNC_WAN; |
| } |
| gmac1 = TPM_GMAC_FUNC_LAN; |
| break; |
| |
| case TPM_PON_WAN_G1_MNG_EXT_SWITCH: |
| case TPM_PON_WAN_G1_SINGLE_PORT: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_NONE; |
| gmac1 = TPM_GMAC_FUNC_LAN_UNI; |
| break; |
| |
| case TPM_PON_WAN_G0_G1_LPBK: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_US_MAC_LEARN_DS_LAN_UNI; |
| gmac1 = TPM_GMAC_FUNC_LAN; |
| break; |
| case TPM_PON_WAN_G0_G1_DUAL_LAN: |
| pon = TPM_GMAC_FUNC_WAN; |
| gmac0 = TPM_GMAC_FUNC_LAN_UNI; |
| gmac1 = TPM_GMAC_FUNC_LAN_UNI; |
| break; |
| } |
| |
| /* when ds load balance on G0 and G1 is enabled, G0/1 are both LAN */ |
| tpm_db_ds_mac_based_trunk_enable_get(&ds_mac_based_trunk_enable); |
| if (TPM_DS_MAC_BASED_TRUNK_ENABLED == ds_mac_based_trunk_enable) |
| gmac1 = TPM_GMAC_FUNC_LAN; |
| |
| ret_code = tpm_db_gmac_func_set(TPM_ENUM_PMAC, pon); |
| IF_ERROR(ret_code); |
| ret_code = tpm_db_gmac_func_set(TPM_ENUM_GMAC_0, gmac0); |
| IF_ERROR(ret_code); |
| ret_code = tpm_db_gmac_func_set(TPM_ENUM_GMAC_1, gmac1); |
| IF_ERROR(ret_code); |
| |
| #ifdef CONFIG_MV_INCLUDE_PON |
| /* shut down or enable PON */ |
| ret_code = tpm_db_get_pon_callback(&pon_callback_func); |
| IF_ERROR(ret_code); |
| if (pon_callback_func) { |
| if (pon == TPM_GMAC_FUNC_WAN) |
| pon_callback_func(1); |
| else |
| pon_callback_func(0); |
| } |
| #endif |
| |
| return (TPM_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_eth_max_uni_port_set() |
| * |
| * DESCRIPTION: Sets the max_uni_port_nr according to EthCmplx profile |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * |
| * COMMENTS: |
| * On success, returns TPM_OK |
| * On error, returns tpm_db_gmac_func_set error |
| *******************************************************************************/ |
| int32_t tpm_db_eth_max_uni_port_set(void) |
| { |
| switch (tpm_db.eth_cmplx_profile) { |
| case TPM_PON_WAN_G0_SINGLE_PORT: |
| case TPM_PON_WAN_G1_SINGLE_PORT: |
| case TPM_PON_WAN_G0_G1_LPBK: |
| tpm_db.max_uni_port_nr = TPM_SRC_PORT_UNI_0; |
| break; |
| |
| case TPM_PON_G0_WAN_G1_SINGLE_PORT: |
| case TPM_PON_G1_WAN_G0_SINGLE_PORT: |
| case TPM_PON_WAN_G0_G1_DUAL_LAN: |
| tpm_db.max_uni_port_nr = TPM_SRC_PORT_UNI_1; |
| break; |
| |
| case TPM_PON_WAN_G0_INT_SWITCH: |
| case TPM_PON_WAN_G1_LAN_G0_INT_SWITCH: |
| case TPM_PON_WAN_DUAL_MAC_INT_SWITCH: |
| case TPM_G0_WAN_G1_INT_SWITCH: |
| case TPM_G1_WAN_G0_INT_SWITCH: |
| case TPM_PON_G1_WAN_G0_INT_SWITCH: |
| case TPM_PON_G0_WAN_G1_INT_SWITCH: |
| tpm_db.max_uni_port_nr = TPM_SRC_PORT_UNI_3; |
| break; |
| |
| case TPM_PON_WAN_G1_MNG_EXT_SWITCH: |
| tpm_db.max_uni_port_nr = TPM_SRC_PORT_UNI_6; |
| break; |
| |
| case TPM_PON_WAN_DUAL_MAC_EXT_SWITCH: |
| tpm_db.max_uni_port_nr = TPM_SRC_PORT_UNI_7; |
| break; |
| |
| default: |
| return TPM_DB_ERR_REC_EXIST; |
| } |
| |
| /* increment the counter since UNI enumeration starts @ zero */ |
| tpm_db.max_uni_port_nr++; |
| |
| return (TPM_DB_OK); |
| } |
| |
| tpm_src_port_type_t tpm_db_trg_port_uni_any_bmp_get(bool inc_virt_uni) |
| { |
| uint32_t dst_port, trg_port_uni_any_bmp = 0; |
| tpm_src_port_type_t src_port; |
| |
| for (dst_port = TPM_TRG_UNI_0, src_port = TPM_SRC_PORT_UNI_0; |
| dst_port <= TPM_TRG_UNI_7; |
| dst_port = (dst_port << 1), src_port += 1) { |
| |
| /* if port is valid */ |
| if(tpm_db_eth_port_valid(src_port)) |
| trg_port_uni_any_bmp |= dst_port; |
| } |
| |
| if (tpm_db.func_profile.virt_uni_info.enabled != 0 && true == inc_virt_uni) |
| trg_port_uni_any_bmp |= TPM_TRG_UNI_VIRT; |
| |
| return trg_port_uni_any_bmp; |
| } |
| |
| bool tpm_db_gmac_valid(tpm_gmacs_enum_t gmac) |
| { |
| if (((TPM_ENUM_PMAC == gmac) && (TPM_NONE != tpm_db.init_misc.pon_type)) || |
| ((1 == tpm_db.gmac_port_conf[gmac].valid) && (TPM_GMAC_CON_DISC != tpm_db.gmac_port_conf[gmac].conn))) |
| return true; |
| |
| return false; |
| } |
| |
| int32_t tpm_db_target_to_gmac(tpm_pnc_trg_t pnc_target, tpm_gmacs_enum_t *gmac) |
| { |
| if (TPM_PNC_TRG_GMAC0 == pnc_target) |
| *gmac = TPM_ENUM_GMAC_0; |
| else if (TPM_PNC_TRG_GMAC1 == pnc_target) |
| *gmac = TPM_ENUM_GMAC_1; |
| else if (TPM_PNC_TRG_CPU == pnc_target) { |
| TPM_OS_ERROR(TPM_DB_MOD, "target to CPU, no GMAC valid\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } else |
| *gmac = TPM_ENUM_PMAC; |
| |
| return TPM_DB_OK; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_to_lan_gmac_get() |
| * |
| * DESCRIPTION: returns the GMAC target for traffic to LAN according to target |
| * port bitmap |
| * INPUTS: |
| * trg_port target port bitmap |
| * |
| * OUTPUTS: |
| * pnc_target gmac target |
| * |
| * RETURNS: |
| * On success, the function returns TPM_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_to_lan_gmac_get(tpm_trg_port_type_t trg_port, tpm_pnc_trg_t *pnc_target) |
| { |
| uint32_t i; |
| tpm_pnc_trg_t gmac_vec = 0; |
| bool trg_port_on_switch = false; |
| |
| |
| if (NULL == pnc_target) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| *pnc_target = TPM_INVALID_PNC_TRG; |
| |
| /* for UNI_ANY we search the gmac_func for lan cababilities */ |
| if (TPM_TRG_PORT_UNI_ANY == trg_port) { |
| for (i = TPM_ENUM_GMAC_0; i < TPM_MAX_GMAC; i++) { |
| if (!tpm_db_gmac_valid(i)) |
| continue; |
| if (!tpm_db_gmac1_lpbk_en_get()) { |
| if (TPM_GMAC_FUNC_LAN == tpm_db.gmac_func[i] || |
| TPM_GMAC_FUNC_LAN_UNI == tpm_db.gmac_func[i]) { |
| gmac_vec |= (TPM_ENUM_GMAC_0 == i) ? TPM_PNC_TRG_GMAC0 : TPM_PNC_TRG_GMAC1; |
| break;/* target only one, no others */ |
| } |
| } else { |
| gmac_vec |= TPM_PNC_TRG_GMAC0; |
| break; |
| } |
| } |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "trg_port(%x) gmac_vec(%x)\n", trg_port, gmac_vec); |
| *pnc_target = gmac_vec; |
| return TPM_DB_OK; |
| } |
| |
| /* if target is virt uni, search for the gmac that acts as LAN */ |
| if (TPM_TRG_UNI_VIRT & trg_port) { |
| for (i = TPM_ENUM_GMAC_0; i < TPM_MAX_GMAC; i++) { |
| if (!tpm_db_gmac_valid(i)) |
| continue; |
| |
| /* need only virt uni lan ports */ |
| if (TPM_GMAC_FUNC_LAN == tpm_db.gmac_func[i]){ |
| gmac_vec |= (TPM_ENUM_GMAC_0 == i) ? TPM_PNC_TRG_GMAC0 : TPM_PNC_TRG_GMAC1; |
| break; |
| } |
| } |
| } |
| |
| /* search ethernet ports */ |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if (TPM_DB_VALID != tpm_db.eth_ports[i].valid || |
| TPM_SRC_PORT_ILLEGAL == tpm_db.eth_ports[i].port_src || |
| TPM_SRC_PORT_WAN == tpm_db.eth_ports[i].port_src) |
| continue; |
| |
| if ((1 << tpm_db.eth_ports[i].port_src) & (trg_port >> TPM_TRG_UNI_OFFSET)){ |
| if (TPM_INTCON_SWITCH == tpm_db.eth_ports[i].int_connect) { |
| /* port on switch, set the flag */ |
| trg_port_on_switch = true; |
| } else if (TPM_INTCON_GMAC0 == tpm_db.eth_ports[i].int_connect){ |
| /* port on GMAC0 */ |
| gmac_vec |= TPM_PNC_TRG_GMAC0; |
| } else if (TPM_INTCON_GMAC1 == tpm_db.eth_ports[i].int_connect){ |
| /* port on GMAC1 */ |
| gmac_vec |= TPM_PNC_TRG_GMAC1; |
| } |
| } |
| } |
| |
| /* if port connected to switch, search gmac_func for the connected GMAC */ |
| if (true == trg_port_on_switch) { |
| for (i = TPM_ENUM_GMAC_0; i < TPM_MAX_GMAC; i++) { |
| if (!tpm_db_gmac_valid(i)) |
| continue; |
| |
| /* need only LAN ports */ |
| if (TPM_GMAC_FUNC_LAN == tpm_db.gmac_func[i] || |
| TPM_GMAC_FUNC_LAN_UNI == tpm_db.gmac_func[i]){ |
| if (TPM_GMAC_CON_SWITCH_4 == tpm_db.gmac_port_conf[i].conn || |
| TPM_GMAC_CON_SWITCH_5 == tpm_db.gmac_port_conf[i].conn) { |
| gmac_vec |= (TPM_ENUM_GMAC_0 == i) ? TPM_PNC_TRG_GMAC0 : TPM_PNC_TRG_GMAC1; |
| } |
| } |
| } |
| } |
| |
| if (TPM_INVALID_PNC_TRG == gmac_vec) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "trg_port(%x) gmac_vec(%x)\n", trg_port, gmac_vec); |
| *pnc_target = gmac_vec; |
| return TPM_DB_OK; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_src_gmac_func_get() |
| * |
| * DESCRIPTION: returns the GMAC target for traffic to LAN according to target |
| * port bitmap |
| * INPUTS: |
| * trg_port target port bitmap |
| * |
| * OUTPUTS: |
| * pnc_target gmac target |
| * |
| * RETURNS: |
| * On success, the function returns TPM_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_src_gmac_func_get(tpm_src_port_type_t src_port, tpm_db_gmac_func_t *gmac_func) |
| { |
| uint32_t i; |
| |
| if (NULL == gmac_func) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| *gmac_func = TPM_GMAC_FUNC_NONE; |
| |
| if (TPM_SRC_PORT_WAN == src_port){ |
| *gmac_func = TPM_GMAC_FUNC_WAN; |
| return TPM_DB_OK; |
| } |
| |
| if (TPM_SRC_PORT_UNI_VIRT == src_port){ |
| if (TPM_FALSE == tpm_db.func_profile.virt_uni_info.enabled) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| tpm_db_gmac_func_get(TPM_ENUM_GMAC_1, gmac_func); |
| return TPM_DB_OK; |
| } |
| |
| /* start gmac ports */ |
| for (i = 0; i < TPM_NUM_GMACS; i++) { |
| if (TPM_FALSE == tpm_db.gmac_port_conf[i].valid) |
| continue; |
| |
| if (tpm_db.gmac_port_conf[i].port_src == src_port){ |
| *gmac_func = tpm_db.gmac_func[i]; |
| return TPM_DB_OK; |
| } |
| } |
| |
| /* search switch ports */ |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if (TPM_DB_VALID != tpm_db.eth_ports[i].valid) |
| continue; |
| |
| /* port_src found on switch */ |
| if (tpm_db.eth_ports[i].port_src == src_port){ |
| uint32_t j; |
| |
| /* now search gmac table to find connecting port */ |
| for (j = 0; j < TPM_NUM_GMACS-1; j++) { |
| if (TPM_FALSE == tpm_db.gmac_port_conf[j].valid) |
| continue; |
| |
| if ((TPM_SRC_PORT_ILLEGAL == tpm_db.gmac_port_conf[j].port_src) && |
| ((TPM_GMAC_CON_SWITCH_5 == tpm_db.gmac_port_conf[j].conn) || |
| (TPM_GMAC_CON_SWITCH_4 == tpm_db.gmac_port_conf[j].conn))){ |
| *gmac_func = (TPM_ENUM_GMAC_0 == i) ? tpm_db.gmac_func[0] : tpm_db.gmac_func[1]; |
| return TPM_DB_OK; |
| } |
| } |
| |
| } |
| } |
| |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| int32_t tpm_db_src_port_on_switch(tpm_src_port_type_t src_port) |
| { |
| uint32_t i; |
| |
| /* switch ports can not act as WAN source port */ |
| if (TPM_SRC_PORT_WAN == src_port) |
| return TPM_FALSE; |
| |
| /* start gmac ports */ |
| for (i = 0; i < TPM_NUM_GMACS; i++) { |
| if (TPM_FALSE == tpm_db.gmac_port_conf[i].valid) |
| continue; |
| |
| if (tpm_db.gmac_port_conf[i].port_src == src_port) |
| return TPM_FALSE; |
| } |
| |
| /* search switch ports */ |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| if (TPM_DB_VALID != tpm_db.eth_ports[i].valid) |
| continue; |
| |
| if (tpm_db.eth_ports[i].port_src == src_port) |
| return TPM_TRUE; |
| } |
| return TPM_FALSE; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_trg_port_switch_port_get() |
| * |
| * DESCRIPTION: Function to get the target port bitmap |
| * |
| * INPUTS: |
| * ext_port - External Port Identifier, can be any positive number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * The function returns the target ports bitmap for an external port. |
| * In case of no matching - it returns empty bitmap 0x0. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_trg_port_switch_port_get(tpm_trg_port_type_t ext_port) |
| { |
| uint32_t portVec = 0; |
| |
| if (ext_port & TPM_TRG_PORT_UNI_ANY) { |
| ext_port |= (TPM_TRG_UNI_0 | TPM_TRG_UNI_1 | TPM_TRG_UNI_2 | TPM_TRG_UNI_3 | |
| TPM_TRG_UNI_4 | TPM_TRG_UNI_5 | TPM_TRG_UNI_6 | TPM_TRG_UNI_7); |
| |
| if (tpm_db.func_profile.virt_uni_info.enabled != 0) |
| ext_port |= TPM_TRG_UNI_VIRT; |
| } |
| if (ext_port & TPM_TRG_UNI_0) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_0); |
| |
| if (ext_port & TPM_TRG_UNI_1) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_1); |
| |
| if (ext_port & TPM_TRG_UNI_2) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_2); |
| |
| if (ext_port & TPM_TRG_UNI_3) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_3); |
| |
| if (ext_port & TPM_TRG_UNI_4) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_4); |
| |
| if (ext_port & TPM_TRG_UNI_5) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_5); |
| |
| if (ext_port & TPM_TRG_UNI_6) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_6); |
| |
| if (ext_port & TPM_TRG_UNI_7) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_7); |
| |
| if (ext_port & TPM_TRG_UNI_VIRT) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_UNI_VIRT); |
| |
| if (ext_port & TPM_TRG_PORT_CPU) |
| portVec |= 1 << tpm_db_eth_port_switch_port_get(TPM_SRC_PORT_WAN); |
| |
| return (portVec); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_eth_port_conf_set() |
| * |
| * DESCRIPTION: Function to set an ethernet physical and internal configuration in the DB |
| * |
| * INPUTS: |
| * ext_port - External Port Identifier, can be any positive number |
| * other inputs - See explanation in tpm_db_eth_port_conf_t structure |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_eth_port_conf_set(tpm_init_eth_port_conf_t *eth_port_conf) |
| { |
| uint32_t i; |
| int32_t free_entry = -1; |
| |
| if (NULL == eth_port_conf) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "src_port (%d)\n", eth_port_conf->port_src); |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) { |
| /* Check entry does not exist */ |
| if ((tpm_db.eth_ports[i].port_src == eth_port_conf->port_src) |
| && (tpm_db.eth_ports[i].valid == TPM_DB_VALID)) |
| return (TPM_DB_ERR_REC_EXIST); |
| |
| /* Find first invalid entry */ |
| if ((free_entry == -1) && (tpm_db.eth_ports[i].valid == TPM_DB_INVALID)) |
| free_entry = i; |
| } |
| /* No free Entry */ |
| if (free_entry == -1) |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| |
| /* Set entry */ |
| tpm_db.eth_ports[free_entry].port_src = eth_port_conf->port_src; |
| tpm_db.eth_ports[free_entry].int_connect = eth_port_conf->int_connect; |
| tpm_db.eth_ports[free_entry].chip_connect = eth_port_conf->chip_connect; |
| tpm_db.eth_ports[free_entry].switch_port = eth_port_conf->switch_port; |
| tpm_db.eth_ports[free_entry].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| int32_t tpm_db_gmac_conn_conf_set(tpm_init_gmac_conn_conf_t *gmac_port_conf, uint32_t arr_size) |
| { |
| uint32_t i; |
| |
| if (NULL == gmac_port_conf) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| for (i = 0; i < arr_size; i++) { |
| TPM_OS_DEBUG(TPM_DB_MOD, "gmac src_port (%d)\n", gmac_port_conf[i].port_src); |
| |
| /* Set entry */ |
| tpm_db.gmac_port_conf[i].port_src = gmac_port_conf[i].port_src; |
| tpm_db.gmac_port_conf[i].conn = gmac_port_conf[i].conn; |
| tpm_db.gmac_port_conf[i].valid = gmac_port_conf[i].valid; |
| } |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_conn_conf_get() |
| * |
| * DESCRIPTION: Function to get GMAC connection information from DB |
| * |
| * INPUTS: |
| * gmac - GMAC port |
| * |
| * OUTPUTS: |
| * gmac_port_conf - connection info |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_conn_conf_get(tpm_gmacs_enum_t gmac, tpm_init_gmac_conn_conf_t *gmac_port_conf) |
| { |
| if (NULL == gmac_port_conf) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memcpy(gmac_port_conf, &tpm_db.gmac_port_conf[gmac], sizeof(tpm_init_gmac_conn_conf_t)); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_tcont_llid_set() |
| * |
| * DESCRIPTION: Function to set the GMAC connection and T-CONTs in the DB |
| * |
| * INPUTS: |
| * num_tcont_llid - Number of T-CONTs/LLIDs |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_tcont_llid_set(uint32_t num_tcont_llid) |
| { |
| tpm_db.num_valid_tcont_llid = num_tcont_llid; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_conn_get() |
| * |
| * DESCRIPTION: Function to get the Connection of an Ethernet GMAC |
| * |
| * INPUTS: |
| * gmac - GMAC number |
| * OUTPUTS: |
| * gmac_con - GMAC internal Physical connection (see tpm_db_gmac_conn_t) |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_conn_get(tpm_gmacs_enum_t gmac, tpm_db_gmac_conn_t *gmac_con) |
| { |
| if (gmac == TPM_ENUM_GMAC_0) |
| *gmac_con = tpm_db.gmac_port_conf[0].conn; |
| else if (gmac == TPM_ENUM_GMAC_1) |
| *gmac_con = tpm_db.gmac_port_conf[1].conn; |
| else |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_mh_en_conf_set() |
| * |
| * DESCRIPTION: Function to set the GMAC connection and T-CONTs in the DB |
| * |
| * INPUTS: |
| * gmac - GMAC |
| * mh_en - MH enable TRUE/FALSE |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_mh_en_conf_set(tpm_gmacs_enum_t gmac, uint32_t mh_en) |
| { |
| |
| tpm_db.gmac_mh_en[gmac] = mh_en; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_mh_en_conf_get() |
| * |
| * DESCRIPTION: Function to set the GMAC connection and T-CONTs in the DB |
| * |
| * INPUTS: |
| * gmac - GMAC |
| * |
| * OUTPUTS: |
| * mh_en - MH enable TRUE/FALSE |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_mh_en_conf_get(tpm_gmacs_enum_t gmac, uint32_t *mh_en) |
| { |
| |
| *mh_en = tpm_db.gmac_mh_en[gmac]; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_bm_bufs_conf_set() |
| * |
| * DESCRIPTION: Function to set the GMAC number of Buffer Mngmt large_bufers, short_buffers |
| * |
| * INPUTS: |
| * gmac - GMAC |
| * large_pkt_buffers - number of buffers in the GMAC long packets pool |
| * small_pkt_buffers - number of buffers in the GMAC short packets pool |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_bm_bufs_conf_set(tpm_gmacs_enum_t gmac, uint32_t large_pkt_buffers, uint32_t small_pkt_buffers) |
| { |
| tpm_db.gmac_bp_bufs[gmac].valid = TPM_DB_VALID; |
| tpm_db.gmac_bp_bufs[gmac].large_pkt_buffers = large_pkt_buffers; |
| tpm_db.gmac_bp_bufs[gmac].small_pkt_buffers = small_pkt_buffers; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_bm_bufs_conf_get() |
| * |
| * DESCRIPTION: Function to set the GMAC number of Buffer Mngmt large_bufers, short_buffers |
| * |
| * INPUTS: |
| * gmac - GMAC |
| * valid - Is the entry valid in the db |
| * large_pkt_buffers - number of buffers in the GMAC long packets pool |
| * small_pkt_buffers - number of buffers in the GMAC short packets pool |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_bm_bufs_conf_get(tpm_gmacs_enum_t gmac, |
| uint32_t *valid, uint32_t *large_pkt_buffers, uint32_t *small_pkt_buffers) |
| { |
| if ((valid == NULL) || (gmac >= TPM_MAX_NUM_GMACS)) |
| return (TPM_DB_ERR_INV_INPUT); |
| *valid = (tpm_db.gmac_bp_bufs[gmac].valid == TPM_DB_VALID ? 1 : 0); |
| |
| if (large_pkt_buffers != NULL) |
| *large_pkt_buffers = tpm_db.gmac_bp_bufs[gmac].large_pkt_buffers; |
| |
| if (small_pkt_buffers != NULL) |
| *small_pkt_buffers = tpm_db.gmac_bp_bufs[gmac].small_pkt_buffers; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_intport_int_con_get() |
| * |
| * DESCRIPTION: Function returns internal connectivity of an internal port num |
| * |
| * INPUTS: |
| * int_port_num - Internal Port Identifier, UNI#0..UNI#4 or WAN Port |
| * |
| * OUTPUTS: |
| * int_con - Port internal L2 Connection (G0, G1, Amber switch) |
| * switch_port - Amber Switch Port number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_intport_int_con_get(tpm_src_port_type_t int_port_num, |
| tpm_db_int_conn_t *int_con, |
| uint32_t *switch_port) |
| { |
| int32_t ret_code; |
| tpm_db_chip_conn_t dummy_chip_con; |
| tpm_db_int_conn_t l_int_conn; |
| uint32_t l_switch_port; |
| |
| if (int_port_num == TPM_SRC_PORT_UNI_VIRT) { |
| *int_con = TPM_INTCON_SWITCH; |
| *switch_port = tpm_db.func_profile.virt_uni_info.switch_port; |
| return (TPM_DB_OK); |
| } |
| |
| /* Get External Port Config */ |
| ret_code = tpm_db_eth_port_conf_get(int_port_num, |
| &dummy_chip_con, |
| &l_int_conn, |
| &l_switch_port); |
| IF_ERROR(ret_code); |
| |
| /* Return data */ |
| *int_con = l_int_conn; |
| *switch_port = l_switch_port; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_num_tcont_llid_get() |
| * |
| * DESCRIPTION: Function to get the number of T-CONTs/LLIDs |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * num_tcont_llid - Number of GPON TCONTs or EPON LLIDs |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_num_tcont_llid_get(uint32_t *num_tcont_llid) |
| { |
| *num_tcont_llid = tpm_db.num_valid_tcont_llid; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_tx_q_conf_set() |
| * |
| * DESCRIPTION: Function to set the parameters of a Packet Processor Component Tx queue |
| * |
| * INPUTS: |
| * tx_mod - Tx module (G0, G1, or TCONT/LLID0-7) |
| * OUTPUTS: |
| * gmac_con - GMAC0 connection |
| * queue_num - Queue number in this Tx |
| * sched_method - The Tx Scheduler this queue is added to (the WRR or the Strict scheduler) |
| * queue_owner - The single hardware owner, that is feeding this queue. |
| * Can be the CPU, or one of the PAcket Processor Rx components. |
| * owner_queue_num - The relative queue number of the owner of this queue. |
| * queue_weight - Weight, if the queue is added to the WRR Scheduler. |
| * queue_size - |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_tx_q_conf_set(tpm_db_tx_mod_t tx_mod, |
| uint32_t queue_num, |
| tpm_db_sched_t sched_method, |
| tpm_db_txq_owner_t queue_owner, |
| uint32_t owner_queue_num, uint32_t queue_size, uint32_t queue_weight) |
| { |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_owner = queue_owner; |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].owner_queue_num = owner_queue_num; |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].sched_method = sched_method; |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_size = queue_size; |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_weight = queue_weight; |
| tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_tx_q_conf_get() |
| * |
| * DESCRIPTION: Function to set the parameters of a Packet Processor Tx Component |
| * |
| * INPUTS: |
| * tx_mod - Tx module (G0, G1, or TCONT/LLID0-7) |
| * queue_num - Queue number in this Tx |
| * |
| * OUTPUTS: |
| * valid - Queue exists |
| * sched_method - The Tx Scheduler this queue is added to (the WRR or the Strict scheduler) |
| * queue_owner - The single hardware owner, that is feeding this queue. |
| * Can be the CPU, or one of the PAcket Processor Rx components. |
| * owner_queue_num - The relative queue number of the owner of this queue. |
| * queue_weight - Weight, if the queue is added to the WRR Scheduler. |
| * queue_size - |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_tx_q_conf_get(tpm_db_tx_mod_t tx_mod, |
| uint32_t queue_num, |
| uint32_t *valid, |
| tpm_db_sched_t *sched_method, |
| tpm_db_txq_owner_t *queue_owner, |
| uint32_t *owner_queue_num, uint32_t *queue_size, uint32_t *queue_weight) |
| { |
| if (valid == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].valid == TPM_DB_VALID) { |
| *valid = TPM_TRUE; |
| if (sched_method != NULL) |
| *sched_method = tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].sched_method; |
| if (queue_owner != NULL) |
| *queue_owner = tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_owner; |
| if (owner_queue_num != NULL) |
| *owner_queue_num = tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].owner_queue_num; |
| if (queue_size != NULL) |
| *queue_size = tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_size; |
| if (queue_weight != NULL) |
| *queue_weight = tpm_db.gmac_tx[tx_mod].tx_queue[queue_num].queue_weight; |
| } else { |
| *valid = TPM_FALSE; |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_rx_q_conf_set() |
| * |
| * DESCRIPTION: Function to set the parameters of a Packet Processor Tx Component |
| * |
| * INPUTS: |
| * gmac - GMAC |
| * OUTPUTS: |
| * queue_num - Queue number in this Tx |
| * queue_size - |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_rx_q_conf_set(tpm_gmacs_enum_t gmac, uint32_t queue_num, uint32_t queue_size) |
| { |
| if ((gmac >= TPM_MAX_NUM_GMACS) || (queue_num >= TPM_MAX_NUM_RX_QUEUE)) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.gmac_rx[gmac].rx_queue[queue_num].queue_size = queue_size; |
| tpm_db.gmac_rx[gmac].rx_queue[queue_num].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_gmac_rx_q_conf_get(tpm_gmacs_enum_t gmac, uint32_t queue_num, uint32_t *valid, uint32_t *queue_size) |
| { |
| |
| if ((valid == NULL) || (gmac >= TPM_MAX_NUM_GMACS) || (queue_num >= TPM_MAX_NUM_RX_QUEUE)) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (tpm_db.gmac_rx[gmac].rx_queue[queue_num].valid == TPM_DB_VALID) { |
| *valid = TPM_TRUE; |
| if (queue_size != NULL) |
| *queue_size = tpm_db.gmac_rx[gmac].rx_queue[queue_num].queue_size; |
| } else |
| *valid = TPM_FALSE; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_tx_val_set() |
| * |
| * DESCRIPTION: Function to set the parameters of a Tx module |
| * |
| * INPUTS: |
| * tx_mod - Tx Module to validate |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_tx_val_set(tpm_db_tx_mod_t tx_mod) |
| { |
| tpm_db.gmac_tx[tx_mod].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_rx_val_set() |
| * |
| * DESCRIPTION: Function to set the parameters of a Tx module |
| * |
| * INPUTS: |
| * gmac - GMAC to set active |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_rx_val_set(tpm_gmacs_enum_t gmac) |
| { |
| tpm_db.gmac_rx[gmac].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| uint32_t tpm_db_gmac_rx_val_get(tpm_gmacs_enum_t gmac) |
| { |
| if (tpm_db.gmac_rx[gmac].valid == TPM_DB_VALID) |
| return (TPM_TRUE); |
| else |
| return (TPM_FALSE); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_func_get() |
| * |
| * DESCRIPTION: Check the Function of a GMAC (LAN, WAN or no function) |
| * |
| * INPUTS: |
| * gmac - GMAC to check |
| * OUTPUTS: |
| * gfunc - Functionality the GMAC is performing (None, LAN or WAN) |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_func_get(tpm_gmacs_enum_t gmac, tpm_db_gmac_func_t *gfunc) |
| { |
| if (gmac > TPM_MAX_GMAC) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| *gfunc = tpm_db.gmac_func[gmac]; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_func_set() |
| * |
| * DESCRIPTION: Sets the Function of a GMAC (LAN, WAN or no function) |
| * |
| * INPUTS: |
| * gmac - GMAC to set |
| * gfunc - Functionality the GMAC is performing (None, LAN or WAN) |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_func_set(tpm_gmacs_enum_t gmac, tpm_db_gmac_func_t gfunc) |
| { |
| if (gmac > TPM_MAX_GMAC) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.gmac_func[gmac] = gfunc; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_tx_val_get() |
| * |
| * DESCRIPTION: Function check the validity of a Tx module |
| * |
| * INPUTS: |
| * tx_mod - Tx module to check |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| uint32_t tpm_db_gmac_tx_val_get(tpm_db_tx_mod_t tx_mod) |
| { |
| if (tpm_db.gmac_tx[tx_mod].valid == TPM_DB_VALID) |
| return (TPM_TRUE); |
| else |
| return (TPM_FALSE); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_lpk_queue_get() |
| * |
| * DESCRIPTION: Function to get the queue id used to do gmac loopback on MC, min queue id for data traffic, |
| * max queue id for MAC learning |
| * INPUTS: |
| * queue_type - queue type for GMAC1 loopback, for data traffic or for MAC learning |
| * OUTPUTS: |
| * gmac - gmac on which loopback is done |
| * queue_idx - queue index which do loopback |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| *******************************************************************************/ |
| uint32_t tpm_db_gmac_lpk_queue_get(tpm_gmacs_enum_t *gmac, |
| uint32_t *queue_idx, |
| tpm_db_gmac1_lpk_queue_type_t queue_type) |
| { |
| uint32_t queue_id, q_valid, gmac_id; |
| tpm_db_txq_owner_t queue_owner, lpk_queue_owner = TPM_Q_OWNER_GMAC0; |
| tpm_db_gmac_func_t lpk_gmac_func; |
| tpm_db_tx_mod_t tx_mod; |
| uint32_t q_expected = TPM_MAX_NUM_TX_QUEUE; |
| |
| /*check input parameters*/ |
| if (NULL == gmac || NULL == queue_idx) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| /*check func profile*/ |
| if (!tpm_db_gmac1_lpbk_en_get()) { |
| TPM_OS_ERROR(TPM_DB_MOD, "GMAC1 loopback has not been enabled!\n"); |
| return TPM_FALSE; |
| } |
| |
| /*Find the GMAC used to do loopback*/ |
| for (gmac_id = TPM_ENUM_GMAC_0; gmac_id < TPM_MAX_NUM_GMACS; gmac_id ++) { |
| if (TPM_DB_OK == tpm_db_gmac_func_get(gmac_id, &lpk_gmac_func)) { |
| if (TPM_GMAC_FUNC_LAN == lpk_gmac_func) |
| break; |
| } else { |
| continue; |
| } |
| } |
| |
| if (gmac_id == TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Loopback GMAC get failed \n"); |
| return TPM_FALSE; |
| } else { |
| tx_mod = (tpm_db_tx_mod_t)gmac_id; |
| lpk_queue_owner = TPM_Q_OWNER_GMAC0; |
| } |
| |
| /* get the Tx queue of GMAC1, if more than 1 queue belong to gmac0, lowest index is selected */ |
| for (queue_id = 0; queue_id < TPM_MAX_NUM_TX_QUEUE; queue_id++) { |
| if (TPM_DB_OK != tpm_db_gmac_tx_q_conf_get(tx_mod, queue_id, &q_valid, NULL, |
| &queue_owner, NULL, NULL, NULL)) |
| continue; |
| if (q_valid == TPM_TRUE && queue_owner == lpk_queue_owner) { |
| q_expected = queue_id; |
| if (TPM_GMAC1_QUEUE_DATA_TRAFFIC == queue_type) |
| break; |
| else if (TPM_GMAC1_QUEUE_MAC_LEARN_TRAFFIC == queue_type) |
| continue; |
| } |
| } |
| if (q_expected >= TPM_MAX_NUM_TX_QUEUE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid Tx queue %d of GMAC1 assigned to GMAC0 \n", q_expected); |
| return ERR_SW_TM_QUEUE_INVALID; |
| } |
| |
| *gmac = gmac_id; |
| *queue_idx = q_expected; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_create() |
| * |
| * DESCRIPTION: Function to create a range in the DB |
| * |
| * INPUTS: |
| * pnc_range_conf - Pointer to all config information needed for an entry |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: Perfom only DB integrity checks, not data correctness checks |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_create(tpm_db_pnc_range_conf_t *pnc_range_conf) |
| { |
| uint32_t i; |
| int32_t free_entry = -1; |
| |
| /* Check NULL Pointer */ |
| if (pnc_range_conf == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| /* Check range_id is not already in DB, and that DB is not full */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID && PNC_RANGE_CONF(i).range_id == pnc_range_conf->range_id) |
| return (TPM_DB_ERR_RANGE_EXIST); |
| |
| if ((tpm_db.pnc_range[i].valid == TPM_DB_INVALID) && (free_entry == -1)) |
| free_entry = i; |
| } |
| if (free_entry == -1) |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| |
| /* Copy Config Structure into DB */ |
| memcpy(&(tpm_db.pnc_range[free_entry].pnc_range_conf), pnc_range_conf, sizeof(tpm_db_pnc_range_conf_t)); |
| |
| /* Init Operational Data */ |
| PNC_RANGE_OPER(free_entry).free_entries = (pnc_range_conf->api_end - pnc_range_conf->api_start + 1); |
| PNC_RANGE_OPER(free_entry).num_resets = 0; |
| |
| tpm_db.pnc_range[free_entry].valid = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_delete() |
| * |
| * DESCRIPTION: Initializes and invalidates PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that is deleted |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_delete(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| /* Reset Operational values */ |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID && |
| tpm_db.pnc_range[i].pnc_range_conf.range_id == pnc_range) { |
| memset(&(tpm_db.pnc_range[i]), 0, sizeof(tpm_pnc_ranges_t)); |
| tpm_db.pnc_range[i].valid = TPM_DB_INVALID; |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_reset() |
| * |
| * DESCRIPTION: Resets PnC range, all entries are returned to free |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that is reset |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_reset(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| /* reach the range to be reset */ |
| if (tpm_db.pnc_range[i].pnc_range_conf.range_id == pnc_range) { |
| /* Reset Operational values */ |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID) { |
| /* both hardcoded and non-hardcoded entries will behave the same from free_entries point of view */ |
| PNC_RANGE_OPER(i).free_entries = |
| PNC_RANGE_CONF(i).api_end - PNC_RANGE_CONF(i).api_start + 1; |
| (PNC_RANGE_OPER(i).num_resets)++; |
| return (TPM_DB_OK); |
| } |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_free_ent_inc() |
| * |
| * DESCRIPTION: Increases number of free entries for a PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that it's free entries is increased |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_free_ent_inc(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == pnc_range) { |
| /* Check number of free entries is not too big */ |
| if (PNC_RANGE_OPER(i).free_entries |
| < (PNC_RANGE_CONF(i).api_end - PNC_RANGE_CONF(i).api_start + 1)) { |
| (PNC_RANGE_OPER(i).free_entries)++; |
| return (TPM_DB_OK); |
| } else |
| return (TPM_DB_ERR_DB_INCONSISTENCY); |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_free_ent_dec() |
| * |
| * DESCRIPTION: Decreases number of free entries for a PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that it's free entries is decreased |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_free_ent_dec(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID && PNC_RANGE_CONF(i).range_id == pnc_range) { |
| TPM_OS_DEBUG(TPM_DB_MOD, "range_id(%d), free_ent(%d)\n", pnc_range, |
| PNC_RANGE_OPER(i).free_entries); |
| /* Check number of free entries is not zero */ |
| if (PNC_RANGE_OPER(i).free_entries > 0) { |
| (PNC_RANGE_OPER(i).free_entries)--; |
| return (TPM_DB_OK); |
| } else { |
| TPM_OS_ERROR(TPM_DB_MOD, "no free entries \n"); |
| return (TPM_DB_ERR_DB_INCONSISTENCY); |
| } |
| } |
| } |
| /* pnc_range not found */ |
| TPM_OS_ERROR(TPM_DB_MOD, "range_id(%d) not found\n", pnc_range); |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_get_lu_conf() |
| * |
| * DESCRIPTION: Get PnC least used config for specific PnC range |
| * |
| * INPUTS: |
| * range_id - The PnC range id |
| * |
| * OUTPUTS: |
| * lu_conf - Least used configuration for PnC range |
| |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_get_lu_conf(tpm_pnc_ranges_t range_id, tpm_api_lu_conf_t *lu_conf) |
| { |
| tpm_pnc_ranges_t l_range_idx; |
| |
| /* Check PnC range */ |
| if ((range_id < 0) || (range_id > (TPM_MAX_NUM_RANGES - 1))) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Error, range_id(%d) is illegal \n", range_id); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Check input param */ |
| if (lu_conf == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Error, lu_conf is NULL \n"); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Get the config from TPM db */ |
| for (l_range_idx = 0; l_range_idx < TPM_MAX_RANGE; l_range_idx++) { |
| if (tpm_db.pnc_range[l_range_idx].valid == TPM_DB_VALID |
| && (PNC_RANGE_CONF(l_range_idx).range_id == range_id)) { |
| lu_conf->cntr_grp = tpm_db.pnc_range[l_range_idx].pnc_range_conf.cntr_grp; |
| lu_conf->lu_mask = tpm_db.pnc_range[l_range_idx].pnc_range_conf.lu_mask; |
| break; |
| } |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_api_start_inc() |
| * |
| * DESCRIPTION: Increases number of free entries for a PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that it's free entries is increased |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_api_start_inc(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == pnc_range) { |
| /* Check number of free entries is not too big */ |
| if (PNC_RANGE_OPER(i).free_entries >= 1) { |
| (PNC_RANGE_CONF(i).api_start)++; |
| (PNC_RANGE_OPER(i).free_entries)--; |
| return (TPM_DB_OK); |
| } else |
| return (TPM_DB_ERR_DB_INCONSISTENCY); |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_api_end_dec() |
| * |
| * DESCRIPTION: Decrease number of api_end for a PnC range |
| * The reason might be addition of an entry at the end of the range. |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range that it's free entries is increased |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_api_end_dec(tpm_pnc_ranges_t pnc_range) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == pnc_range) { |
| /* Check number of free entries is not too big */ |
| if (PNC_RANGE_OPER(i).free_entries >= 1) { |
| (PNC_RANGE_CONF(i).api_end)--; |
| (PNC_RANGE_OPER(i).free_entries)--; |
| return (TPM_DB_OK); |
| } else |
| return (TPM_DB_ERR_DB_INCONSISTENCY); |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| int32_t tpm_db_api_section_get_from_api_type(tpm_api_type_t api_type, tpm_api_sections_t *api_section) |
| { |
| int32_t error_code = TPM_DB_OK; |
| |
| /*TODO - replace this w/ conf structure */ |
| |
| switch (api_type) { |
| case TPM_API_MAC_LEARN: |
| *api_section = TPM_PNC_MAC_LEARN_ACL; |
| break; |
| case TPM_API_CPU_LOOPBACK: |
| *api_section = TPM_CPU_LOOPBACK_ACL; |
| break; |
| case TPM_API_DS_LOAD_BALANCE: |
| *api_section = TPM_DS_LOAD_BALANCE_ACL; |
| break; |
| case TPM_API_L2_PRIM: |
| *api_section = TPM_L2_PRIM_ACL; |
| break; |
| case TPM_API_L3_TYPE: |
| *api_section = TPM_L3_TYPE_ACL; |
| break; |
| case TPM_API_IPV4: |
| *api_section = TPM_IPV4_ACL; |
| break; |
| case TPM_API_IPV4_MC: |
| *api_section = TPM_IPV4_MC; |
| break; |
| case TPM_API_IPV6_GEN: |
| *api_section = TPM_IPV6_GEN_ACL; |
| break; |
| case TPM_API_IPV6_MC: |
| *api_section = TPM_IPV6_MC_ACL; |
| break; |
| case TPM_API_IPV6_DIP: |
| *api_section = TPM_IPV6_DIP_ACL; |
| break; |
| case TPM_API_IPV6_NH: |
| *api_section = TPM_IPV6_NH_ACL; |
| break; |
| case TPM_API_IPV6_L4: |
| *api_section = TPM_L4_ACL; |
| break; |
| case TPM_API_CNM: |
| *api_section = TPM_CNM_MAIN_ACL; |
| break; |
| default: |
| error_code = TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| return (error_code); |
| } |
| |
| |
| int32_t tpm_db_api_type_get_from_api_section(tpm_api_sections_t api_section, tpm_api_type_t *api_type) |
| { |
| int32_t error_code = TPM_DB_OK; |
| |
| /*TODO - replace this w/ conf structure */ |
| |
| switch (api_section) { |
| case TPM_PNC_MAC_LEARN_ACL: |
| *api_type = TPM_API_MAC_LEARN; |
| break; |
| case TPM_CPU_LOOPBACK_ACL: |
| *api_type = TPM_API_CPU_LOOPBACK; |
| break; |
| case TPM_DS_LOAD_BALANCE_ACL: |
| *api_type = TPM_API_DS_LOAD_BALANCE; |
| break; |
| case TPM_L2_PRIM_ACL: |
| *api_type = TPM_API_L2_PRIM; |
| break; |
| case TPM_L3_TYPE_ACL: |
| *api_type = TPM_API_L3_TYPE; |
| break; |
| case TPM_IPV4_ACL: |
| *api_type = TPM_API_IPV4; |
| break; |
| case TPM_IPV4_MC: |
| *api_type = TPM_API_IPV4_MC; |
| break; |
| case TPM_IPV6_GEN_ACL: |
| *api_type = TPM_API_IPV6_GEN; |
| break; |
| case TPM_IPV6_DIP_ACL: |
| *api_type = TPM_API_IPV6_DIP; |
| break; |
| case TPM_IPV6_NH_ACL: |
| *api_type = TPM_API_IPV6_NH; |
| break; |
| case TPM_L4_ACL: |
| *api_type = TPM_API_IPV6_L4; |
| break; |
| default: |
| error_code = TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| return (error_code); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_get() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range to get data for |
| |
| * OUTPUTS: |
| * range_data - Returned DB structure of returned entry. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_get(tpm_pnc_ranges_t pnc_range, tpm_db_pnc_range_t *range_data) |
| { |
| uint32_t i; |
| |
| if ((pnc_range < 0) || (pnc_range > (TPM_MAX_NUM_RANGES - 1))) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID && PNC_RANGE_CONF(i).range_id == pnc_range) { |
| memcpy(range_data, &(tpm_db.pnc_range[i]), sizeof(tpm_db_pnc_range_t)); |
| return (TPM_DB_OK); |
| } |
| } |
| |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_get_range_start_end() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * pnc_range - The id of the pnc range to get data for |
| |
| * OUTPUTS: |
| * range_start - Returned the start of specific PnC range. |
| * range_end - Returned the end of specific PnC range. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_get_range_start_end(tpm_pnc_ranges_t pnc_range, uint32_t *range_start, uint32_t *range_end) |
| { |
| uint32_t i; |
| |
| if ((pnc_range < 0) || (pnc_range > (TPM_MAX_NUM_RANGES - 1))) |
| return(TPM_DB_ERR_INV_INPUT); |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if ((tpm_db.pnc_range[i].valid == TPM_DB_VALID) |
| && (PNC_RANGE_CONF(i).range_id == pnc_range)) { |
| *range_start = PNC_RANGE_CONF(i).range_start + PNC_RANGE_CONF(i).api_start; |
| *range_end = PNC_RANGE_CONF(i).range_end; |
| return(TPM_DB_OK); |
| } |
| } |
| |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_tbl_val_get_next() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * cur_ind - The current index (handle) to the pnc_range table. Function returns the next valid |
| * pnc range entry > cur_index. cur_index < 0 indicates to return first valid entry in table, |
| * valid next_ind values are 0 or higher |
| * OUTPUTS: |
| * next_ind - See cur_ind. If end of table was reached before valid entry, (-1) is returned in next_ind |
| * range_data - Returned DB structure of returned entry. When entry is invalid, range_data filled with zero. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_tbl_val_get_next(int32_t cur_ind, int32_t *next_ind, tpm_db_pnc_range_t *range_data) |
| { |
| int32_t i; |
| |
| /* Initialize first next_ind */ |
| if (cur_ind < 0) |
| i = 0; |
| else |
| i = cur_ind + 1; |
| |
| /* Check PnC range exists in DB */ |
| for (; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID) { |
| /* Return Data Structure */ |
| memcpy(range_data, &(tpm_db.pnc_range[i]), sizeof(tpm_db_pnc_range_t)); |
| *next_ind = i; |
| return (TPM_DB_OK); |
| } |
| } |
| *next_ind = -1; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_val_get_next() |
| * |
| * DESCRIPTION: Returns DB info of the next valid PnC range. |
| * Similar to "tpm_db_pnc_rng_tbl_val_get_next", but the handle is the range_id, not the table_index. |
| * |
| * INPUTS: |
| * cur_range - The current pnc_range in the pnc_range table. Function returns the next valid |
| * pnc_range > cur_range. cur_range < 0 indicates to return first valid entry in table, |
| * valid next_ind values are 0 or higher |
| * OUTPUTS: |
| * next_range - See cur_range. If end of table was reached before valid entry, (-1) is returned in next_range |
| * range_data - Returned DB structure of returned entry. When entry is invalid, range_data filled with zero. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_val_get_next(tpm_pnc_ranges_t cur_range, |
| tpm_pnc_ranges_t *next_range, tpm_db_pnc_range_t *range_data) |
| { |
| uint32_t i; |
| uint32_t l_min_index = 0; /* oren - add init value, need to check */ |
| tpm_pnc_ranges_t l_min_range = TPM_MAX_RANGE + 1; |
| |
| /* Check smallest valid next_PnC range in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| /*printf("i(%d) valid(%x) range_id(%d), cur_range(%d) l_min_range(%d)\n", |
| i,tpm_db.pnc_range[i].valid, PNC_RANGE_CONF(i).range_id, cur_range,l_min_range); */ |
| if ((tpm_db.pnc_range[i].valid == TPM_DB_VALID) && (PNC_RANGE_CONF(i).range_id > cur_range) |
| && (PNC_RANGE_CONF(i).range_id < l_min_range)) { |
| l_min_range = PNC_RANGE_CONF(i).range_id; |
| l_min_index = i; |
| } |
| } |
| if (l_min_range <= TPM_MAX_RANGE) { |
| /* Return Data Structure */ |
| memcpy(range_data, &(tpm_db.pnc_range[l_min_index]), sizeof(tpm_db_pnc_range_t)); |
| *next_range = l_min_range; |
| return (TPM_DB_OK); |
| } |
| |
| /* No valid next range found */ |
| *next_range = -1; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_conf_get() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * range_id - Range number to retrieve configuration for |
| |
| * OUTPUTS: |
| * range_conf - Structure for pnc_range Configuration Info |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_conf_get(tpm_pnc_ranges_t range_id, tpm_db_pnc_range_conf_t *range_conf) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == range_id) { |
| /* Return Data Structure */ |
| memcpy(range_conf, &(tpm_db.pnc_range[i].pnc_range_conf), sizeof(tpm_db_pnc_range_conf_t)); |
| return (TPM_DB_OK); |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_oper_get() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * range_id - Range number to retrieve configuration for |
| |
| * OUTPUTS: |
| * range_oper - Structure for pnc_range Operational Info |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_oper_get(tpm_pnc_ranges_t range_id, tpm_db_pnc_range_oper_t *range_oper) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == range_id) { |
| /* Return Data Structure */ |
| memcpy(range_oper, &(tpm_db.pnc_range[i].pnc_range_oper), sizeof(tpm_db_pnc_range_oper_t)); |
| return (TPM_DB_OK); |
| } |
| } |
| /* pnc_range not found */ |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_rng_free_ent_get() |
| * |
| * DESCRIPTION: Returns number of free entries of PnC range |
| * |
| * INPUTS: |
| * range_id - Range number to retrieve number of free entries |
| |
| * OUTPUTS: |
| * free_entries - Number of free entries in Table |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_rng_free_ent_get(tpm_pnc_ranges_t range_id, uint32_t *free_entries) |
| { |
| uint32_t i; |
| |
| /* Check PnC range exists in DB */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) { |
| if (tpm_db.pnc_range[i].valid == TPM_DB_VALID |
| && tpm_db.pnc_range[i].pnc_range_conf.range_id == range_id) { |
| /* Return Free Entries */ |
| *free_entries = PNC_RANGE_OPER(i).free_entries; |
| return (TPM_DB_OK); |
| } |
| } |
| /* pnc_range not found */ |
| *free_entries = 0; |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_owner_set() |
| * |
| * DESCRIPTION: Creates an owner_id in the DB. |
| * |
| * INPUTS: |
| * owner_id - Id of new owner |
| |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_owner_set(uint32_t owner_id) |
| { |
| uint32_t i; |
| int32_t free_ind = -1; |
| |
| /* Check owner was not already set */ |
| for (i = 0; i < TPM_MAX_API_TYPES; i++) { |
| if ((tpm_db.owners[i].valid == TPM_DB_VALID) && (tpm_db.owners[i].owner_id == owner_id)) |
| return (TPM_DB_ERR_REC_EXIST); |
| if ((free_ind == -1) && (tpm_db.owners[i].valid == TPM_DB_INVALID)) |
| free_ind = i; |
| } |
| if (free_ind == -1) |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| |
| /* Set on first free index */ |
| tpm_db.owners[free_ind].valid = TPM_DB_VALID; |
| tpm_db.owners[free_ind].owner_id = owner_id; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_owner_get_next() |
| * |
| * DESCRIPTION: Returns DB info of PnC range |
| * |
| * INPUTS: |
| * cur_ind - The current index (handle) to the owner table. Function returns the next |
| * valid table entry > cur_index. cur_index < 0 indicates to return first valid entry in table, |
| * valid next_ind values are 0 or higher. |
| * OUTPUTS: |
| * next_ind - See cur_ind. If end of table was reached before valid entry, (-1) is returned in next_ind |
| * owner - Returns the owner of the next index. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. No more owners is not considered error. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_owner_get_next(int32_t cur_ind, int32_t *next_ind, uint32_t *owner) |
| { |
| uint32_t i; |
| |
| /* Initialize first next_ind */ |
| if (cur_ind < 0) |
| i = 0; |
| else |
| i = cur_ind + 1; |
| |
| /* Check owner exists in DB */ |
| for (; i < TPM_MAX_API_TYPES; i++) { |
| if (tpm_db.owners[i].valid == TPM_DB_VALID) { /* oren - changed = to ==, need to check */ |
| /* Return Data Structure */ |
| *next_ind = i; |
| *owner = tpm_db.owners[i].owner_id; |
| return (TPM_DB_OK); |
| } |
| } |
| /* No valid entry found */ |
| *next_ind = -1; |
| |
| return (TPM_DB_OK); |
| } |
| |
| #if 0 |
| /******************************************************************************* |
| * tpm_db_apig_set() |
| * |
| * DESCRIPTION: Creates an API Group in the DB. |
| * |
| * INPUTS: |
| * owner_id - owner of the API Group |
| * api_type - API Group being created |
| |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| |
| int32_t tpm_db_apig_set(uint32_t owner_id, tpm_api_type_t api_type) |
| { |
| uint32_t i; |
| |
| /* Check owner exists */ |
| for (i = 0; i < TPM_MAX_API_TYPES; i++) { |
| if ((tpm_db.owners[i].valid == TPM_DB_VALID) && (tpm_db.owners[i].owner_id == owner_id)) |
| break; |
| } |
| if (i == TPM_MAX_API_TYPES) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| /* Check api_type does not exist */ |
| if (tpm_db.api_groups[api_type].valid == TPM_DB_VALID) |
| return (TPM_DB_ERR_REC_EXIST); |
| |
| tpm_db.api_groups[api_type].valid = TPM_DB_VALID; |
| tpm_db.api_groups[api_type].api_owner_id = owner_id; |
| tpm_db.api_groups[api_type].api_type = api_type; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_apig_get_next() |
| * |
| * DESCRIPTION: Returns DB info of API Group |
| * |
| * INPUTS: |
| * cur_ind - The current index (handle) to the owner table. Function returns the next |
| * valid table entry > cur_index. cur_index < 0 indicates to return first valid entry in table, |
| * valid next_ind values are 0 or higher. |
| * OUTPUTS: |
| * next_ind - See cur_ind. If end of table was reached before valid entry, (-1) is returned in next_ind |
| * api_type - Returns the API Group. |
| * owner - Returns the owner of the API Group. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_apig_get_next(int32_t cur_ind, int32_t *next_ind, uint32_t *owner, tpm_api_type_t *api_type) |
| { |
| uint32_t i; |
| |
| /* Initialize first next_ind */ |
| if (cur_ind < 0) |
| i = 0; |
| else |
| i = cur_ind + 1; |
| |
| /* Check API Group exists in DB */ |
| for (; i < TPM_MAX_API_TYPES; i++) { |
| if (tpm_db.api_groups[i].valid == TPM_DB_VALID) { |
| /* Return Data */ |
| *next_ind = i; |
| *api_type = tpm_db.api_groups[i].api_type; |
| *owner = tpm_db.api_groups[i].api_owner_id; |
| return (TPM_DB_OK); |
| } |
| } |
| /* No valid entry found */ |
| *next_ind = -1; |
| return (TPM_DB_OK); |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_igmp_set_port_frwd_mode() |
| * |
| * DESCRIPTION: Set the IGMP status of a UNI port or WAN port |
| * |
| * INPUTS: |
| * src_port - source port to set |
| * igmp_state - how to process IGMP packets |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_set_port_frwd_mode(uint32_t port, uint32_t mode) |
| { |
| tpm_db.igmp_def.frwd_mode[port] = mode; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_igmp_get_port_frwd_mode() |
| * |
| * DESCRIPTION: Get the IGMP status of a UNI port or WAN port |
| * |
| * INPUTS: |
| * src_port - source port to get |
| * |
| * OUTPUTS: |
| * igmp_state - how to process IGMP packets |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_get_port_frwd_mode(uint32_t port, uint32_t *mode) |
| { |
| *mode = tpm_db.igmp_def.frwd_mode[port]; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_igmp_set_cpu_queue() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_set_cpu_queue(uint32_t queue) |
| { |
| tpm_db.igmp_def.cpu_queue = queue; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_igmp_get_cpu_queue() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_get_cpu_queue(uint32_t *queue) |
| { |
| *queue = tpm_db.igmp_def.cpu_queue; |
| return (TPM_DB_OK); |
| } |
| |
| |
| /******************************************************************************* |
| * tpm_db_igmp_set_snoop_enable() |
| * |
| * DESCRIPTION: Set IGMP snoop enable |
| * |
| * INPUTS: |
| * igmp_snoop_enable - IGMP snoop enable |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_set_snoop_enable(uint32_t igmp_snoop_enable) |
| { |
| tpm_db.igmp_def.igmp_snoop_enable = igmp_snoop_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_igmp_get_snoop_enable() |
| * |
| * DESCRIPTION: Get IGMP snoop enable |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop_enable - IGMP snoop enable |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_igmp_get_snoop_enable(uint32_t *igmp_snoop_enable) |
| { |
| *igmp_snoop_enable = tpm_db.igmp_def.igmp_snoop_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_type_set() |
| * |
| * DESCRIPTION: Set OMCI ethertype |
| * |
| * INPUTS: |
| * omci_etype - OMCI Ethertype |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_omci_type_set(uint32_t omci_etype) |
| { |
| tpm_db.init_misc.omci_etype = omci_etype; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_type_get() |
| * |
| * DESCRIPTION: Get OMCI ethertype |
| * |
| * OUTPUTS: |
| * omci_etype - OMCI Ethertype |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_omci_type_get(uint32_t *omci_etype) |
| { |
| *omci_etype = tpm_db.init_misc.omci_etype; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_channel_set() |
| * |
| * DESCRIPTION: Set OMCI channel parameters |
| * |
| * INPUTS: |
| * gemport - OMCI GEM port ID |
| * cpu_rx_q - OMCI cpu rx queue |
| * cpu_tx_q - OMCI cpu tx queue |
| * tcont_id - OMCI tcont ID |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_omci_channel_set(uint16_t gemport, uint32_t cpu_rx_q, uint32_t cpu_tx_q, uint32_t tcont_id) |
| { |
| tpm_db.init_misc.omci_gemport = gemport; |
| tpm_db.init_misc.oam_cpu_rx_q = cpu_rx_q; |
| tpm_db.init_misc.oam_cpu_tx_q = cpu_tx_q; |
| tpm_db.init_misc.oam_cpu_tx_port = tcont_id; |
| tpm_db.init_misc.oam_channel_configured = 1; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_channel_remove() |
| * |
| * DESCRIPTION: Remove OMCI channel parameters |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_omci_channel_remove(void) |
| { |
| tpm_db.init_misc.omci_gemport = 0; |
| tpm_db.init_misc.oam_cpu_rx_q = 0; |
| tpm_db.init_misc.oam_cpu_tx_q = 0; |
| tpm_db.init_misc.oam_cpu_tx_port = 0; |
| tpm_db.init_misc.oam_channel_configured = 0; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_oam_loopback_state_get() |
| * |
| * DESCRIPTION: Get OAM loopback configure state |
| * |
| * OUTPUTS: |
| * omci_etype - OMCI Ethertype |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_loopback_state_get(uint32_t *loopback) |
| { |
| *loopback = tpm_db.init_misc.oam_loopback_channel_configured; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_oam_loopback_channel_set() |
| * |
| * DESCRIPTION: Set OAM loopback channel state |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_loopback_channel_set(void) |
| { |
| tpm_db.init_misc.oam_loopback_channel_configured = 1; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_channel_remove() |
| * |
| * DESCRIPTION: Remove OMCI channel parameters |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_loopback_channel_remove(void) |
| { |
| tpm_db.init_misc.oam_loopback_channel_configured = 0; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_omci_channel_get() |
| * |
| * DESCRIPTION: Get OMCI channel parameters |
| * |
| * INPUTS: |
| * gemport - OMCI GEM port ID |
| * cpu_rx_q - OMCI cpu rx queue |
| * cpu_tx_q - OMCI cpu tx queue |
| * tcont_id - OMCI tcont ID |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_omci_channel_get(uint32_t *valid, uint16_t *gemport, uint32_t *cpu_rx_q, uint32_t *cpu_tx_q, |
| uint32_t *tcont_id) |
| { |
| *gemport = tpm_db.init_misc.omci_gemport; |
| *cpu_rx_q = tpm_db.init_misc.oam_cpu_rx_q; |
| *cpu_tx_q = tpm_db.init_misc.oam_cpu_tx_q; |
| *tcont_id = tpm_db.init_misc.oam_cpu_tx_port; |
| *valid = tpm_db.init_misc.oam_channel_configured; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_oam_channel_set() |
| * |
| * DESCRIPTION: Set OAM channel parameters |
| * |
| * INPUTS: |
| * cpu_rx_q - OAM cpu rx queue |
| * cpu_tx_q - OAM cpu tx queue |
| * llid - OAM LLID |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_channel_set(uint32_t cpu_rx_q, uint32_t cpu_tx_q, uint32_t llid) |
| { |
| tpm_db.init_misc.oam_cpu_rx_q = cpu_rx_q; |
| tpm_db.init_misc.oam_cpu_tx_q = cpu_tx_q; |
| tpm_db.init_misc.oam_cpu_tx_port = llid; |
| tpm_db.init_misc.oam_channel_configured = 1; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_oam_channel_remove() |
| * |
| * DESCRIPTION: Remove OAM channel parameters |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_channel_remove(void) |
| { |
| tpm_db.init_misc.omci_gemport = 0; |
| tpm_db.init_misc.oam_cpu_rx_q = 0; |
| tpm_db.init_misc.oam_cpu_tx_q = 0; |
| tpm_db.init_misc.oam_cpu_tx_port = 0; |
| tpm_db.init_misc.oam_channel_configured = 0; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_oam_channel_get() |
| * |
| * DESCRIPTION: Get OAM channel parameters |
| * |
| * INPUTS: |
| * cpu_rx_q - OAM cpu rx queue |
| * cpu_tx_q - OAM cpu tx queue |
| * tcont_id - OAM llid |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_oam_channel_get(uint32_t *valid, uint32_t *cpu_rx_q, uint32_t *cpu_tx_q, uint32_t *llid) |
| { |
| *cpu_rx_q = tpm_db.init_misc.oam_cpu_rx_q; |
| *cpu_tx_q = tpm_db.init_misc.oam_cpu_tx_q; |
| *llid = tpm_db.init_misc.oam_cpu_tx_port; |
| *valid = tpm_db.init_misc.oam_channel_configured; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_init_deb_port_set() |
| * |
| * DESCRIPTION: Set Init Debug Port |
| * |
| * INPUTS: |
| * pnc_init_debug_port - Set the debug Port, which will be preconfigured to send |
| * all traffic to CPU (NFS port for development) |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| #if 0 |
| int32_t tpm_db_pnc_init_deb_port_set(uint32_t pnc_init_debug_port) |
| { |
| tpm_db.init_misc.pnc_init_debug_port = pnc_init_debug_port; |
| |
| return (TPM_DB_OK); |
| |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_pnc_init_deb_port_get() |
| * |
| * DESCRIPTION: Get Debug Port |
| * |
| * OUTPUTS: |
| * pnc_init_debug_port - Get the debug Port, which will be preconfigured to send all |
| * traffic to CPU (NFS port for development) |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| #if 0 |
| int32_t tpm_db_pnc_init_deb_port_get(uint32_t *pnc_init_debug_port) |
| { |
| *pnc_init_debug_port = tpm_db.init_misc.pnc_init_debug_port; |
| |
| return (TPM_DB_OK); |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_init_done_set() |
| * |
| * DESCRIPTION: Set TPM was successfully Initialized |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_init_done_set(void) |
| { |
| tpm_db.init_misc.tpm_init_succeeded = TPM_DB_VALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_init_done_get() |
| * |
| * DESCRIPTION: Get value if TPM was successfully Initialized |
| * |
| * OUTPUTS: |
| * tpm_init_succeeded - |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_init_done_get(void) |
| { |
| if (tpm_db.init_misc.tpm_init_succeeded == TPM_DB_VALID) |
| return (1); |
| return (0); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pon_type_set() |
| * |
| * DESCRIPTION: Set WAN technology |
| * |
| * INPUTS: |
| * pon_type - GPON, EPON, Ethernet or None |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pon_type_set(tpm_db_pon_type_t pon_type) |
| { |
| tpm_db.init_misc.pon_type = pon_type; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pon_type_get() |
| * |
| * DESCRIPTION: Get WAN technology |
| * |
| * OUTPUTS: |
| * pon_type - GPON, EPON, Ethernet or None |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pon_type_get(tpm_db_pon_type_t *pon_type) |
| { |
| *pon_type = tpm_db.init_misc.pon_type; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_active_wan_set() |
| * |
| * DESCRIPTION: Set WAN technology |
| * |
| * INPUTS: |
| * pon_type - GPON, EPON, Ethernet or None |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_active_wan_set(tpm_gmacs_enum_t active_wan) |
| { |
| tpm_db.init_misc.active_wan = active_wan; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_active_wan_get() |
| * |
| * DESCRIPTION: Set WAN technology |
| * |
| * INPUTS: |
| * pon_type - GPON, EPON, Ethernet or None |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| tpm_gmacs_enum_t tpm_db_active_wan_get() |
| { |
| return tpm_db.init_misc.active_wan; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_mac_learn_enable_set() |
| * |
| * DESCRIPTION: |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_mac_learn_enable_set(tpm_init_pnc_mac_learn_enable_t pnc_mac_learn_enable) |
| { |
| tpm_db.init_misc.pnc_mac_learn_enable = pnc_mac_learn_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_mac_learn_enable_get() |
| * |
| * DESCRIPTION: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_mac_learn_enable_get(tpm_init_pnc_mac_learn_enable_t *pnc_mac_learn_enable) |
| { |
| *pnc_mac_learn_enable = tpm_db.init_misc.pnc_mac_learn_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_fc_conf_set() |
| * |
| * DESCRIPTION: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_fc_conf_set(tpm_init_fc_params_t *port_fc_conf) |
| { |
| memcpy(&tpm_db.port_fc_conf, port_fc_conf, sizeof(tpm_db_fc_params_t)); |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_fc_conf_get() |
| * |
| * DESCRIPTION: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_fc_conf_get(tpm_init_fc_params_t *port_fc_conf) |
| { |
| memcpy(port_fc_conf, &tpm_db.port_fc_conf, sizeof(tpm_db_fc_params_t)); |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_switch_init_set() |
| * |
| * DESCRIPTION: Set Amber Initialization |
| * |
| * INPUTS: |
| * switch_init |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_switch_init_set(uint32_t switch_init) |
| { |
| tpm_db.func_profile.switch_init = switch_init; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_switch_init_get() |
| * |
| * DESCRIPTION: Get Amber Initialization |
| * |
| * INPUTS: |
| * switch_init |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_switch_init_get(uint32_t *switch_init) |
| { |
| *switch_init = tpm_db.func_profile.switch_init; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ds_mh_set_conf_set() |
| * |
| * DESCRIPTION: Set downstream marvell header source select |
| * |
| * INPUTS: |
| * ds_mh_set_conf - Allow set MH in Pnc or not |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ds_mh_set_conf_set(tpm_db_mh_src_t ds_mh_set_conf) |
| { |
| tpm_db.init_misc.ds_mh_set_conf = ds_mh_set_conf; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ds_mh_get_conf_set() |
| * |
| * DESCRIPTION: Set downstream marvell header source select |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * ds_mh_set_conf - Allow set MH in Pnc or not |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ds_mh_get_conf_set(tpm_db_mh_src_t *ds_mh_set_conf) |
| { |
| *ds_mh_set_conf = tpm_db.init_misc.ds_mh_set_conf; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_cfg_pnc_parse_set() |
| * |
| * DESCRIPTION: Set config PNC parse enabled/disabled in DB |
| * |
| * INPUTS: |
| * cfg_pnc_parse 0=DISABLED / 1=ENABLED |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_cfg_pnc_parse_set(tpm_init_cfg_pnc_parse_t cfg_pnc_parse) |
| { |
| tpm_db.init_misc.cfg_pnc_parse = cfg_pnc_parse; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_cpu_loopback_set() |
| * |
| * DESCRIPTION: Set cpu loopback enabled/disabled in DB |
| * |
| * INPUTS: |
| * cpu_loopback 0=DISABLED / 1=ENABLED |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_cpu_loopback_set(tpm_init_cpu_loopback_t cpu_loopback) |
| { |
| tpm_db.init_misc.cpu_loopback = cpu_loopback; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_cfg_pnc_parse_get() |
| * |
| * DESCRIPTION: Get config PNC parse enabled/disabled in DB |
| * |
| * OUTPUTS: |
| * cfg_pnc_parse_val 0=DISABLED / 1=ENABLED |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_cfg_pnc_parse_get(tpm_init_cfg_pnc_parse_t *cfg_pnc_parse_val) |
| { |
| *cfg_pnc_parse_val = tpm_db.init_misc.cfg_pnc_parse; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_cpu_loopback_get() |
| * |
| * DESCRIPTION: Get CPU loopback enabled/disabled in DB |
| * |
| * OUTPUTS: |
| * cpu_loopback_val 0=DISABLED / 1=ENABLED |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_cpu_loopback_get(tpm_init_cpu_loopback_t *cpu_loopback_val) |
| { |
| *cpu_loopback_val = tpm_db.init_misc.cpu_loopback; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_double_tag_support_set() |
| * |
| * DESCRIPTION: Set config double tagged supported in DB |
| * |
| * INPUTS: |
| * dbl_tag 0=DISABLED / 1=ENABLED |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_double_tag_support_set(tpm_init_double_tag_t dbl_tag) |
| { |
| tpm_db.init_misc.dbl_tag = dbl_tag; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_double_tag_support_get() |
| * |
| * DESCRIPTION: Get config double tagged supported in DB |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_double_tag_support_get(tpm_init_double_tag_t *dbl_tag) |
| { |
| *dbl_tag = tpm_db.init_misc.dbl_tag; |
| |
| return (TPM_DB_OK); |
| } |
| |
| #if 0 |
| /******************************************************************************* |
| * tpm_db_default_tag_tpid_set() |
| * |
| * DESCRIPTION: Set tpid of one/two vlan tag in DB |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_default_tag_tpid_set(uint16_t vlan1_tpid, uint16_t vlan2_tpid) |
| { |
| tpm_db.init_misc.vlan1_tpid = vlan1_tpid; |
| tpm_db.init_misc.vlan2_tpid = vlan2_tpid; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_default_tag_tpid_get() |
| * |
| * DESCRIPTION: Get tpid of one/two vlan tag in DB |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_default_tag_tpid_get(uint16_t *vlan1_tpid, uint16_t *vlan2_tpid) |
| { |
| *vlan1_tpid = tpm_db.init_misc.vlan1_tpid; |
| *vlan2_tpid = tpm_db.init_misc.vlan2_tpid; |
| |
| return (TPM_DB_OK); |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_default_tag_tpid_set() |
| * |
| * DESCRIPTION: Set tpid of one/two vlan tag in DB |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_default_tag_tpid_set(tpm_init_tpid_opt_t *tag_tpid) |
| { |
| memcpy(&tpm_db.init_misc.tag_tpid, tag_tpid, sizeof(tpm_init_tpid_opt_t)); |
| return(TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_default_tag_tpid_get() |
| * |
| * DESCRIPTION: Get tpid of one/two vlan tag in DB |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_default_tag_tpid_get(tpm_init_tpid_opt_t *tag_tpid) |
| { |
| memcpy(tag_tpid, &tpm_db.init_misc.tag_tpid, sizeof(tpm_init_tpid_opt_t)); |
| return(TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_virt_info_set() |
| * |
| * DESCRIPTION: Set wifi via UNI in TPM DB |
| * |
| * INPUTS: |
| * virt_uni_info.enabled 0=DISABLED / 1=ENABLED |
| * virt_uni_info.uni_port port# |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_virt_info_set(tpm_init_virt_uni_t virt_uni_info) |
| { |
| tpm_db.func_profile.virt_uni_info.enabled = virt_uni_info.enabled; |
| tpm_db.func_profile.virt_uni_info.uni_port = virt_uni_info.uni_port; |
| tpm_db.func_profile.virt_uni_info.switch_port = virt_uni_info.switch_port; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_virt_info_get() |
| * |
| * DESCRIPTION: Get wifi via UNI in TPM DB |
| * |
| * OUTPUTS: |
| * virt_uni_info.enabled 0=DISABLED / 1=ENABLED |
| * virt_uni_info.uni_port port# |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_virt_info_get(tpm_init_virt_uni_t *virt_uni_info) |
| { |
| virt_uni_info->enabled = tpm_db.func_profile.virt_uni_info.enabled; |
| virt_uni_info->uni_port = tpm_db.func_profile.virt_uni_info.uni_port; |
| virt_uni_info->switch_port = tpm_db.func_profile.virt_uni_info.switch_port; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ipv6_5t_enable_set() |
| * |
| * DESCRIPTION: |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ipv6_5t_enable_set(tpm_init_ipv6_5t_enable_t ipv6_5t_enable) |
| { |
| tpm_db.init_misc.ipv6_5t_enable = ipv6_5t_enable; |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ipv6_5t_enable_get() |
| * |
| * DESCRIPTION: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ipv6_5t_enable_get(tpm_init_ipv6_5t_enable_t *ipv6_5t_enable) |
| { |
| *ipv6_5t_enable = tpm_db.init_misc.ipv6_5t_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_port_vector_tbl_info_set() |
| * |
| * DESCRIPTION: Set MH port vector table in TPM DB. |
| * |
| * OUTPUTS: |
| * tpm_mh_port_vector_tbl_new |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_port_vector_tbl_info_set(uint32_t reg_num, uint32_t uni_vector, uint16_t amber_port_vector, |
| uint32_t pnc_vector) |
| { |
| if (TPM_TX_MAX_MH_REGS <= reg_num) |
| return TPM_DB_ERR_REC_INV; |
| |
| tpm_db.tpm_mh_port_vector_tbl[reg_num].uni_vector = uni_vector; |
| tpm_db.tpm_mh_port_vector_tbl[reg_num].pnc_vector = pnc_vector; |
| tpm_db.tpm_mh_port_vector_tbl[reg_num].amber_port_vector = amber_port_vector; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_port_vector_tbl_info_get() |
| * |
| * DESCRIPTION: Get MH port vector table in TPM DB. |
| * |
| * OUTPUTS: |
| * tpm_mh_port_vector_tbl_new |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_port_vector_tbl_info_get(uint32_t reg_num, uint32_t *uni_vector, uint16_t *amber_port_vector, |
| uint32_t *pnc_vector) |
| { |
| if (TPM_TX_MAX_MH_REGS <= reg_num) |
| return TPM_DB_ERR_REC_INV; |
| |
| *uni_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].uni_vector; |
| *pnc_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].pnc_vector; |
| *amber_port_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].amber_port_vector; |
| return (TPM_DB_OK); |
| } |
| |
| |
| /******************************************************************************* |
| * tpm_db_port_vector_tbl_info_search() |
| * |
| * DESCRIPTION: Search in the MH port vector table in TPM DB for matching target port |
| * |
| * OUTPUTS: |
| * tpm_mh_port_vector_tbl_new |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_port_vector_tbl_info_search(tpm_trg_port_type_t trg_port, uint32_t *uni_vector, |
| uint16_t *amber_port_vector, uint32_t *pnc_vector) |
| { |
| uint32_t reg_num; |
| |
| for (reg_num = 0; reg_num < TPM_TX_MAX_MH_REGS; reg_num++) { |
| if (trg_port == tpm_db.tpm_mh_port_vector_tbl[reg_num].uni_vector) { |
| *uni_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].uni_vector; |
| *pnc_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].pnc_vector; |
| *amber_port_vector = tpm_db.tpm_mh_port_vector_tbl[reg_num].amber_port_vector; |
| return TPM_DB_OK; |
| } |
| } |
| |
| return TPM_DB_ERR_REC_INV; |
| } |
| |
| |
| |
| /******************************************************************************* |
| * tpm_db_api_section_ent_tbl_reset() |
| * |
| * DESCRIPTION: Reset an API table/acl |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_ent_tbl_reset(uint32_t start_entry, uint32_t num_entries) |
| { |
| uint32_t i; |
| |
| /*Init API Rng Entries */ |
| memset(&(tpm_db.api_ent_mem_area[mem_alloc_start_ind]), 0, (num_entries) * (sizeof(tpm_db_api_entry_t))); |
| |
| /* Invalidate API Rng Entries */ |
| for (i = start_entry; i < (start_entry + num_entries); i++) |
| tpm_db.api_ent_mem_area[i].valid = TPM_DB_INVALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_ent_tbl_get() |
| * |
| * DESCRIPTION: get an API table/acl entry |
| * |
| * INPUTS: |
| * api_sec - Section of the API acl/table |
| * index - rule index |
| * OUTPUTS: |
| * api_ent_mem_area - table/acl entry |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_ent_tbl_get(tpm_api_sections_t api_sec, tpm_db_api_entry_t *api_ent_mem_area, uint32_t index) |
| { |
| if (ILLEGAL_API_SEC(api_sec)) |
| IF_ERROR_I(TPM_DB_ERR_REC_NOT_EXIST, api_sec); |
| |
| if (NULL == api_ent_mem_area) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memcpy(api_ent_mem_area, &tpm_db.api_ent_mem_area[(tpm_db.api_section[api_sec].table_start) + index], sizeof(tpm_db_api_entry_t)); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_init() |
| * |
| * DESCRIPTION: Initialize an API table/acl |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * api_rng_size - Size of the table/acl |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_init(tpm_api_sections_t api_section, tpm_pnc_ranges_t prim_pnc_range, uint32_t api_rng_size) |
| { |
| |
| /* Check that new api_rng table does not cross allocation boundaries */ |
| if ((mem_alloc_start_ind + api_rng_size) > TPM_DB_API_ENTRIES_TBL_SIZE) { |
| TPM_OS_ERROR(TPM_DB_MOD, " API Range not created, Entries Area overflow, " |
| "ind_start(%d), api_rng_size(%d), mem_area_size(%d) \n", |
| mem_alloc_start_ind, api_rng_size, TPM_DB_API_ENTRIES_TBL_SIZE); |
| |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| if ((mem_alloc_start_ind + api_rng_size) > (TPM_DB_API_ENTRIES_TBL_SIZE - TPM_DB_API_SECTION_MARGIN_SIZE)) { |
| TPM_OS_WARN(TPM_DB_MOD, "Entries Area has less than calculated end margin, " |
| "ind_start(%d), api_rng_size(%d), mem_area_size(%d)\n", |
| mem_alloc_start_ind, api_rng_size, TPM_DB_API_ENTRIES_TBL_SIZE); |
| } |
| |
| /*Init API Range */ |
| memset(&(tpm_db.api_section[api_section]), 0, sizeof(tpm_db_api_section_t)); |
| |
| tpm_db_api_section_ent_tbl_reset(mem_alloc_start_ind, api_rng_size); |
| |
| tpm_db.api_section[api_section].table_size = api_rng_size; |
| tpm_db.api_section[api_section].table_start = mem_alloc_start_ind; |
| tpm_db.api_section[api_section].valid = TPM_DB_VALID; |
| tpm_db.api_section[api_section].prim_pnc_range = prim_pnc_range; |
| tpm_db.api_section[api_section].last_valid_entry = -1; |
| tpm_db.api_section[api_section].last_valid_index = -1; |
| tpm_db.api_section[api_section].num_valid_entries = 0; |
| |
| /* Forward to next 'API Entries table' start_index. |
| * This also inserts 'margin_size' between subsequent 'API Entries table' */ |
| mem_alloc_start_ind += (api_rng_size + TPM_DB_API_SECTION_MARGIN_SIZE); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entries_area_reset() |
| * |
| * DESCRIPTION: Reset an API table/acl |
| * |
| * INPUTS: |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entries_area_reset(void) |
| { |
| /* Stripe API Entries Area */ |
| memset(tpm_db.api_ent_mem_area, MEM_MARGIN_PATTERN, sizeof(tpm_db.api_ent_mem_area)); |
| |
| /* Reset Area Index, Start Area offset at margin_size */ |
| mem_alloc_start_ind = TPM_DB_API_SECTION_MARGIN_SIZE; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_invalidate() |
| * |
| * DESCRIPTION: Reset an API table/acl |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_invalidate(tpm_api_sections_t api_section) |
| { |
| /*Init API Range */ |
| memset(&(tpm_db.api_section[api_section]), 0, sizeof(tpm_db_api_section_t)); |
| |
| /* Invalidate Range */ |
| tpm_db.api_section[api_section].valid = TPM_DB_INVALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_reset() |
| * |
| * DESCRIPTION: Initialize an API table/acl |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_reset(tpm_api_sections_t api_section) |
| { |
| /* prim_pnc_range, table_size, table_start attributes are retained from init */ |
| |
| tpm_db.api_section[api_section].num_valid_entries = 0; |
| tpm_db.api_section[api_section].last_valid_entry = -1; |
| tpm_db.api_section[api_section].last_valid_index = -1; |
| |
| /* Invalidate all API entries */ |
| tpm_db_api_section_ent_tbl_reset(tpm_db.api_section[api_section].table_start, |
| tpm_db.api_section[api_section].table_size); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_get() |
| * |
| * DESCRIPTION: Get |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * api_rng_size - API range size |
| * num_valid_entries- Number of valid entries |
| * last_valid - Last valid entry |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_get(tpm_api_sections_t api_section, |
| uint32_t *api_rng_size, |
| uint32_t *num_valid_entries, |
| tpm_pnc_ranges_t *prim_pnc_range, |
| int32_t *last_valid_entry, |
| uint32_t *tbl_start) |
| { |
| if (ILLEGAL_API_SEC(api_section)) |
| IF_ERROR_I(TPM_DB_ERR_REC_NOT_EXIST, api_section); |
| |
| if (tpm_db.api_section[api_section].valid == TPM_DB_INVALID) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| *api_rng_size = tpm_db.api_section[api_section].table_size; |
| *num_valid_entries = tpm_db.api_section[api_section].num_valid_entries; |
| *prim_pnc_range = tpm_db.api_section[api_section].prim_pnc_range; |
| *last_valid_entry = tpm_db.api_section[api_section].last_valid_entry; |
| *tbl_start = tpm_db.api_section[api_section].table_start; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, |
| "returned size(%d), num_entries(%d), prim_pnc_range(%d), last_valid_entry (%d) tbl_start(%d)\n", |
| *api_rng_size, *num_valid_entries, *prim_pnc_range, *last_valid_entry, *tbl_start); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_lastentry_get() |
| * |
| * DESCRIPTION: Get |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * last_valid - Last valid entry |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_lastentry_get(tpm_api_sections_t api_section, int32_t *last_valid_entry) |
| { |
| if (tpm_db.api_section[api_section].valid == TPM_DB_INVALID) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| *last_valid_entry = tpm_db.api_section[api_section].last_valid_entry; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_main_pnc_get() |
| * |
| * DESCRIPTION: Get |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * prim_pnc_range - Primary PNC Range for this API ACL/Table |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_main_pnc_get(tpm_api_sections_t api_section, tpm_pnc_ranges_t *prim_pnc_range) |
| { |
| if (tpm_db.api_section[api_section].valid == TPM_DB_INVALID) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| *prim_pnc_range = tpm_db.api_section[api_section].prim_pnc_range; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_num_entries_get() |
| * |
| * DESCRIPTION: Get |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * num_entries - Number of valid entries |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_num_entries_get(tpm_api_sections_t api_section, uint32_t *num_entries) |
| { |
| if (tpm_db.api_section[api_section].valid == TPM_DB_INVALID) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| *num_entries = tpm_db.api_section[api_section].num_valid_entries; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_val_get_next() |
| * |
| * DESCRIPTION: Get next valid API range |
| * |
| * INPUTS: |
| * cur_api_section - Section of the API acl/table |
| * OUTPUTS: |
| * api_rng_size - API range size |
| * num_valid_entries- Number of valid entries |
| * last_valid - Last valid entry |
| * next_section |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_val_get_next(int32_t cur_api_section, |
| int32_t *next_section, |
| uint32_t *api_rng_size, |
| uint32_t *num_valid_entries, int32_t *last_valid_entry, uint32_t *tbl_start) |
| { |
| uint32_t x; |
| |
| /* Check Params */ |
| if (cur_api_section < -1 || cur_api_section >= TPM_MAX_NUM_API_SECTIONS) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| /* Initialize next section */ |
| x = (uint32_t) (cur_api_section + 1); |
| |
| /* Check PnC range exists in DB */ |
| for (; x < TPM_MAX_NUM_API_SECTIONS; x++) { |
| if (tpm_db.api_section[x].valid == TPM_DB_VALID) { |
| /* Return Data */ |
| *api_rng_size = tpm_db.api_section[x].table_size; |
| *num_valid_entries = tpm_db.api_section[x].num_valid_entries; |
| *last_valid_entry = tpm_db.api_section[x].last_valid_entry; |
| *tbl_start = tpm_db.api_section[x].table_start; |
| *next_section = x; |
| return (TPM_DB_OK); |
| } |
| } |
| /* No valid entry found */ |
| *next_section = -1; |
| |
| return (TPM_DB_OK); |
| } |
| |
| #if 0 /* YUVAL_OK */ |
| void tpm_db_api_area_bubble_sort(tpm_db_api_check_t *array, uint8_t num_elements) |
| { |
| int32_t i, j; |
| tpm_db_api_check_t temp_var; |
| |
| if (num_elements <= 1) |
| return; |
| |
| for (i = 0; i < num_elements; i++) { |
| /* back through the area bringing smallest remaining element to position i */ |
| for (j = num_elements - 1; j > i; j--) { |
| if (array[j - 1].table_start > array[j].table_start) { |
| memcpy(&temp_var, &(array[j]), sizeof(tpm_db_api_check_t)); |
| memcpy(&(array[j]), &(array[j - 1]), sizeof(tpm_db_api_check_t)); |
| memcpy(&(array[j - 1]), &temp_var, sizeof(tpm_db_api_check_t)); |
| |
| } |
| } |
| } |
| |
| return; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_section_margins_check() |
| * |
| * DESCRIPTION: Get next valid API range |
| * |
| * INPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_rng_margins_self_check(void) |
| { |
| |
| tpm_api_sections_t cur_section = -1, next_section = 0; |
| int32_t last_valid; |
| int32_t ret_code, margin_area; |
| uint32_t margin_entry, api_rng_size = 0, num_valid_entries; |
| uint32_t tbl_start_ind = 0, table_size, margin_start_ind, area_num, num_ranges; |
| uint32_t i = 0, k = 0; |
| uint8_t *margin_p; |
| tpm_db_api_check_t api_sections_areas[TPM_MAX_NUM_API_SECTIONS]; |
| |
| /* Loop through valid API ranges read them into local array */ |
| ret_code = tpm_db_api_section_val_get_next(cur_section, &next_section, &api_rng_size, |
| &num_valid_entries, &last_valid, &tbl_start_ind); |
| IF_ERROR(ret_code); |
| |
| while (next_section != TPM_INVALID_SECTION) { |
| api_sections_areas[i].table_size = api_rng_size; |
| api_sections_areas[i].table_start = tbl_start_ind; |
| |
| cur_section = next_section; |
| i++; |
| |
| ret_code = tpm_db_api_section_val_get_next(cur_section, &next_section, &api_rng_size, |
| &num_valid_entries, &last_valid, &tbl_start_ind); |
| IF_ERROR(ret_code); |
| } |
| |
| num_ranges = i; |
| |
| /* Simple Ordering */ |
| tpm_db_api_area_bubble_sort(api_sections_areas, num_ranges); |
| if (1) { |
| printk("%s (%d)\n", __func__, __LINE__); |
| for (k = 0; k < num_ranges; k++) { |
| printk("entry(%d) table_start(%d) table_size(%d)\n", k, api_sections_areas[k].table_start, |
| api_sections_areas[k].table_size); |
| } |
| } |
| |
| /* Check margins */ |
| margin_start_ind = 0; |
| i = 0; |
| |
| for (area_num = 0; area_num < num_ranges; area_num++) { |
| tbl_start_ind = api_sections_areas[area_num].table_start; |
| table_size = api_sections_areas[area_num].table_size; |
| |
| margin_p = (uint8_t *) &(tpm_db.api_ent_mem_area[margin_start_ind]); |
| margin_area = (tbl_start_ind - margin_start_ind) * (sizeof(tpm_db_api_entry_t)); |
| i = 0; |
| |
| while (i < margin_area) { |
| if (*(margin_p + i) != MEM_MARGIN_PATTERN) { |
| /* Print complete tpm_db_api_entry_t from start to end, and also skips checking the rest of it */ |
| margin_entry = i / (sizeof(tpm_db_api_entry_t)); |
| |
| printk("margin entry(%d):\n", margin_entry); |
| for (i = margin_entry * sizeof(tpm_db_api_entry_t); |
| i < (margin_entry + 1) * sizeof(tpm_db_api_entry_t); i++) { |
| printk("%x ", *(margin_p + i)); |
| } |
| |
| /* i now points to start of next entry */ |
| } else { |
| i++; |
| } |
| } |
| margin_start_ind = tbl_start_ind + api_sections_areas[area_num].table_size; |
| } |
| |
| printk("===========================================\n"); |
| return (TPM_OK); |
| |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_api_section_entry_add() |
| * |
| * DESCRIPTION: Update Range params to add new entry |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * new_last_valid - Update the last valid entry with this value |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_section_entry_add(tpm_api_sections_t api_section, int32_t new_last_valid) |
| { |
| if (tpm_db.api_section[api_section].valid == TPM_DB_INVALID) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| (tpm_db.api_section[api_section].num_valid_entries)++; |
| tpm_db.api_section[api_section].last_valid_entry = new_last_valid; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_freeentry_get() |
| * |
| * DESCRIPTION: Get free API entry |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * OUTPUTS: |
| * ind - Return Free Index |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_freeentry_get(tpm_api_sections_t api_section, int32_t *index) |
| { |
| uint32_t i; |
| |
| /* Find Empty Index */ |
| for (i = 0; i < tpm_db.api_section[api_section].table_size; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_INVALID) |
| break; |
| } |
| if (i == tpm_db.api_section[api_section].table_size) { |
| *index = -1; |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| *index = i; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_ind_get() |
| * |
| * DESCRIPTION: Get Index (handle) of a rulenum |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rulenum - Rulenum of the API acl/table |
| * OUTPUTS: |
| * index - Return rule number's index |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_ind_get(tpm_api_sections_t api_section, uint32_t rule_num, int32_t *index) |
| { |
| int32_t i; |
| |
| /* Find the rulenum index */ |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID && API_ENT_I(api_section, i).rule_num == rule_num) |
| break; |
| } |
| |
| if (i > tpm_db.api_section[api_section].last_valid_index) { |
| *index = -1; |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| *index = i; |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_tcam_rule_idx_get() |
| * |
| * DESCRIPTION: Get PnC rule index by API section and TCAM number |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * tcam_num - TCAM number of the API acl/table |
| * OUTPUTS: |
| * rule_idx - Return rule index for PnC rule |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_tcam_rule_idx_get(tpm_api_sections_t api_section, uint32_t tcam_num, uint32_t *rule_idx) |
| { |
| int32_t i; |
| |
| /* Find the rule index */ |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| /* |
| printk("tpm_db_api_tcam_rule_idx_get index[%d], valid[%d], num_pnc_ranges[%d], pnc_index[%d] \n", |
| i, API_ENT_I(api_section, i).valid, API_ENT_I(api_section, i).pnc_tbl_conn.num_pnc_ranges, |
| API_ENT_I(api_section, i).pnc_tbl_conn.pnc_conn_tbl[0].pnc_index); |
| */ |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID |
| && API_ENT_I(api_section, i).pnc_tbl_conn.num_pnc_ranges > 0 |
| && API_ENT_I(api_section, i).pnc_tbl_conn.pnc_conn_tbl[0].pnc_index == tcam_num) |
| break; |
| } |
| |
| if (i > tpm_db.api_section[api_section].last_valid_index) { |
| *rule_idx = 0; |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| *rule_idx = API_ENT_I(api_section, i).rule_idx; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_set() |
| * |
| * DESCRIPTION: Set an API Entry |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_num - Rule number in the API range |
| * bi_dir - Is this rule Bi-directional |
| * api_data - The API key data for this entry |
| * mod_con - Definition of connection to modification tables |
| * pnc_con - Definition of connection to PNC tables |
| * OUTPUTS: |
| * rule_idx - Unique Rule Identifier, that does not change over the life span of the rule. |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_set(tpm_api_sections_t api_section, |
| uint32_t rule_num, |
| uint32_t bi_dir, |
| tpm_rule_entry_t *api_data, |
| tpm_db_mod_conn_t *mod_con, tpm_db_pnc_conn_t *pnc_con, uint32_t *rule_idx) |
| { |
| int32_t ind; |
| tpm_pnc_ranges_t range_id = 0; |
| tpm_db_pnc_range_conf_t rangConf; |
| int32_t ret_code; |
| uint32_t l_rule_idx; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d), - rule_num(%d)\n", api_section, rule_num); |
| |
| /* Find Empty Index */ |
| tpm_db_api_freeentry_get(api_section, &ind); |
| if (ind == -1) |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| |
| /* Get Range_Id, rang configuration, to get range type */ |
| ret_code = tpm_db_api_section_main_pnc_get(api_section, &range_id); |
| IF_ERROR(ret_code); |
| ret_code = tpm_db_pnc_rng_conf_get(range_id, &rangConf); |
| IF_ERROR(ret_code); |
| |
| /* Fill in API entry */ |
| memcpy(&(API_ENT_I(api_section, ind).api_rule_data), api_data, sizeof(tpm_rule_entry_t)); |
| if (mod_con) |
| memcpy(&(API_ENT_I(api_section, ind).mod_tbl_conn), mod_con, sizeof(tpm_db_mod_conn_t)); |
| |
| memcpy(&(API_ENT_I(api_section, ind).pnc_tbl_conn), pnc_con, sizeof(tpm_db_pnc_conn_t)); |
| |
| API_ENT_I(api_section, ind).bi_dir = bi_dir; |
| l_rule_idx = tpm_db_rule_index_get(); |
| if (TPM_RANGE_TYPE_ACL == rangConf.range_type) |
| API_ENT_I(api_section, ind).rule_idx = l_rule_idx; |
| else |
| API_ENT_I(api_section, ind).rule_idx = rule_num; |
| |
| API_ENT_I(api_section, ind).rule_num = rule_num; |
| API_ENT_I(api_section, ind).valid = TPM_DB_VALID; |
| |
| /* Increase highest tbl_index if needed */ |
| if (ind > tpm_db.api_section[api_section].last_valid_index) |
| tpm_db.api_section[api_section].last_valid_index = ind; |
| |
| |
| /* Set last_valid to rule_num if needed */ |
| if ((tpm_db.api_section[api_section].last_valid_entry < 0) |
| || ((int32_t) rule_num > tpm_db.api_section[api_section].last_valid_entry)) |
| tpm_db.api_section[api_section].last_valid_entry = (int32_t) rule_num; |
| |
| (tpm_db.api_section[api_section].num_valid_entries)++; |
| |
| if (TPM_RANGE_TYPE_ACL == rangConf.range_type) { |
| *rule_idx = l_rule_idx; |
| tpm_db_rule_index_incrs(); |
| } else |
| *rule_idx = rule_num; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_invalidate() |
| * |
| * DESCRIPTION: Invalidate an API Entry |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_num - Rule number in the API range |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_invalidate(tpm_api_sections_t api_section, uint32_t rule_num) |
| { |
| int32_t ind; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d), - rule_num(%d)\n", api_section, rule_num); |
| |
| /* Find rule_num Index */ |
| tpm_db_api_entry_ind_get(api_section, rule_num, &ind); |
| if (ind == -1) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " ind(%d), \n", ind); |
| |
| /* Invalidate the entry on the api_table */ |
| memset(&(API_ENT_I(api_section, ind)), 0, sizeof(tpm_db_api_entry_t)); |
| API_ENT_I(api_section, ind).valid = TPM_DB_INVALID; |
| |
| /* Decrease highest tbl_index if needed */ |
| if (ind == tpm_db.api_section[api_section].last_valid_index) |
| tpm_db.api_section[api_section].last_valid_index--; |
| |
| /* Decrease last_valid if needed */ |
| if ((int32_t) rule_num == tpm_db.api_section[api_section].last_valid_entry) |
| tpm_db.api_section[api_section].last_valid_entry--; |
| |
| /* Decrease the number of valid entries */ |
| (tpm_db.api_section[api_section].num_valid_entries)--; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " last_valid_entry(%d), num_valid_entries(%d), \n", |
| tpm_db.api_section[api_section].last_valid_entry, |
| tpm_db.api_section[api_section].num_valid_entries); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_rulenum_inc() |
| * |
| * DESCRIPTION: Increase rulenum of a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_inc_start - Start of Range of API entries to increase the rule_num |
| * rule_inc_end - End of Range of API entries to increase the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_rulenum_inc(tpm_api_sections_t api_section, uint32_t rule_inc_start, uint32_t rule_inc_end) |
| { |
| int32_t i; |
| int32_t ind, ret_code; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d) - range_inc_start(%d) range_inc_end(%d) \n", |
| api_section, rule_inc_start, rule_inc_end); |
| |
| if (rule_inc_end >= (tpm_db.api_section[api_section].table_size - 1)) { |
| TPM_OS_ERROR(TPM_DB_MOD, " for api_section(%d), - range_inc_end(%d) too large \n", |
| api_section, rule_inc_end); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Increase all entries */ |
| for (i = rule_inc_end; i >= (int32_t) (rule_inc_start); i--) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| (API_ENT_I(api_section, ind).rule_num)++; |
| } |
| |
| /* Increase last_valid rule_num, if necessary */ |
| if (tpm_db.api_section[api_section].last_valid_entry == (int32_t) rule_inc_end) |
| (tpm_db.api_section[api_section].last_valid_entry)++; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_rulenum_dec() |
| * |
| * DESCRIPTION: Decrease rulenum of a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_dec_start - Start of Range of API entries to decrease the rule_num |
| * rule_dec_end - End of Range of API entries to decrease the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_rulenum_dec(tpm_api_sections_t api_section, uint32_t rule_dec_start, uint32_t rule_dec_end) |
| { |
| |
| uint32_t i; |
| int32_t ind, ret_code; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d) - rule_dec_start(%d) rule_dec_end(%d) \n", |
| api_section, rule_dec_start, rule_dec_end); |
| |
| if (rule_dec_start == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "for api_section(%d) - rule_dec_start cannot be 0\n", api_section); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Decrease all entries */ |
| for (i = rule_dec_start; i <= rule_dec_end; i++) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| (API_ENT_I(api_section, ind).rule_num)--; |
| } |
| |
| /* Decrease last_valid, if it equaled last in range */ |
| if (tpm_db.api_section[api_section].last_valid_entry == (int32_t) rule_dec_end) |
| (tpm_db.api_section[api_section].last_valid_entry)--; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_specific_pnc_dec() |
| * |
| * DESCRIPTION: Decrease the connected PCN entry of a specific pnc range |
| * for a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * range_id - Pnc range id |
| * rule_inc_start - Start of Range of API entries to decrease the rule_num |
| * rule_inc_end - End of Range of API entries to decrease the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_specific_pnc_dec(tpm_api_sections_t api_section, |
| tpm_pnc_ranges_t range_id, uint32_t rule_inc_start, uint32_t rule_inc_end) |
| { |
| uint32_t i, j; |
| int32_t ret_code, ind; |
| tpm_db_pnc_conn_t *pnc_tbl_conn; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d), range(%d) - rule_inc_start(%d) rule_inc_end(%d) \n", |
| api_section, range_id, rule_inc_start, rule_inc_end); |
| |
| ret_code = tpm_db_pnc_rng_conf_get(range_id, &range_conf); |
| IF_ERROR(ret_code); |
| |
| /* Increase pnc_entries of all rule_nums in the range */ |
| for (i = rule_inc_start; i <= rule_inc_end; i++) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| if (API_ENT_I(api_section, ind).valid == TPM_DB_INVALID) |
| continue; |
| |
| pnc_tbl_conn = &(API_ENT_I(api_section, ind).pnc_tbl_conn); |
| |
| /* Loop over all then pnc_entries of this api_entry */ |
| for (j = 0; j < (pnc_tbl_conn->num_pnc_ranges); j++) { |
| |
| if (pnc_tbl_conn->pnc_conn_tbl[j].pnc_range == (uint32_t) range_id) |
| pnc_tbl_conn->pnc_conn_tbl[j].pnc_index--; |
| } |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_specific_pnc_inc() |
| * |
| * DESCRIPTION: Increase the connected PCN entry of a specific pnc range |
| * for a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * range_id - Pnc range id |
| * rule_inc_start - Start of Range of API entries to decrease the rule_num |
| * rule_inc_end - End of Range of API entries to decrease the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_specific_pnc_inc(tpm_api_sections_t api_section, |
| tpm_pnc_ranges_t range_id, uint32_t rule_inc_start, uint32_t rule_inc_end) |
| { |
| uint32_t i, j; |
| int32_t ret_code, ind; |
| tpm_db_pnc_conn_t *pnc_tbl_conn; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d), range(%d) - rule_inc_start(%d) rule_inc_end(%d) \n", |
| api_section, range_id, rule_inc_start, rule_inc_end); |
| |
| ret_code = tpm_db_pnc_rng_conf_get(range_id, &range_conf); |
| IF_ERROR(ret_code); |
| |
| /* Increase pnc_entries of all rule_nums in the range */ |
| for (i = rule_inc_start; i <= rule_inc_end; i++) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| |
| pnc_tbl_conn = &(API_ENT_I(api_section, ind).pnc_tbl_conn); |
| |
| /* Loop over all then pnc_entries of this api_entry */ |
| for (j = 0; j < (pnc_tbl_conn->num_pnc_ranges); j++) { |
| |
| if (pnc_tbl_conn->pnc_conn_tbl[j].pnc_range == (uint32_t) range_id) |
| pnc_tbl_conn->pnc_conn_tbl[j].pnc_index++; |
| } |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_conn_inc() |
| * |
| * DESCRIPTION: Increase the connected PCN entry for a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_inc_start - Start of Range of API entries to decrease the rule_num |
| * rule_inc_end - End of Range of API entries to decrease the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_conn_inc(tpm_api_sections_t api_section, uint32_t rule_inc_start, uint32_t rule_inc_end) |
| { |
| int32_t i; |
| uint32_t j; |
| int32_t ind, ret_code; |
| tpm_db_pnc_conn_t *pnc_tbl_conn; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d) - rule_inc_start(%d) rule_inc_end(%d) \n", |
| api_section, rule_inc_start, rule_inc_end); |
| |
| if (rule_inc_end >= (tpm_db.api_section[api_section].table_size - 1)) { |
| TPM_OS_ERROR(TPM_DB_MOD, " for api_section(%d)- range_inc_end(%d) too large \n", |
| api_section, rule_inc_end); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Increase pnc_entries of all rule_nums in the range */ |
| for (i = rule_inc_end; i >= (int32_t) (rule_inc_start); i--) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| pnc_tbl_conn = &(API_ENT_I(api_section, ind).pnc_tbl_conn); |
| |
| /* Loop over all then pnc_entries of this api_entry */ |
| for (j = 0; j < (pnc_tbl_conn->num_pnc_ranges); j++) { |
| /* INcrease only the entries of the PNC Ranges that are TYPE_ACL */ |
| ret_code = tpm_db_pnc_rng_conf_get(pnc_tbl_conn->pnc_conn_tbl[j].pnc_range, &range_conf); |
| IF_ERROR_I(ret_code, i); |
| if (range_conf.range_type == TPM_RANGE_TYPE_ACL) |
| pnc_tbl_conn->pnc_conn_tbl[j].pnc_index++; |
| } |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_conn_dec() |
| * |
| * DESCRIPTION: Decrease the connected PCN entry for a range of API entries |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_dec_start - Start of Range of API entries to decrease the rule_num |
| * rule_dec_end - End of Range of API entries to decrease the rule_num |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_conn_dec(tpm_api_sections_t api_section, uint32_t rule_dec_start, uint32_t rule_dec_end) |
| { |
| uint32_t i, j; |
| int32_t ind, ret_code; |
| tpm_db_pnc_conn_t *pnc_tbl_conn; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d) - rule_dec_start(%d) rule_dec_end(%d) \n", |
| api_section, rule_dec_start, rule_dec_end); |
| |
| if (rule_dec_start == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, " for api_section(%d) - rule_dec_start is zero \n", api_section); |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| /* Decrease pnc_entries of all rule_nums in the range */ |
| for (i = rule_dec_start; i <= rule_dec_end; i++) { |
| ret_code = tpm_db_api_entry_ind_get(api_section, i, &ind); |
| IF_ERROR_I(ret_code, i); |
| pnc_tbl_conn = &(API_ENT_I(api_section, ind).pnc_tbl_conn); |
| |
| /* Loop over all then pnc_entries of this api_entry */ |
| for (j = 0; j < (pnc_tbl_conn->num_pnc_ranges); j++) { |
| /* Decrease only the entries of the PNC Ranges that are TYPE_ACL */ |
| ret_code = tpm_db_pnc_rng_conf_get(pnc_tbl_conn->pnc_conn_tbl[j].pnc_range, &range_conf); |
| IF_ERROR_I(ret_code, i); |
| if (range_conf.range_type == TPM_RANGE_TYPE_ACL) |
| pnc_tbl_conn->pnc_conn_tbl[j].pnc_index--; |
| } |
| } |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_tcam_num_get() |
| * |
| * DESCRIPTION: Get API TCAM number according to API section and rule index |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_idx - Unique Rule Identifier, that does not change over the life span of the rule. |
| * |
| * OUTPUTS: |
| * tcam_num - PnC TCAM number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_tcam_num_get(tpm_api_sections_t api_section, uint32_t rule_idx, uint32_t *tcam_num) |
| { |
| int32_t ret_code; |
| uint32_t rule_num; |
| uint32_t dummy_idx; |
| uint32_t bi_dir; |
| tpm_rule_entry_t api_data; |
| tpm_db_mod_conn_t mod_con = { 0, 0 }; |
| tpm_db_pnc_conn_t pnc_con; |
| |
| /* Get rule number */ |
| ret_code = tpm_db_api_rulenum_get(api_section, rule_idx, &rule_num); |
| IF_ERROR(ret_code); |
| |
| /* Get API entry */ |
| ret_code = tpm_db_api_entry_get(api_section, rule_num, &dummy_idx, &bi_dir, &api_data, &mod_con, &pnc_con); |
| IF_ERROR(ret_code); |
| |
| /* Get TCAM number, always return the first TCAM number even there are multiple */ |
| /* TCAM entries to one rule index */ |
| *tcam_num = pnc_con.pnc_conn_tbl[0].pnc_index; |
| |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_api_entry_update_rule_idx(tpm_api_sections_t api_section, |
| uint32_t rule_idx_pre, |
| uint32_t rule_idx_new) |
| { |
| int32_t ind; |
| int32_t ret_code; |
| uint32_t rule_num = 0; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, " api_section(%d), - rule_num(%d)\n", api_section, rule_num); |
| |
| /* Get the rule_num */ |
| ret_code = tpm_db_api_rulenum_get(api_section, rule_idx_pre, &rule_num); |
| if (ret_code == TPM_DB_ERR_REC_NOT_EXIST) { |
| TPM_OS_ERROR(TPM_DB_MOD, " The rule non-exist!\n"); |
| return ERR_RULE_IDX_INVALID; |
| } |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "with rule_num(%d)\n", rule_num); |
| |
| tpm_db_api_entry_ind_get(api_section, rule_num, &ind); |
| if (ind == -1) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| /* update rule_index */ |
| API_ENT_I(api_section, ind).rule_idx = rule_idx_new; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_rulenum_get() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_idx - Unique Rule Identifier, that does not change over the life span of the rule. |
| * |
| * OUTPUTS: |
| * rule_num - The API entry number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_rulenum_get(tpm_api_sections_t api_section, uint32_t rule_idx, uint32_t *rule_num) |
| { |
| int32_t i; |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID && API_ENT_I(api_section, i).rule_idx == rule_idx) { |
| *rule_num = API_ENT_I(api_section, i).rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_rulenum_get_from_l2_key() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * parse_bm - fields to be parsed in the key. |
| * l2_key - structure of l2_key |
| * |
| * OUTPUTS: |
| * rule_num - The API entry number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_rulenum_get_from_l2_key(tpm_api_sections_t api_section, tpm_parse_fields_t parse_rule_bm, |
| tpm_l2_acl_key_t *l2_key, uint32_t *rule_num) |
| { |
| int32_t i, cmp_res; |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID) { |
| cmp_res = memcmp(&(API_ENT_I(api_section, i).api_rule_data.l2_prim_key.l2_key), |
| l2_key, sizeof(tpm_l2_acl_key_t)); |
| if (cmp_res == 0) { /* found entry */ |
| /* check the parse_bm */ |
| if (parse_rule_bm == API_ENT_I(api_section, i).api_rule_data.l2_prim_key.parse_rule_bm) { |
| *rule_num = API_ENT_I(api_section, i).rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| } |
| } |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_rulenum_get_from_l3_key() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * parse_bm - fields to be parsed in the key. |
| * l3_key - structure of l3_key |
| * |
| * OUTPUTS: |
| * rule_num - The API entry number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_rulenum_get_from_l3_key(tpm_api_sections_t api_section, tpm_parse_fields_t parse_rule_bm, |
| tpm_l3_type_key_t *l3_key, uint32_t *rule_num) |
| { |
| int32_t i, cmp_res; |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID) { |
| cmp_res = memcmp(&API_ENT_I(api_section, i).api_rule_data.l3_type_key.l3_key, |
| l3_key, sizeof(tpm_l3_type_key_t)); |
| if (cmp_res == 0) { /* found entry */ |
| /* check the parse_bm */ |
| if (parse_rule_bm == API_ENT_I(api_section, i).api_rule_data.l3_type_key.parse_rule_bm) { |
| *rule_num = API_ENT_I(api_section, i).rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| } |
| } |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_rulenum_get_from_ipv4_key() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * parse_bm - fields to be parsed in the key. |
| * ipv4_key - structure of ipv4_key |
| * |
| * OUTPUTS: |
| * rule_num - The API entry number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_rulenum_get_from_ipv4_key(tpm_api_sections_t api_section, tpm_parse_fields_t parse_rule_bm, |
| tpm_ipv4_acl_key_t *ipv4_key, uint32_t *rule_num) |
| { |
| int32_t i, cmp_res; |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID) { |
| cmp_res = memcmp(&API_ENT_I(api_section, i).api_rule_data.ipv4_key.ipv4_key, |
| ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| if (cmp_res == 0) { /* found entry */ |
| /* check the parse_bm */ |
| if (parse_rule_bm == API_ENT_I(api_section, i).api_rule_data.ipv4_key.parse_rule_bm) { |
| *rule_num = API_ENT_I(api_section, i).rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| } |
| } |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_rulenum_get_from_ipv6_key() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * parse_bm - fields to be parsed in the key. |
| * ipv6_key - structure of ipv6_key |
| * |
| * OUTPUTS: |
| * rule_num - The API entry number |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_rulenum_get_from_ipv6_key(tpm_api_sections_t api_section, tpm_parse_fields_t parse_rule_bm, |
| tpm_ipv6_acl_key_t *ipv6_key, uint32_t *rule_num) |
| { |
| int32_t i, cmp_res; |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (API_ENT_I(api_section, i).valid == TPM_DB_VALID) { |
| cmp_res = memcmp(&API_ENT_I(api_section, i).api_rule_data.ipv6_key.ipv6_key, |
| ipv6_key, sizeof(tpm_ipv6_acl_key_t)); |
| if (cmp_res == 0) { /* found entry */ |
| /* check the parse_bm */ |
| if (parse_rule_bm == API_ENT_I(api_section, i).api_rule_data.ipv6_key.parse_rule_bm) { |
| *rule_num = API_ENT_I(api_section, i).rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| } |
| } |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_get() |
| * |
| * DESCRIPTION: Get API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * rule_num - The API entry number |
| * |
| * OUTPUTS: |
| * rule_idx - Unique Rule Identifier, that does not change over the life span of the rule. |
| * bi_dir - Is this rule bi-directional (currently not used) |
| * api_data - All config information received for this API call |
| * mod_con - Connection to modification tables |
| * pnc_con - Connection to PNC |
| * |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_get(tpm_api_sections_t api_section, |
| uint32_t rule_num, |
| uint32_t *rule_idx, |
| uint32_t *bi_dir, |
| tpm_rule_entry_t *api_data, tpm_db_mod_conn_t *mod_con, tpm_db_pnc_conn_t *pnc_con) |
| { |
| int32_t ind; |
| |
| tpm_db_api_entry_ind_get(api_section, rule_num, &ind); |
| if (ind == -1) |
| return (TPM_DB_ERR_REC_NOT_EXIST); |
| |
| memcpy(api_data, &(API_ENT_I(api_section, ind).api_rule_data), sizeof(tpm_rule_entry_t)); |
| memcpy(mod_con, &(API_ENT_I(api_section, ind).mod_tbl_conn), sizeof(tpm_db_mod_conn_t)); |
| memcpy(pnc_con, &(API_ENT_I(api_section, ind).pnc_tbl_conn), sizeof(tpm_db_pnc_conn_t)); |
| *bi_dir = API_ENT_I(api_section, ind).bi_dir; |
| *rule_idx = API_ENT_I(api_section, ind).rule_idx; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_api_entry_valid_get_next() |
| * |
| * DESCRIPTION: Get Next API Entry Data |
| * |
| * INPUTS: |
| * api_section - Section of the API acl/table |
| * cur_rule - The current rule_num in the API Range. |
| * Function returns the next valid rule number next_rule > cur_rule |
| * |
| * OUTPUTS: |
| * next_rule - See cur_rule. If end of table was reached before valid entry, (-1) is returned in next_rule |
| * All of the following outputs relate to rule_num=next_rule. |
| * rule_idx - See tpm_db_api_entry_get |
| * bi_dir - See tpm_db_api_entry_get |
| * api_data - See tpm_db_api_entry_get |
| * mod_con - See tpm_db_api_entry_get |
| * pnc_con - See tpm_db_api_entry_get |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_api_entry_val_get_next(tpm_api_sections_t api_section, |
| int32_t cur_rule, |
| int32_t *next_rule, |
| uint32_t *rule_idx, |
| uint32_t *bi_dir, |
| tpm_rule_entry_t *api_data, |
| tpm_db_mod_conn_t *mod_con, tpm_db_pnc_conn_t *pnc_con) |
| { |
| int32_t ind = -1; |
| int32_t i; |
| uint32_t min_rule, l_next_rule = ~0; |
| tpm_db_api_entry_t *api_tbl = &(API_ENT_I(api_section, 0)); |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "api_section(%d) cur_rule(%d)\n", api_section, cur_rule); */ |
| |
| if (cur_rule <= -1) |
| min_rule = 0; |
| else |
| min_rule = cur_rule + 1; |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "min_rule(%d) \n", min_rule); */ |
| |
| for (i = 0; i <= tpm_db.api_section[api_section].last_valid_index; i++) { |
| if (((api_tbl + i)->valid == TPM_DB_VALID) && |
| ((api_tbl + i)->rule_num >= min_rule) && ((api_tbl + i)->rule_num < l_next_rule)) { |
| l_next_rule = (api_tbl + i)->rule_num; |
| ind = i; |
| } |
| } |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "l_next_rule(%d) ind(%d) \n", l_next_rule, ind); */ |
| |
| if ((l_next_rule < (uint32_t) (~0)) && (ind != -1)) { |
| memcpy(api_data, &(API_ENT_I(api_section, ind).api_rule_data), sizeof(tpm_rule_entry_t)); |
| memcpy(mod_con, &(API_ENT_I(api_section, ind).mod_tbl_conn), sizeof(tpm_db_mod_conn_t)); |
| memcpy(pnc_con, &(API_ENT_I(api_section, ind).pnc_tbl_conn), sizeof(tpm_db_pnc_conn_t)); |
| *bi_dir = API_ENT_I(api_section, ind).bi_dir; |
| *rule_idx = API_ENT_I(api_section, ind).rule_idx; |
| |
| *next_rule = l_next_rule; |
| } else /* Not found */ |
| *next_rule = -1; |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "next_rule(%d) \n", *next_rule); */ |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_shdw_ent_set() |
| * |
| * DESCRIPTION: Set PNC Entry in Shadow Table |
| * |
| * INPUTS: |
| * pnc_entry - PnC Entry |
| * |
| * OUTPUTS: |
| * pnc_data - PnC Data |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_shdw_ent_set(uint32_t pnc_entry, tpm_pnc_all_t *pnc_data) |
| { |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "pnc_entry(%d)\n", pnc_entry); |
| if (pnc_entry >= TPM_PNC_SIZE) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.pnc_shadow[pnc_entry].valid = TPM_DB_VALID; |
| memcpy(&(tpm_db.pnc_shadow[pnc_entry].pnc_data), pnc_data, sizeof(tpm_pnc_all_t)); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_shdw_ent_inv() |
| * |
| * DESCRIPTION: Invalidate PNC Entry in Shadow Table |
| * |
| * INPUTS: |
| * pnc_entry - PnC Entry |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_shdw_ent_inv(uint32_t pnc_entry) |
| { |
| if (pnc_entry >= TPM_PNC_SIZE) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memset(&(tpm_db.pnc_shadow[pnc_entry].pnc_data), 0, sizeof(tpm_pnc_all_t)); |
| tpm_db.pnc_shadow[pnc_entry].valid = TPM_DB_INVALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_shdw_ent_get() |
| * |
| * DESCRIPTION: Get PNC Entry from Shadow Table |
| * |
| * INPUTS: |
| * pnc_entry - PnC Entry |
| * |
| * OUTPUTS: |
| * valid - Is the PNC Entry valid in Shadow |
| * pnc_data - PnC Data |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_shdw_ent_get(uint32_t pnc_entry, uint32_t *valid, tpm_pnc_all_t *pnc_data) |
| { |
| if (pnc_entry >= TPM_PNC_SIZE) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memcpy(pnc_data, &(tpm_db.pnc_shadow[pnc_entry].pnc_data), sizeof(tpm_pnc_all_t)); |
| if (tpm_db.pnc_shadow[pnc_entry].valid == TPM_DB_VALID) |
| *valid = TPM_TRUE; |
| else |
| *valid = TPM_FALSE; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mod_shdw_par_check() |
| * |
| * DESCRIPTION: Function checks legality of modification table params |
| * |
| * INPUTS: |
| * gmac - GMAC In |
| * entry - modification entry |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mod_shdw_par_check(tpm_gmacs_enum_t gmac, uint32_t mod_entry) |
| { |
| if ((mod_entry >= TPM_MOD_TABL_SIZE) |
| || /*(gmac < TPM_ENUM_GMAC_0) || */ (gmac >= TPM_MAX_NUM_GMACS)) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_shdw_ent_del() |
| * |
| * DESCRIPTION: Function deletes a PNC entry and "pushes up" the PNC Range |
| * |
| * INPUTS: |
| * pnc_start_entry - |
| * pnc_stop_entry - |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_shdw_ent_del(uint32_t pnc_start_entry, uint32_t pnc_stop_entry) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "pnc_start_entry(%d) pnc_stop_entry(%d)\n", pnc_start_entry, pnc_stop_entry); |
| |
| if ((pnc_start_entry >= TPM_PNC_SIZE) || (pnc_stop_entry >= TPM_PNC_SIZE)) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| /* Push up the existing range, except for the first one that is deleted */ |
| for (i = pnc_start_entry; i < pnc_stop_entry; i++) |
| memcpy(&(tpm_db.pnc_shadow[i]), &(tpm_db.pnc_shadow[i + 1]), sizeof(tpm_db_pnc_shadow_t)); |
| |
| /* Set last entry in range to invalid */ |
| memset(&(tpm_db.pnc_shadow[pnc_stop_entry].pnc_data), 0, sizeof(tpm_pnc_all_t)); |
| tpm_db.pnc_shadow[pnc_stop_entry].valid = TPM_DB_INVALID; |
| |
| return (TPM_DB_OK); |
| |
| } |
| |
| /******************************************************************************* |
| * tpm_db_pnc_shdw_ent_ins() |
| * |
| * DESCRIPTION: Function inserts an empty entry into a PNC Range ("pushes down the range") |
| * |
| * INPUTS: |
| * pnc_start_entry - |
| * pnc_stop_entry - |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_pnc_shdw_ent_ins(uint32_t pnc_start_entry, uint32_t pnc_stop_entry) |
| { |
| int32_t i; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "pnc_start_entry(%d) pnc_stop_entry(%d)\n", pnc_start_entry, pnc_stop_entry); |
| |
| if ((pnc_start_entry >= (TPM_PNC_SIZE - 1)) || (pnc_stop_entry >= (TPM_PNC_SIZE - 1))) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| /* Push down the existing range */ |
| for (i = (int32_t) pnc_stop_entry; i >= (int32_t) pnc_start_entry; i--) |
| memcpy(&(tpm_db.pnc_shadow[i + 1]), &(tpm_db.pnc_shadow[i]), sizeof(tpm_db_pnc_shadow_t)); |
| |
| /* Set empty (invalid) entry */ |
| memset(&(tpm_db.pnc_shadow[pnc_start_entry].pnc_data), 0, sizeof(tpm_pnc_all_t)); |
| tpm_db.pnc_shadow[pnc_start_entry].valid = TPM_DB_INVALID; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mod_etype_sel_get() |
| * |
| * DESCRIPTION: Get select of Vlan Ethertype |
| * |
| * INPUTS: |
| * tpid - Requested Vlan tpid |
| * |
| * |
| * OUTPUTS: |
| * etype_sel - selector that matches this tpid |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mod_etype_sel_get(uint32_t tpid, uint32_t *etype_sel) |
| { |
| uint32_t i; |
| |
| if (etype_sel == NULL) { |
| TPM_OS_DEBUG(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| for (i = 0; i < TPM_NUM_VLAN_ETYPE_REGS; i++) { |
| if (tpm_db.vlan_etype[i].tpid_ether_type == tpid && tpm_db.vlan_etype[i].valid == TPM_DB_VALID) { |
| *etype_sel = i; |
| return (TPM_DB_OK); |
| } |
| } |
| return (TPM_DB_ERR_REC_EXIST); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mod_etype_sel_free_get() |
| * |
| * DESCRIPTION: Get an unused tpid selector |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * etype_sel - selector |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mod_etype_sel_free_get(uint32_t *etype_sel) |
| { |
| uint32_t i; |
| |
| if (etype_sel == NULL) { |
| TPM_OS_DEBUG(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| for (i = 0; i < TPM_NUM_VLAN_ETYPE_REGS; i++) { |
| if (tpm_db.vlan_etype[i].valid == TPM_DB_INVALID) { |
| *etype_sel = i; |
| return (TPM_DB_OK); |
| } |
| } |
| |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mod_etype_sel_set() |
| * |
| * DESCRIPTION: Set a tpid in a selector |
| * |
| * INPUTS: |
| * tpid - Requested Vlan tpid |
| * etype_sel - selector that matches this tpid |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mod_etype_sel_set(uint32_t tpid, uint32_t etype_sel) |
| { |
| if (etype_sel >= TPM_NUM_VLAN_ETYPE_REGS) { |
| TPM_OS_DEBUG(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| tpm_db.vlan_etype[etype_sel].valid = TPM_DB_VALID; |
| tpm_db.vlan_etype[etype_sel].tpid_ether_type = tpid; |
| |
| return (TPM_DB_OK); |
| } |
| |
| void tpm_db_set_mc_filter_mode(uint32_t mode) |
| { |
| tpm_db.igmp_def.filter_mode = mode; |
| } |
| |
| uint32_t tpm_db_get_mc_filter_mode(void) |
| { |
| return tpm_db.igmp_def.filter_mode; |
| } |
| |
| void tpm_db_set_mc_pppoe_enable(uint32_t enable) |
| { |
| tpm_db.igmp_def.mc_pppoe_enable = enable; |
| } |
| |
| uint8_t tpm_db_get_mc_pppoe_enable(void) |
| { |
| return tpm_db.igmp_def.mc_pppoe_enable; |
| } |
| void tpm_db_split_mod_set_enable(tpm_db_split_mod_enable_t enable) |
| { |
| tpm_db.split_mod_conf.split_mod_enable = enable; |
| } |
| |
| tpm_db_split_mod_enable_t tpm_db_split_mod_get_enable(void) |
| { |
| return tpm_db.split_mod_conf.split_mod_enable; |
| } |
| |
| void tpm_db_split_mod_set_num_vlans(uint32_t num_vlans) |
| { |
| /* as default, vlan 0 is added during Init */ |
| tpm_db.split_mod_conf.num_vlans = (num_vlans + TPM_DB_SPLIT_MOD_INIT_VLANS_NUM); |
| } |
| |
| uint32_t tpm_db_split_mod_get_num_vlans(void) |
| { |
| return tpm_db.split_mod_conf.num_vlans; |
| } |
| void tpm_db_split_mod_set_mode(tpm_db_split_mod_mode_t mode) |
| { |
| tpm_db.split_mod_conf.split_mod_mode = mode; |
| } |
| |
| tpm_db_split_mod_mode_t tpm_db_split_mod_get_mode(void) |
| { |
| return tpm_db.split_mod_conf.split_mod_mode; |
| } |
| void tpm_db_split_mod_set_num_p_bits(uint32_t num_p_bits, uint8_t p_bits[TPM_DB_SPLIT_MOD_P_BIT_NUM_MAX]) |
| { |
| tpm_db.split_mod_conf.num_p_bits = num_p_bits; |
| memcpy(&(tpm_db.split_mod_conf.p_bits), p_bits, TPM_DB_SPLIT_MOD_P_BIT_NUM_MAX); |
| } |
| |
| uint32_t tpm_db_split_mod_get_num_p_bits(void) |
| { |
| return tpm_db.split_mod_conf.num_p_bits; |
| } |
| int32_t tpm_db_split_mod_get_p_bits_by_index(uint8_t index, uint8_t *p_bits) |
| { |
| if (p_bits == NULL) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| *p_bits = index; |
| return TPM_DB_OK; |
| } |
| int32_t tpm_db_split_mod_get_index_by_p_bits(uint8_t p_bits, uint32_t *index) |
| { |
| uint32_t i; |
| for(i = 0; i < tpm_db.split_mod_conf.num_p_bits; i++) |
| if (p_bits == tpm_db.split_mod_conf.p_bits[i]) { |
| *index = p_bits; |
| return TPM_DB_OK; |
| } |
| |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| #if 0 |
| void tpm_db_set_mc_igmp_mode(uint32_t mode) |
| { |
| tpm_db.igmp_def.igmp_mode = mode; |
| } |
| |
| uint32_t tpm_db_get_mc_igmp_mode(void) |
| { |
| return tpm_db.igmp_def.igmp_mode; |
| } |
| #endif |
| void tpm_db_set_mc_per_uni_vlan_xlate(uint32_t enable) |
| { |
| tpm_db.igmp_def.per_uni_vlan_xlat = enable; |
| } |
| |
| uint8_t tpm_db_get_mc_per_uni_vlan_xlate(void) |
| { |
| return tpm_db.igmp_def.per_uni_vlan_xlat; |
| } |
| |
| void tpm_db_set_mc_hwf_queue(uint8_t hwf_queue) |
| { |
| tpm_db.igmp_def.mc_hwf_queue = hwf_queue; |
| } |
| |
| uint8_t tpm_db_get_mc_hwf_queue(void) |
| { |
| return tpm_db.igmp_def.mc_hwf_queue; |
| } |
| |
| void tpm_db_set_mc_cpu_queue(uint8_t cpu_queue) |
| { |
| tpm_db.igmp_def.mc_cpu_queue = cpu_queue; |
| } |
| |
| uint8_t tpm_db_get_mc_cpu_queue(void) |
| { |
| return tpm_db.igmp_def.mc_cpu_queue; |
| } |
| |
| void tpm_db_set_mc_igmp_proxy_sa_mac(uint8_t *sa_mac) |
| { |
| memcpy(tpm_db_mc_igmp_proxy_sa_mac, sa_mac, 6 * sizeof(uint8_t)); |
| tpm_db_mc_igmp_proxy_sa_mac_valid = 1; |
| } |
| |
| void tpm_db_get_mc_igmp_proxy_sa_mac(uint8_t *sa_mac, uint8_t *valid) |
| { |
| *valid = tpm_db_mc_igmp_proxy_sa_mac_valid; |
| if (tpm_db_mc_igmp_proxy_sa_mac_valid) |
| memcpy(sa_mac, tpm_db_mc_igmp_proxy_sa_mac, 6 * sizeof(uint8_t)); |
| } |
| |
| void tpm_db_set_mc_lpbk_enable(tpm_ip_ver_t ver, uint8_t enable) |
| { |
| if (ver < TPM_IP_VER_MAX) |
| tpm_db.igmp_def.mc_lpbk_enable[ver] = enable; |
| } |
| |
| void tpm_db_get_mc_lpbk_enable(tpm_ip_ver_t ver, uint8_t *enable) |
| { |
| if (ver < TPM_IP_VER_MAX) |
| *enable = tpm_db.igmp_def.mc_lpbk_enable[ver]; |
| } |
| |
| int32_t tpm_db_set_mc_stream_entry(uint32_t stream_num, tpm_db_mc_stream_entry_t *mc_stream) |
| { |
| if (tpm_db_mc_stream_table[stream_num] == NULL) { |
| tpm_db_mc_stream_table[stream_num] = |
| /*(tpm_db_mc_stream_entry_t *)*/ kmalloc(sizeof(tpm_db_mc_stream_entry_t), GFP_KERNEL); |
| if (tpm_db_mc_stream_table[stream_num] == NULL) |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| |
| memcpy(tpm_db_mc_stream_table[stream_num], mc_stream, sizeof(tpm_db_mc_stream_entry_t)); |
| } else { |
| if (tpm_db_mc_stream_table[stream_num]->igmp_mode == mc_stream->igmp_mode && |
| tpm_db_mc_stream_table[stream_num]->mc_stream_pppoe == mc_stream->mc_stream_pppoe && |
| tpm_db_mc_stream_table[stream_num]->vid == mc_stream->vid && |
| tpm_db_mc_stream_table[stream_num]->src_valid == mc_stream->src_valid && |
| !memcmp(tpm_db_mc_stream_table[stream_num]->src_addr, mc_stream->src_addr, 4 * sizeof(uint8_t)) && |
| !memcmp(tpm_db_mc_stream_table[stream_num]->group_addr, mc_stream->group_addr, 4 * sizeof(uint8_t))) { |
| tpm_db_mc_stream_table[stream_num]->dest_port_bm = mc_stream->dest_port_bm; |
| tpm_db_mc_stream_table[stream_num]->u4_entry = mc_stream->u4_entry; |
| } else |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_mc_stream_entry(uint32_t stream_num, tpm_db_mc_stream_entry_t *mc_stream) |
| { |
| if (tpm_db_mc_stream_table[stream_num] == NULL) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| memcpy(mc_stream, tpm_db_mc_stream_table[stream_num], sizeof(tpm_db_mc_stream_entry_t)); |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_reset_mc_stream_entry(uint32_t stream_num) |
| { |
| if (tpm_db_mc_stream_table[stream_num] != NULL) { |
| kfree(tpm_db_mc_stream_table[stream_num]); |
| tpm_db_mc_stream_table[stream_num] = NULL; |
| } |
| } |
| |
| int32_t tpm_db_set_ipv6_mc_stream_entry(uint32_t stream_num, tpm_db_ipv6_mc_stream_entry_t *mc_stream) |
| { |
| if (0 == tpm_db.ipv6_mc_stream[stream_num].valid) { |
| memcpy(&(tpm_db.ipv6_mc_stream[stream_num]), mc_stream, sizeof(tpm_db_ipv6_mc_stream_entry_t)); |
| tpm_db.ipv6_mc_stream[stream_num].valid = 1; |
| } else { |
| if (tpm_db.ipv6_mc_stream[stream_num].igmp_mode == mc_stream->igmp_mode && |
| tpm_db.ipv6_mc_stream[stream_num].mc_stream_pppoe == mc_stream->mc_stream_pppoe && |
| tpm_db.ipv6_mc_stream[stream_num].vid == mc_stream->vid && |
| !memcmp(tpm_db.ipv6_mc_stream[stream_num].group_addr, mc_stream->group_addr, 16 * sizeof(uint8_t))) { |
| tpm_db.ipv6_mc_stream[stream_num].dest_port_bm = mc_stream->dest_port_bm; |
| tpm_db.ipv6_mc_stream[stream_num].u4_entry = mc_stream->u4_entry; |
| } else |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv6_mc_stream_entry(uint32_t stream_num, tpm_db_ipv6_mc_stream_entry_t *mc_stream) |
| { |
| if (0 == tpm_db.ipv6_mc_stream[stream_num].valid) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| memcpy(mc_stream, &(tpm_db.ipv6_mc_stream[stream_num]), sizeof(tpm_db_ipv6_mc_stream_entry_t)); |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_reset_ipv6_mc_stream_entry(uint32_t stream_num) |
| { |
| memset(&(tpm_db.ipv6_mc_stream[stream_num]), 0, sizeof(tpm_db_ipv6_mc_stream_entry_t)); |
| } |
| |
| int32_t tpm_db_get_mc_mac_port_bm(uint8_t *mac_addr, uint32_t *uni_port_bm) |
| { |
| uint32_t entry_id; |
| uint32_t port_nr; |
| |
| *uni_port_bm = 0; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MAC_NUM; entry_id++) { |
| if (tpm_db_mc_mac_table[entry_id] != NULL) |
| if (!memcmp(tpm_db_mc_mac_table[entry_id]->mac_addr, mac_addr, 6 * sizeof(uint8_t))) |
| break; |
| } |
| |
| if (entry_id == TPM_MC_MAX_MAC_NUM) { |
| /* no entry for this MAC */ |
| *uni_port_bm = 0; |
| return TPM_DB_OK; |
| } |
| |
| for (port_nr = TPM_SRC_PORT_UNI_0; port_nr <= TPM_SRC_PORT_UNI_VIRT; port_nr++) |
| if (tpm_db_mc_mac_table[entry_id]->user_num[port_nr]) |
| *uni_port_bm |= (TPM_TRG_UNI_0 << port_nr); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_increase_mc_mac_port_user_num(uint8_t *mac_addr, uint32_t uni_port) |
| { |
| uint32_t entry_id, first_free = TPM_MC_MAX_MAC_NUM; |
| uint32_t port_nr; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MAC_NUM; entry_id++) { |
| if (tpm_db_mc_mac_table[entry_id] != NULL) { |
| if (!memcmp(tpm_db_mc_mac_table[entry_id]->mac_addr, mac_addr, 6 * sizeof(uint8_t))) |
| break; |
| } else if (first_free == TPM_MC_MAX_MAC_NUM) |
| first_free = entry_id; |
| } |
| |
| if (entry_id == TPM_MC_MAX_MAC_NUM) { |
| if (first_free == TPM_MC_MAX_MAC_NUM) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| tpm_db_mc_mac_table[first_free] = |
| /*(tpm_db_mc_mac_entry_t *)*/ kmalloc(sizeof(tpm_db_mc_mac_entry_t), GFP_KERNEL); |
| if (tpm_db_mc_mac_table[first_free] == NULL) |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| |
| memset(tpm_db_mc_mac_table[first_free], 0, sizeof(tpm_db_mc_mac_entry_t)); |
| memcpy(tpm_db_mc_mac_table[first_free]->mac_addr, mac_addr, 6 * sizeof(uint8_t)); |
| entry_id = first_free; |
| } |
| |
| switch (uni_port) { |
| case TPM_TRG_UNI_0: port_nr = TPM_SRC_PORT_UNI_0; break; |
| case TPM_TRG_UNI_1: port_nr = TPM_SRC_PORT_UNI_1; break; |
| case TPM_TRG_UNI_2: port_nr = TPM_SRC_PORT_UNI_2; break; |
| case TPM_TRG_UNI_3: port_nr = TPM_SRC_PORT_UNI_3; break; |
| case TPM_TRG_UNI_4: port_nr = TPM_SRC_PORT_UNI_4; break; |
| case TPM_TRG_UNI_5: port_nr = TPM_SRC_PORT_UNI_5; break; |
| case TPM_TRG_UNI_6: port_nr = TPM_SRC_PORT_UNI_6; break; |
| case TPM_TRG_UNI_7: port_nr = TPM_SRC_PORT_UNI_7; break; |
| case TPM_TRG_UNI_VIRT: port_nr = TPM_SRC_PORT_UNI_VIRT;break; |
| default: |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| tpm_db_mc_mac_table[entry_id]->user_num[port_nr] += 1; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_decrease_mc_mac_port_user_num(uint8_t *mac_addr, uint32_t uni_port) |
| { |
| uint32_t entry_id; |
| uint32_t port_nr; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MAC_NUM; entry_id++) { |
| if (tpm_db_mc_mac_table[entry_id] != NULL) { |
| if (!memcmp(tpm_db_mc_mac_table[entry_id]->mac_addr, mac_addr, 6 * sizeof(uint8_t))) |
| break; |
| } |
| } |
| |
| if (entry_id == TPM_MC_MAX_MAC_NUM) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| switch (uni_port) { |
| case TPM_TRG_UNI_0: port_nr = TPM_SRC_PORT_UNI_0; break; |
| case TPM_TRG_UNI_1: port_nr = TPM_SRC_PORT_UNI_1; break; |
| case TPM_TRG_UNI_2: port_nr = TPM_SRC_PORT_UNI_2; break; |
| case TPM_TRG_UNI_3: port_nr = TPM_SRC_PORT_UNI_3; break; |
| case TPM_TRG_UNI_4: port_nr = TPM_SRC_PORT_UNI_4; break; |
| case TPM_TRG_UNI_5: port_nr = TPM_SRC_PORT_UNI_5; break; |
| case TPM_TRG_UNI_6: port_nr = TPM_SRC_PORT_UNI_6; break; |
| case TPM_TRG_UNI_7: port_nr = TPM_SRC_PORT_UNI_7; break; |
| case TPM_TRG_UNI_VIRT: port_nr = TPM_SRC_PORT_UNI_VIRT;break; |
| default: |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| tpm_db_mc_mac_table[entry_id]->user_num[port_nr] -= 1; |
| |
| return TPM_DB_OK; |
| } |
| |
| uint8_t tpm_db_get_mc_mac_port_user_num(uint8_t *mac_addr, uint32_t uni_port) |
| { |
| uint32_t entry_id; |
| uint32_t port_nr; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MAC_NUM; entry_id++) { |
| if (tpm_db_mc_mac_table[entry_id] != NULL) { |
| if (!memcmp(tpm_db_mc_mac_table[entry_id]->mac_addr, mac_addr, 6 * sizeof(uint8_t))) |
| break; |
| } |
| } |
| |
| if (entry_id == TPM_MC_MAX_MAC_NUM) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| switch (uni_port) { |
| case TPM_TRG_UNI_0: port_nr = TPM_SRC_PORT_UNI_0; break; |
| case TPM_TRG_UNI_1: port_nr = TPM_SRC_PORT_UNI_1; break; |
| case TPM_TRG_UNI_2: port_nr = TPM_SRC_PORT_UNI_2; break; |
| case TPM_TRG_UNI_3: port_nr = TPM_SRC_PORT_UNI_3; break; |
| case TPM_TRG_UNI_4: port_nr = TPM_SRC_PORT_UNI_4; break; |
| case TPM_TRG_UNI_5: port_nr = TPM_SRC_PORT_UNI_5; break; |
| case TPM_TRG_UNI_6: port_nr = TPM_SRC_PORT_UNI_6; break; |
| case TPM_TRG_UNI_7: port_nr = TPM_SRC_PORT_UNI_7; break; |
| case TPM_TRG_UNI_VIRT: port_nr = TPM_SRC_PORT_UNI_VIRT;break; |
| default: |
| return 0; |
| } |
| |
| if (TRG_UNI(uni_port)) { |
| if (port_nr < TPM_MAX_NUM_UNI_PORTS) |
| return tpm_db_mc_mac_table[entry_id]->user_num[port_nr]; |
| } |
| |
| return 0; |
| } |
| |
| void tpm_db_reset_mc_mac_entry(uint8_t *mac_addr) |
| { |
| uint32_t entry_id; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MAC_NUM; entry_id++) { |
| if (tpm_db_mc_mac_table[entry_id] != NULL) { |
| if (!memcmp(tpm_db_mc_mac_table[entry_id]->mac_addr, mac_addr, 6 * sizeof(uint8_t))) { |
| kfree(tpm_db_mc_mac_table[entry_id]); |
| tpm_db_mc_mac_table[entry_id] = NULL; |
| return; |
| } |
| } |
| } |
| } |
| |
| uint32_t tpm_db_mc_lpbk_entries_num_get(void) |
| { |
| return tpm_db_mc_lpbk_entries_num; |
| } |
| |
| int32_t tpm_db_mc_lpbk_entry_set(uint32_t ip_ver, uint16_t mvlan, uint16_t in_vid, uint16_t out_vid, uint32_t rule_num, |
| uint32_t mod_entry) |
| { |
| static uint32_t _rule_index = 1000; |
| uint32_t entry_id, first_free = TPM_MC_MAX_MVLAN_XITS_NUM; |
| tpm_db_mc_lpbk_entry_t *lpbk_entry = NULL; |
| tpm_db_mc_vlan_entry_t *mvlan_entry = NULL; |
| |
| if (rule_num >= TPM_MC_MAX_LPBK_ENTRIES_NUM) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| if (rule_num > tpm_db_mc_lpbk_entries_num) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MVLAN_XITS_NUM; entry_id++) { |
| if (tpm_db_mc_vlan_xits_table[entry_id] != NULL) { |
| if (mvlan == tpm_db_mc_vlan_xits_table[entry_id]->mvlan && |
| ip_ver == tpm_db_mc_vlan_xits_table[entry_id]->ip_ver) { |
| mvlan_entry = tpm_db_mc_vlan_xits_table[entry_id]; |
| break; |
| } |
| } else if (first_free == TPM_MC_MAX_MVLAN_XITS_NUM) |
| first_free = entry_id; |
| } |
| |
| if (entry_id == TPM_MC_MAX_MVLAN_XITS_NUM) { |
| if (first_free == TPM_MC_MAX_MVLAN_XITS_NUM) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| mvlan_entry = /*(tpm_db_mc_vlan_entry_t *)*/ kmalloc(sizeof(tpm_db_mc_vlan_entry_t), GFP_KERNEL); |
| if (mvlan_entry == NULL) |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| |
| memset(mvlan_entry, 0, sizeof(tpm_db_mc_vlan_entry_t)); |
| mvlan_entry->mvlan = mvlan; |
| mvlan_entry->ip_ver = ip_ver; |
| |
| tpm_db_mc_vlan_xits_table[first_free] = mvlan_entry; |
| } |
| |
| first_free = TPM_DB_MAX_TRANSITION_NUM; |
| |
| for (entry_id = 0; entry_id < TPM_DB_MAX_TRANSITION_NUM; entry_id++) { |
| if (mvlan_entry->xits[entry_id].valid == 0) { |
| first_free = entry_id; |
| break; |
| } |
| } |
| |
| if (first_free == TPM_DB_MAX_TRANSITION_NUM) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| lpbk_entry = /*(tpm_db_mc_lpbk_entry_t *)*/ kmalloc(sizeof(tpm_db_mc_lpbk_entry_t), GFP_KERNEL); |
| if (lpbk_entry == NULL) |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| |
| memset(lpbk_entry, 0, sizeof(tpm_db_mc_lpbk_entry_t)); |
| |
| mvlan_entry->xits[first_free].valid = 1; |
| mvlan_entry->xits[first_free].in_vid = in_vid; |
| mvlan_entry->xits[first_free].out_vid = out_vid; |
| mvlan_entry->xits[first_free].lpbk_entry = lpbk_entry; |
| mvlan_entry->xits_num++; |
| |
| _rule_index++; |
| |
| lpbk_entry->rule_index = _rule_index; |
| lpbk_entry->mod_cmd = mod_entry; |
| |
| for (entry_id = tpm_db_mc_lpbk_entries_num; entry_id > rule_num; entry_id--) |
| tpm_db_mc_lpbk_table[entry_id] = tpm_db_mc_lpbk_table[entry_id - 1]; |
| |
| tpm_db_mc_lpbk_table[rule_num] = lpbk_entry; |
| tpm_db_mc_lpbk_entries_num++; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mc_vlan_xits_num_get(uint32_t ip_ver, uint16_t mvlan, uint32_t *xits_num) |
| { |
| uint32_t entry_id; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MVLAN_XITS_NUM; entry_id++) { |
| if (tpm_db_mc_vlan_xits_table[entry_id] != NULL) { |
| if (tpm_db_mc_vlan_xits_table[entry_id]->mvlan == mvlan && |
| tpm_db_mc_vlan_xits_table[entry_id]->ip_ver == ip_ver) { |
| *xits_num = tpm_db_mc_vlan_xits_table[entry_id]->xits_num; |
| return TPM_DB_OK; |
| } |
| } |
| } |
| |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| int32_t tpm_db_mc_vlan_xit_entry_get(uint32_t ip_ver, uint16_t mvlan, uint32_t xit_id, uint32_t *rule_index, uint32_t *mod_entry) |
| { |
| uint32_t entry_id, xit_cnt = 0; |
| uint8_t found; |
| tpm_db_mc_vlan_entry_t *mvlan_entry = NULL; |
| tpm_db_mc_lpbk_entry_t *lpbk_entry = NULL; |
| |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MVLAN_XITS_NUM; entry_id++) { |
| if (tpm_db_mc_vlan_xits_table[entry_id] != NULL) { |
| if (tpm_db_mc_vlan_xits_table[entry_id]->mvlan == mvlan && |
| tpm_db_mc_vlan_xits_table[entry_id]->ip_ver == ip_ver) { |
| mvlan_entry = tpm_db_mc_vlan_xits_table[entry_id]; |
| break; |
| } |
| } |
| } |
| |
| if (mvlan_entry == NULL) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| found = 0; |
| for (entry_id = 0; entry_id < TPM_DB_MAX_TRANSITION_NUM; entry_id++) { |
| if (xit_cnt == xit_id) { |
| found = 1; |
| break; |
| } |
| xit_cnt++; |
| } |
| |
| if (found == 0) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| lpbk_entry = mvlan_entry->xits[entry_id].lpbk_entry; |
| |
| *rule_index = lpbk_entry->rule_index; |
| *mod_entry = lpbk_entry->mod_cmd; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mc_lpbk_rule_num_get(uint32_t rule_index, uint32_t *rule_num) |
| { |
| uint32_t entry_id; |
| |
| for (entry_id = 0; entry_id < tpm_db_mc_lpbk_entries_num; entry_id++) { |
| if (tpm_db_mc_lpbk_table[entry_id] != NULL) { |
| if (tpm_db_mc_lpbk_table[entry_id]->rule_index == rule_index) { |
| *rule_num = entry_id; |
| return TPM_DB_OK; |
| } |
| } |
| } |
| |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| int32_t tpm_db_mc_lpbk_entry_invalidate(uint32_t rule_num) |
| { |
| uint32_t entry_id, xit_id; |
| uint8_t found; |
| tpm_db_mc_lpbk_entry_t *lpbk_entry = NULL; |
| tpm_db_mc_vlan_entry_t *mvlan_entry = NULL; |
| |
| if (rule_num > tpm_db_mc_lpbk_entries_num) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| lpbk_entry = tpm_db_mc_lpbk_table[rule_num]; |
| |
| for (entry_id = rule_num; entry_id < (tpm_db_mc_lpbk_entries_num - 1); entry_id++) |
| tpm_db_mc_lpbk_table[entry_id] = tpm_db_mc_lpbk_table[entry_id + 1]; |
| |
| kfree(lpbk_entry); |
| tpm_db_mc_lpbk_table[tpm_db_mc_lpbk_entries_num - 1] = NULL; |
| tpm_db_mc_lpbk_entries_num--; |
| |
| found = 0; |
| for (entry_id = 0; entry_id < TPM_MC_MAX_MVLAN_XITS_NUM; entry_id++) { |
| mvlan_entry = tpm_db_mc_vlan_xits_table[entry_id]; |
| if (mvlan_entry != NULL) { |
| if (mvlan_entry->xits_num > 0) { |
| for (xit_id = 0; xit_id < TPM_DB_MAX_TRANSITION_NUM; xit_id++) { |
| if (mvlan_entry->xits[xit_id].valid) { |
| if (lpbk_entry == mvlan_entry->xits[xit_id].lpbk_entry) { |
| mvlan_entry->xits[xit_id].valid = 0; |
| found = 1; |
| break; |
| } |
| } |
| } |
| |
| if (found) { |
| mvlan_entry->xits_num--; |
| if (mvlan_entry->xits_num == 0) { |
| kfree(mvlan_entry); |
| tpm_db_mc_vlan_xits_table[entry_id] = NULL; |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mc_alloc_virt_uni_entry(uint32_t *entry_id) |
| { |
| uint32_t free; |
| |
| for (free = 0; free < TPM_MC_MAX_STREAM_NUM; free++) { |
| if (tpm_db_mc_virt_uni_entry_state_table[free] == 0) { |
| tpm_db_mc_virt_uni_entry_state_table[free] = 1; |
| *entry_id = free; |
| return TPM_DB_OK; |
| } |
| } |
| |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| |
| int32_t tpm_db_mc_free_virt_uni_entry(uint32_t entry_id) |
| { |
| if (entry_id >= TPM_MC_MAX_STREAM_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| tpm_db_mc_virt_uni_entry_state_table[entry_id] = 0; |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_mc_rule_reset(void) |
| { |
| uint32_t i; |
| |
| /* Reset multicast stream table */ |
| for (i = 0; i < TPM_MC_MAX_STREAM_NUM; i++) { |
| if (tpm_db_mc_stream_table[i] != NULL) { |
| kfree(tpm_db_mc_stream_table[i]); |
| tpm_db_mc_stream_table[i] = NULL; |
| } |
| } |
| |
| /* Reset multicast mac table */ |
| for (i = 0; i < TPM_MC_MAX_MAC_NUM; i++) { |
| if (tpm_db_mc_mac_table[i] != NULL) { |
| kfree(tpm_db_mc_mac_table[i]); |
| tpm_db_mc_mac_table[i] = NULL; |
| } |
| } |
| |
| /* Reset multicast loopback tables */ |
| tpm_db_mc_lpbk_entries_num = 0; |
| for (i = 0; i < TPM_MC_MAX_LPBK_ENTRIES_NUM; i++) { |
| if (tpm_db_mc_lpbk_table[i] != NULL) { |
| kfree(tpm_db_mc_lpbk_table[i]); |
| tpm_db_mc_lpbk_table[i] = NULL; |
| } |
| } |
| |
| for (i = 0; i < TPM_MC_MAX_MVLAN_XITS_NUM; i++) { |
| if (tpm_db_mc_vlan_xits_table[i] != NULL) { |
| kfree(tpm_db_mc_vlan_xits_table[i]); |
| tpm_db_mc_vlan_xits_table[i] = NULL; |
| } |
| } |
| |
| /* Reset state table of virt_uni entries */ |
| memset(tpm_db_mc_virt_uni_entry_state_table, 0, TPM_MC_MAX_STREAM_NUM * sizeof(uint8_t)); |
| |
| /* reset IPv6 MC rule */ |
| memset(tpm_db.ipv6_mc_stream, 0, sizeof(tpm_db.ipv6_mc_stream)); |
| |
| } |
| int32_t tpm_db_mc_vlan_get_ai_bit_by_vid(uint32_t mc_vlan, uint32_t *ai_bit) |
| { |
| uint32_t i; |
| int32_t ret_val; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vlan(%d) \n", mc_vlan); |
| |
| /* first, get ai bits if mc vlan already exists */ |
| ret_val = tpm_db_mc_vlan_get_ai_bit(mc_vlan, ai_bit); |
| if (TPM_DB_OK == ret_val) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc vlan already exists, ai bits(%d)\n", *ai_bit); |
| return TPM_DB_OK; |
| } |
| |
| /* alloc a new ai bits */ |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if (!tpm_db.mc_ai_bits_table[i].valid) { |
| tpm_db.mc_ai_bits_table[i].valid = true; |
| tpm_db.mc_ai_bits_table[i].mc_vlan = mc_vlan; |
| tpm_db.mc_ai_bits_table[i].pnc_index_num = 0; |
| memset(tpm_db.mc_ai_bits_table[i].pnc_index, 0xff, |
| sizeof(tpm_db.mc_ai_bits_table[i].pnc_index)); |
| *ai_bit = i; |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " alloc a new ai bits(%d)\n", i); |
| return TPM_DB_OK; |
| } |
| } |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| bool tpm_db_mc_vlan_l2_rule_exist(uint32_t mc_vlan, uint32_t rule_num) |
| { |
| uint32_t loop_in; |
| uint32_t i; |
| uint32_t ret_code; |
| tpm_pnc_ranges_t range_id = 0; |
| tpm_db_pnc_range_conf_t rangConf; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vlan(%d), rule_num(%d) \n", mc_vlan, rule_num); |
| |
| /* Get Range_Id */ |
| tpm_db_api_section_main_pnc_get(TPM_L2_PRIM_ACL, &range_id); |
| |
| /* Get Range Conf */ |
| ret_code = tpm_db_pnc_rng_conf_get(range_id, &rangConf); |
| if (TPM_OK != ret_code) { |
| TPM_OS_ERROR(TPM_DB_MOD, " recvd ret_code(%d)\n", ret_code); |
| return false; |
| } |
| |
| if (TPM_RANGE_TYPE_TABLE != rangConf.range_type) { |
| /* not TABLE mode */ |
| return false; |
| } |
| |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((mc_vlan == tpm_db.mc_ai_bits_table[i].mc_vlan) && (tpm_db.mc_ai_bits_table[i].valid)) { |
| for (loop_in = 0; loop_in < TPM_MC_VLAN_MAX_PNC_RULE_NUM; loop_in++) { |
| if (rule_num == tpm_db.mc_ai_bits_table[i].pnc_index[loop_in]) |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| int32_t tpm_db_mc_vlan_set_ai_bit_pnc_index(uint32_t mc_vlan, uint32_t l2_pnc_rule_index) |
| { |
| uint32_t i; |
| uint32_t loop_in; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vlan(%d) l2_pnc_rule_index(%d)\n", mc_vlan, l2_pnc_rule_index); |
| |
| /* in table mode, and rule_num already exist, do not record again */ |
| if (tpm_db_mc_vlan_l2_rule_exist(mc_vlan, l2_pnc_rule_index)) |
| return TPM_DB_OK; |
| |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((mc_vlan == tpm_db.mc_ai_bits_table[i].mc_vlan) && (tpm_db.mc_ai_bits_table[i].valid)) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " ai_index(%d)\n", i); |
| for (loop_in = 0; loop_in < TPM_MC_VLAN_MAX_PNC_RULE_NUM; loop_in++) { |
| if (~0 == tpm_db.mc_ai_bits_table[i].pnc_index[loop_in]) { |
| tpm_db.mc_ai_bits_table[i].pnc_index[loop_in] = l2_pnc_rule_index; |
| tpm_db.mc_ai_bits_table[i].pnc_index_num++; |
| return TPM_DB_OK; |
| } |
| } |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| } |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| int32_t tpm_db_mc_vlan_get_pnc_index_free_slot(uint32_t mc_vlan, uint32_t rule_num) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vlan(%d) \n", mc_vlan); |
| |
| /* in table mode, and rule_num already exist, always has free slot */ |
| if (tpm_db_mc_vlan_l2_rule_exist(mc_vlan, rule_num)) |
| return 1; |
| |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((mc_vlan == tpm_db.mc_ai_bits_table[i].mc_vlan) && (tpm_db.mc_ai_bits_table[i].valid)) { |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " ai_index(%d), pnc_index_num(%d)\n", |
| i, tpm_db.mc_ai_bits_table[i].pnc_index_num); |
| /* ACL mode */ |
| if (TPM_MC_VLAN_MAX_PNC_RULE_NUM <= tpm_db.mc_ai_bits_table[i].pnc_index_num) |
| return 0; |
| return (TPM_MC_VLAN_MAX_PNC_RULE_NUM - tpm_db.mc_ai_bits_table[i].pnc_index_num); |
| } |
| } |
| return TPM_MC_VLAN_MAX_PNC_RULE_NUM; |
| } |
| |
| int32_t tpm_db_mc_vlan_reset_ai_bit(uint32_t l2_pnc_rule_index) |
| { |
| uint32_t i; |
| uint32_t loop_in; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "l2_pnc_rule_index(%d)\n", l2_pnc_rule_index); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if (!tpm_db.mc_ai_bits_table[i].valid) |
| continue; |
| |
| for (loop_in = 0; loop_in < TPM_MC_VLAN_MAX_PNC_RULE_NUM; loop_in++) { |
| if (l2_pnc_rule_index == tpm_db.mc_ai_bits_table[i].pnc_index[loop_in]) { |
| tpm_db.mc_ai_bits_table[i].pnc_index_num--; |
| tpm_db.mc_ai_bits_table[i].pnc_index[loop_in] = ~0; |
| |
| if (0 == tpm_db.mc_ai_bits_table[i].pnc_index_num) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " remove this mc vlan(%d), ai_bits(%d)\n", |
| tpm_db.mc_ai_bits_table[i].mc_vlan, i); |
| tpm_db.mc_ai_bits_table[i].valid = false; |
| tpm_db.mc_ai_bits_table[i].mc_vlan = 0; |
| memset(tpm_db.mc_ai_bits_table[i].pnc_index, 0xff, |
| sizeof(tpm_db.mc_ai_bits_table[i].pnc_index)); |
| } else { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, |
| " decrease pnc_index_num of this mc vlan(%d), pnc_index_num(%d)\n", |
| tpm_db.mc_ai_bits_table[i].mc_vlan, |
| tpm_db.mc_ai_bits_table[i].pnc_index_num); |
| } |
| |
| return TPM_DB_OK; |
| } |
| } |
| continue; |
| } |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| int32_t tpm_db_mc_vlan_reset_mc_vlan(uint32_t mc_vlan) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vlan); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((tpm_db.mc_ai_bits_table[i].valid) && (mc_vlan == tpm_db.mc_ai_bits_table[i].mc_vlan)) { |
| if (0 == tpm_db.mc_ai_bits_table[i].pnc_index_num) { |
| tpm_db.mc_ai_bits_table[i].valid = false; |
| tpm_db.mc_ai_bits_table[i].mc_vlan = 0; |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " reset this vlan(%d)\n", mc_vlan); |
| } |
| return TPM_DB_OK; |
| } |
| } |
| return (TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| int32_t tpm_db_mc_vlan_get_ai_bit(uint32_t mc_vlan, uint32_t *ai_bit) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vlan); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if (mc_vlan == tpm_db.mc_ai_bits_table[i].mc_vlan) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " ai_index(%d)\n", i); |
| *ai_bit = i; |
| return TPM_DB_OK; |
| } |
| } |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| int32_t tpm_db_set_mc_vid_cfg(uint32_t mc_vid, tpm_mc_vid_port_vid_set_t *mc_vid_uniports_config) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vid); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if (false == tpm_db.mc_vid_port_cfg[i].valid) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vid_index(%d)\n", i); |
| tpm_db.mc_vid_port_cfg[i].valid = true; |
| tpm_db.mc_vid_port_cfg[i].mc_vid = mc_vid; |
| memcpy(&tpm_db.mc_vid_port_cfg[i].mc_vid_port_vids, mc_vid_uniports_config, |
| sizeof(tpm_mc_vid_port_vid_set_t)); |
| return TPM_DB_OK; |
| } |
| } |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| int32_t tpm_db_get_mc_vid_cfg(uint32_t mc_vid, tpm_mc_vid_port_cfg_t **mc_vid_uniports_config) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vid); |
| |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((true == tpm_db.mc_vid_port_cfg[i].valid) && (mc_vid == tpm_db.mc_vid_port_cfg[i].mc_vid)) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vid_index(%d)\n", i); |
| *mc_vid_uniports_config = &(tpm_db.mc_vid_port_cfg[i].mc_vid_port_vids[0]); |
| return TPM_DB_OK; |
| } |
| } |
| |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| |
| bool tpm_db_mc_vid_exist(uint32_t mc_vid) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vid); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((true == tpm_db.mc_vid_port_cfg[i].valid) && (mc_vid == tpm_db.mc_vid_port_cfg[i].mc_vid)) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vid_index(%d)\n", i); |
| return true; |
| } |
| } |
| return (false); |
| } |
| |
| uint32_t tpm_db_remove_mc_vid_cfg(uint32_t mc_vid) |
| { |
| uint32_t i; |
| |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, "mc_vlan(%d)\n", mc_vid); |
| for (i = 0; i < TPM_MC_VID_NUM_MAX; i++) { |
| if ((true == tpm_db.mc_vid_port_cfg[i].valid) && (mc_vid == tpm_db.mc_vid_port_cfg[i].mc_vid)) { |
| TPM_OS_DEBUG(TPM_TPM_LOG_MOD, " mc_vid_index(%d)\n", i); |
| tpm_db.mc_vid_port_cfg[i].valid = false; |
| tpm_db.mc_vid_port_cfg[i].mc_vid = 0; |
| return TPM_DB_OK; |
| } |
| } |
| return (TPM_DB_ERR_INV_INPUT); |
| } |
| /******************************************************************************* |
| * tpm_db_mc_cfg_reset() |
| * |
| * DESCRIPTION: Reset MC configuration part in DB. Set all structures to 0, |
| * and all valid fields to false |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| void tpm_db_mc_cfg_reset(void) |
| { |
| memset(&tpm_db.mc_ai_bits_table, 0, sizeof(tpm_db.mc_ai_bits_table)); |
| memset(&tpm_db.mc_vid_port_cfg, 0, sizeof(tpm_db.mc_vid_port_cfg)); |
| |
| tpm_db_mc_igmp_proxy_sa_mac_valid = 0; |
| memset(tpm_db_mc_igmp_proxy_sa_mac, 0, 6 * sizeof(uint8_t)); |
| |
| return; |
| } |
| |
| void tpm_db_mod2_init_jump_area_cfg(void) |
| { |
| tpm_db_mod2_jump_area_cfg.base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.total_num = 0; |
| tpm_db_mod2_jump_area_cfg.split_num = 0; |
| |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_PMAC] = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_GMAC_0] = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_GMAC_1] = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_PMAC] = TPM_MOD2_NULL_ENT_IDX; |
| |
| tpm_db_mod2_jump_area_cfg.split_pbit_num = 0; |
| } |
| |
| void tpm_db_mod2_init_chain_cfg(void) |
| { |
| tpm_mod2_multicast_mh_enable = 1; |
| tpm_mod2_pppoe_add_mod_enable = 1; |
| tpm_mod2_double_tag_enable = 1; |
| tpm_mod2_udp_checksum_use_init_bm_enable = 0; |
| tpm_mod2_udp_checksum_enable = 1; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].subr_chain = 1; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].max_size = TPM_MOD2_MAX_MH_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].subr_chain = 1; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].max_size = TPM_MOD2_MAX_MAC_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].subr_chain = 1; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].max_size = TPM_MOD2_MAX_VLAN_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].subr_chain = 1; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].max_size = TPM_MOD2_MAX_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].subr_chain = 1; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].max_size = TPM_MOD2_MAX_IPV6_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].subr_chain = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].max_size = TPM_MOD2_MAX_L2_TWO_TAG_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].subr_chain = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].max_size = TPM_MOD2_MAX_IPV4_NAPT_W_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].subr_chain = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].max_size = TPM_MOD2_MAX_IPV4_MC_W_MH_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].subr_chain = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].max_size = TPM_MOD2_MAX_ROUTE_W_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].base_entry = TPM_MOD2_NULL_ENT_IDX; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].subr_chain = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].max_size = TPM_MOD2_MAX_IPV6_MC_W_MH_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].next_free[TPM_ENUM_GMAC_0] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].next_free[TPM_ENUM_GMAC_1] = TPM_MOD2_INVALID_CHAIN_ID; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].next_free[TPM_ENUM_PMAC] = TPM_MOD2_INVALID_CHAIN_ID; |
| |
| } |
| |
| void tpm_db_mod2_init_pmt_info(void) |
| { |
| tpm_mod2_chain_area_base = TPM_MOD2_NULL_ENT_IDX; |
| tpm_mod2_total_chain_num = 0; |
| |
| memset(tpm_db_mod2_jump_pmt_info, 0, TPM_MAX_NUM_GMACS * sizeof(tpm_mod2_jump_pmt_info_t *)); |
| memset(tpm_db_mod2_chain_pmt_info, 0, TPM_MAX_NUM_GMACS * sizeof(tpm_mod2_jump_pmt_info_t *)); |
| } |
| |
| void tpm_db_mod2_init_chain_info(void) |
| { |
| memset(tpm_db_mod2_jump_booked_entry_bm, 0, TPM_MAX_NUM_GMACS * sizeof(uint32_t *)); |
| memset(tpm_db_mod2_jump_occupied_entry_bm, 0, TPM_MAX_NUM_GMACS * sizeof(uint32_t *)); |
| |
| tpm_db_mod2_jump_bm_group = 0; |
| |
| memset(tpm_db_mod2_chain_booked_entry_bm, 0, TPM_MAX_NUM_GMACS * TPM_CHAIN_TYPE_MAX * sizeof(uint32_t *)); |
| memset(tpm_db_mod2_chain_occupied_entry_bm, 0, TPM_MAX_NUM_GMACS * TPM_CHAIN_TYPE_MAX * sizeof(uint32_t *)); |
| |
| memset(tpm_db_mod2_chain_bm_group, 0, TPM_CHAIN_TYPE_MAX * sizeof(uint32_t)); |
| |
| memset(tpm_db_mod2_chain_info, 0, TPM_MAX_NUM_GMACS * TPM_CHAIN_TYPE_MAX * sizeof(tpm_mod2_chain_info_t *)); |
| } |
| |
| void tpm_db_mod2_set_chain_num(tpm_chain_type_t chain_type, uint16_t chain_num) |
| { |
| if (chain_type < TPM_CHAIN_TYPE_MAX && chain_type != TPM_CHAIN_TYPE_NONE) |
| tpm_db_mod2_chain_cfg[chain_type].total_num = chain_num; |
| } |
| |
| uint16_t tpm_db_mod2_get_chain_max_size(tpm_chain_type_t chain_type) |
| { |
| if (chain_type < TPM_CHAIN_TYPE_MAX && chain_type != TPM_CHAIN_TYPE_NONE) |
| return tpm_db_mod2_chain_cfg[chain_type].max_size; |
| |
| return 0; |
| } |
| |
| void tpm_db_mod2_set_multicast_mh_state(uint8_t enable) |
| { |
| if (enable) { |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].max_size = TPM_MOD2_MAX_IPV4_MC_W_MH_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].max_size = TPM_MOD2_MAX_IPV6_MC_W_MH_CHAIN_SIZE; |
| } else { |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].max_size = TPM_MOD2_MAX_IPV4_MC_WO_MH_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].max_size = TPM_MOD2_MAX_IPV6_MC_WO_MH_CHAIN_SIZE; |
| } |
| |
| tpm_mod2_multicast_mh_enable = enable; |
| } |
| |
| uint8_t tpm_db_mod2_get_multicast_mh_state(void) |
| { |
| return tpm_mod2_multicast_mh_enable; |
| } |
| |
| void tpm_db_mod2_set_pppoe_add_mod_state(uint8_t enable) |
| { |
| if (enable) { |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].max_size = TPM_MOD2_MAX_IPV4_NAPT_W_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].max_size = TPM_MOD2_MAX_ROUTE_W_PPPOE_CHAIN_SIZE; |
| } else { |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].max_size = TPM_MOD2_MAX_IPV4_NAPT_WO_PPPOE_CHAIN_SIZE; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].max_size = TPM_MOD2_MAX_ROUTE_WO_PPPOE_CHAIN_SIZE; |
| } |
| |
| tpm_mod2_pppoe_add_mod_enable = enable; |
| } |
| |
| uint8_t tpm_db_mod2_get_pppoe_add_mod_state(void) |
| { |
| return tpm_mod2_pppoe_add_mod_enable; |
| } |
| |
| void tpm_db_mod2_set_double_tag_state(uint8_t enable) |
| { |
| if (enable) |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].max_size = TPM_MOD2_MAX_L2_TWO_TAG_CHAIN_SIZE; |
| else |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].max_size = TPM_MOD2_MAX_L2_ONE_TAG_CHAIN_SIZE; |
| |
| tpm_mod2_double_tag_enable = enable; |
| } |
| |
| uint8_t tpm_db_mod2_get_double_tag_state(void) |
| { |
| return tpm_mod2_double_tag_enable; |
| } |
| |
| void tpm_db_mod2_set_udp_checksum_use_init_bm_state(uint8_t enable) |
| { |
| tpm_mod2_udp_checksum_use_init_bm_enable = enable; |
| } |
| |
| uint8_t tpm_db_mod2_get_udp_checksum_init_bm_state(void) |
| { |
| return tpm_mod2_udp_checksum_use_init_bm_enable; |
| } |
| |
| void tpm_db_mod2_set_udp_checksum_state(uint8_t enable) |
| { |
| tpm_mod2_udp_checksum_enable = enable; |
| } |
| |
| uint8_t tpm_db_mod2_get_udp_checksum_state(void) |
| { |
| return tpm_mod2_udp_checksum_enable; |
| } |
| |
| int32_t tpm_db_mod2_set_jump_entry(tpm_gmacs_enum_t gmac_port, uint16_t entry_id, tpm_mod2_entry_t *pattern) |
| { |
| tpm_mod2_jump_pmt_info_t *info_p = NULL; |
| |
| if (pattern == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (entry_id >= tpm_db_mod2_jump_area_cfg.total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| info_p = &tpm_db_mod2_jump_pmt_info[gmac_port][entry_id]; |
| |
| if (info_p->status != TPM_MOD_ENTRY_BOOKED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| memcpy(&(info_p->pattern), pattern, sizeof(tpm_mod2_entry_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_activate_jump_entry(tpm_gmacs_enum_t gmac_port, uint16_t entry_id) |
| { |
| tpm_mod2_jump_pmt_info_t *info_p = NULL; |
| uint32_t i, j, mask; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (entry_id >= tpm_db_mod2_jump_area_cfg.total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| info_p = &tpm_db_mod2_jump_pmt_info[gmac_port][entry_id]; |
| |
| if (info_p->status != TPM_MOD_ENTRY_BOOKED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| /* TODO: Check if the entry is split mod entry */ |
| |
| i = j = 0; |
| j = entry_id & 0x1f; |
| i = entry_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_jump_booked_entry_bm[gmac_port][i] &= ~mask; |
| |
| if (tpm_db_mod2_jump_split_mod_all_entry_bm[gmac_port][i] & mask) { |
| /* this is a split mod entry */ |
| info_p->status = TPM_MOD_ENTRY_SPLIT_MOD; |
| tpm_db_mod2_jump_split_mod_occupied_entry_bm[gmac_port][i] |= mask; |
| } |
| else { |
| info_p->status = TPM_MOD_ENTRY_OCCUPIED; |
| tpm_db_mod2_jump_occupied_entry_bm[gmac_port][i] |= mask; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_get_jump_entry_pattern_data(tpm_gmacs_enum_t gmac_port, uint16_t entry_id, |
| tpm_mod2_entry_t *pattern) |
| { |
| tpm_mod2_jump_pmt_info_t *info_p = NULL; |
| |
| if (pattern == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (entry_id >= tpm_db_mod2_jump_area_cfg.total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| info_p = &tpm_db_mod2_jump_pmt_info[gmac_port][entry_id]; |
| |
| if ( (info_p->status != TPM_MOD_ENTRY_OCCUPIED) |
| && (info_p->status != TPM_MOD_ENTRY_SPLIT_MOD)) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| memcpy(pattern, &(info_p->pattern), sizeof(tpm_mod2_entry_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_del_jump_entry(tpm_gmacs_enum_t gmac_port, uint16_t entry_id) |
| { |
| tpm_mod2_jump_pmt_info_t *info_p = NULL; |
| uint32_t i, j, mask; |
| /*uint16_t jump_to; */ |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (entry_id >= tpm_db_mod2_jump_area_cfg.total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| info_p = &tpm_db_mod2_jump_pmt_info[gmac_port][entry_id]; |
| |
| if ( info_p->status != TPM_MOD_ENTRY_OCCUPIED |
| && info_p->status != TPM_MOD_ENTRY_SPLIT_MOD) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| /* delete jump entry in db */ |
| memset(info_p, 0, sizeof(tpm_mod2_jump_pmt_info_t)); |
| |
| /* TODO: Check if the entry is split mod entry */ |
| |
| info_p->status = TPM_MOD_ENTRY_FREE; |
| |
| i = j = 0; |
| j = entry_id & 0x1f; |
| i = entry_id >> 5; |
| mask = 1 << j; |
| |
| if (tpm_db_mod2_jump_split_mod_all_entry_bm[gmac_port][i] & mask) { |
| /* this is a split mod pmt entry */ |
| tpm_db_mod2_jump_split_mod_occupied_entry_bm[gmac_port][i] &= ~mask; |
| } |
| else { |
| tpm_db_mod2_jump_occupied_entry_bm[gmac_port][i] &= ~mask; |
| } |
| |
| tpm_db_mod2_flush_jump_area(gmac_port, entry_id, 1, 0); |
| |
| return TPM_DB_OK; |
| } |
| |
| uint16_t tpm_db_mod2_find_matched_chain(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t total_num, |
| tpm_mod2_chain_info_t *chains, tpm_mod2_chain_pmt_info_t *pmt_data, |
| uint16_t entry_num, tpm_mod2_entry_t *pattern) |
| { |
| uint16_t chain_id, entry_id; |
| uint32_t bm_idx, data; |
| uint32_t *booked_bm = NULL, *occupied_bm = NULL; |
| tpm_mod2_chain_pmt_info_t *pmt_ptr = NULL; |
| |
| booked_bm = tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type]; |
| occupied_bm = tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type]; |
| |
| for (bm_idx = 0; bm_idx < tpm_db_mod2_chain_bm_group[chain_type]; bm_idx++) { |
| data = (booked_bm[bm_idx] | occupied_bm[bm_idx]); |
| if (data) { |
| chain_id = bm_idx << 5; /* multiply 32 */ |
| while (data) { |
| if (data & 0x1) { |
| if (entry_num == chains[chain_id].entry_num) { |
| pmt_ptr = &pmt_data[chains[chain_id].base_entry]; |
| for (entry_id = 0; entry_id < entry_num; entry_id++) { |
| if (memcmp |
| (&(pmt_ptr[entry_id].pattern), &pattern[entry_id], |
| sizeof(tpm_mod2_entry_t))) { |
| break; |
| } |
| } |
| |
| if (entry_id == entry_num) |
| return chain_id; |
| } |
| } |
| chain_id++; |
| data = data >> 1; |
| } |
| } |
| } |
| |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| } |
| |
| void tpm_db_mod2_increase_chain_user(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num++; |
| } |
| |
| void tpm_db_mod2_decrease_chain_user(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num != 0) |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num--; |
| } |
| |
| uint16_t tpm_db_mod2_chain_user_num(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| return tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num; |
| } |
| |
| uint16_t tpm_db_mod2_get_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t entry_num, |
| tpm_mod2_entry_t *pattern) |
| { |
| if (pattern == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (tpm_db_mod2_chain_pmt_info[gmac_port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid pmt data\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| return tpm_db_mod2_find_matched_chain(gmac_port, chain_type, |
| tpm_db_mod2_chain_cfg[chain_type].total_num, |
| tpm_db_mod2_chain_info[gmac_port][chain_type], |
| tpm_db_mod2_chain_pmt_info[gmac_port], entry_num, pattern); |
| } |
| |
| int32_t tpm_db_mod2_set_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id, |
| uint16_t entry_num, tpm_mod2_entry_t *pattern) |
| { |
| uint16_t /*match_chain, */ base_offset, entry_idx; |
| tpm_mod2_chain_info_t *info_p; |
| tpm_mod2_chain_pmt_info_t *pmt_array; |
| |
| if (pattern == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| if (info_p->status == TPM_MOD_ENTRY_OCCUPIED) { |
| tpm_db_mod2_increase_chain_user(gmac_port, chain_type, chain_id); |
| } else if (info_p->status == TPM_MOD_ENTRY_BOOKED) { |
| if (tpm_db_mod2_chain_user_num(gmac_port, chain_type, chain_id) == 0) { |
| base_offset = tpm_db_mod2_chain_cfg[chain_type].base_entry - tpm_mod2_chain_area_base |
| + chain_id * tpm_db_mod2_chain_cfg[chain_type].max_size; |
| |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][base_offset]; |
| |
| for (entry_idx = 0; entry_idx < entry_num; entry_idx++) { |
| if (pmt_array[entry_idx].status != TPM_MOD_ENTRY_FREE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| pmt_array[entry_idx].status = TPM_MOD_ENTRY_BOOKED; |
| pmt_array[entry_idx].chain_type = chain_type; |
| pmt_array[entry_idx].chain_id = chain_id; |
| memcpy(&pmt_array[entry_idx].pattern, &pattern[entry_idx], sizeof(tpm_mod2_entry_t)); |
| } |
| |
| info_p->base_entry = base_offset; |
| info_p->entry_num = entry_num; |
| } |
| |
| tpm_db_mod2_increase_chain_user(gmac_port, chain_type, chain_id); |
| } else { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_activate_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| tpm_mod2_chain_info_t *info_p; |
| uint32_t i, j, mask; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| |
| if (info_p->status == TPM_MOD_ENTRY_BOOKED) { |
| info_p->status = TPM_MOD_ENTRY_OCCUPIED; |
| |
| i = j = 0; |
| j = chain_id & 0x1f; |
| i = chain_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type][i] &= ~mask; |
| tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type][i] |= mask; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_activate_chain_pmt_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| uint16_t base_offset, entry_idx, entry_num; |
| tpm_mod2_chain_info_t *info_p = NULL; |
| tpm_mod2_chain_pmt_info_t *pmt_array = NULL; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| |
| if (info_p->status != TPM_MOD_ENTRY_BOOKED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| base_offset = info_p->base_entry; |
| entry_num = info_p->entry_num; |
| |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][base_offset]; |
| |
| for (entry_idx = 0; entry_idx < entry_num; entry_idx++) |
| pmt_array[entry_idx].status = TPM_MOD_ENTRY_OCCUPIED; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_if_chain_pmt_entries_exist(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, |
| uint16_t chain_id, uint8_t *exist) |
| { |
| uint16_t base_offset, entry_idx, entry_num; |
| tpm_mod2_chain_info_t *info_p = NULL; |
| tpm_mod2_chain_pmt_info_t *pmt_array = NULL; |
| |
| if (exist == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| |
| *exist = 0; |
| |
| if (info_p->status == TPM_MOD_ENTRY_BOOKED) { |
| base_offset = info_p->base_entry; |
| entry_num = info_p->entry_num; |
| |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][base_offset]; |
| |
| for (entry_idx = 0; entry_idx < entry_num; entry_idx++) { |
| if (pmt_array[entry_idx].status != TPM_MOD_ENTRY_OCCUPIED) |
| break; |
| } |
| |
| if (entry_idx == entry_num) |
| *exist = 1; |
| |
| } else if (info_p->status == TPM_MOD_ENTRY_OCCUPIED) |
| *exist = 1; |
| else { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_get_chain_entry_num(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, |
| uint16_t chain_id, uint16_t *entry_num) |
| { |
| tpm_mod2_chain_info_t *info_p; |
| |
| if (entry_num == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| *entry_num = 0; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| if (info_p->status != TPM_MOD_ENTRY_OCCUPIED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| *entry_num = info_p->entry_num; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_get_chain_entry_pattern_data(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, |
| uint16_t chain_id, uint16_t pattern_id, tpm_mod2_entry_t *pattern) |
| { |
| tpm_mod2_chain_info_t *info_p; |
| tpm_mod2_chain_pmt_info_t *entry_p; |
| |
| if (pattern == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero chain\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| if (chain_id >= tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain index\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain info\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| if (info_p->status != TPM_MOD_ENTRY_OCCUPIED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| |
| if (pattern_id >= info_p->entry_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid pattern index\n"); |
| return TPM_DB_ERR_DB_TBL_INV; |
| } |
| |
| entry_p = &tpm_db_mod2_chain_pmt_info[gmac_port][info_p->base_entry + pattern_id]; |
| if (entry_p->status != TPM_MOD_ENTRY_OCCUPIED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid entry status\n"); |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| } |
| memcpy(pattern, &(entry_p->pattern), sizeof(tpm_mod2_entry_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_del_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| uint16_t /*entry_offset, chain_type, chain_id, */ entry_num, /*jump_to, */ entry_index; |
| uint8_t remove_it; |
| tpm_mod2_chain_info_t *info_p = NULL; |
| tpm_mod2_chain_pmt_info_t *pmt_array = NULL; |
| uint32_t i, j, mask; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain type \n"); |
| return TPM_DB_ERR_REC_INV; |
| } |
| |
| if (chain_id > tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain id \n"); |
| return TPM_DB_ERR_REC_INV; |
| } |
| |
| info_p = &tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]; |
| |
| if (info_p->status != TPM_MOD_ENTRY_OCCUPIED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid chain entry \n"); |
| return TPM_DB_ERR_REC_INV; |
| } |
| |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][info_p->base_entry]; |
| |
| tpm_db_mod2_decrease_chain_user(gmac_port, chain_type, chain_id); |
| |
| remove_it = 0; |
| if (tpm_db_mod2_chain_user_num(gmac_port, chain_type, chain_id) == 0) |
| remove_it = 1; |
| |
| entry_num = info_p->entry_num; |
| |
| for (entry_index = 0; entry_index < entry_num; entry_index++) { |
| if (remove_it) { |
| memset(&pmt_array[entry_index], 0, sizeof(tpm_mod2_chain_pmt_info_t)); |
| pmt_array[entry_index].status = TPM_MOD_ENTRY_FREE; |
| } |
| } |
| |
| if (remove_it) { |
| memset(info_p, 0, sizeof(tpm_mod2_chain_info_t)); |
| info_p->status = TPM_MOD_ENTRY_FREE; |
| |
| i = j = 0; |
| j = chain_id & 0x1f; |
| i = chain_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type][i] &= ~mask; |
| |
| tpm_db_mod2_flush_chain_entry(gmac_port, chain_type, chain_id, 1, 0); |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_mod2_update_next_free_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type) |
| { |
| uint16_t chain_id; |
| uint32_t bm_idx, bit_idx, data; |
| uint32_t *booked_bm = NULL, *occupied_bm = NULL; |
| |
| booked_bm = tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type]; |
| occupied_bm = tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type]; |
| |
| for (bm_idx = 0; bm_idx < tpm_db_mod2_chain_bm_group[chain_type]; bm_idx++) { |
| data = ((booked_bm[bm_idx] | occupied_bm[bm_idx]) ^ 0xffffffff); |
| if (data) { |
| chain_id = bm_idx << 5; /* multiply 32 */ |
| bit_idx = 0; |
| while (data) { |
| if (data & 0x1) { |
| chain_id += bit_idx; |
| if (chain_id < tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| tpm_db_mod2_chain_cfg[chain_type].next_free[gmac_port] = chain_id; |
| return; |
| } |
| break; |
| } |
| bit_idx++; |
| data = data >> 1; |
| } |
| } |
| } |
| |
| tpm_db_mod2_chain_cfg[chain_type].next_free[gmac_port] = TPM_MOD2_INVALID_CHAIN_ID; |
| return; |
| } |
| |
| uint16_t tpm_db_mod2_get_next_free_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type) |
| { |
| uint16_t next_free; |
| uint32_t i, j, mask; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) |
| return TPM_MOD2_INVALID_CHAIN_ID; |
| |
| next_free = tpm_db_mod2_chain_cfg[chain_type].next_free[gmac_port]; |
| if (next_free != TPM_MOD2_INVALID_CHAIN_ID) { |
| tpm_db_mod2_chain_info[gmac_port][chain_type][next_free].status = TPM_MOD_ENTRY_BOOKED; |
| |
| i = j = 0; |
| j = TPM_DB_MOD_32(next_free); |
| i = TPM_DB_DIVIDED_BY_32(next_free); |
| mask = 1 << j; |
| |
| tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type][i] |= mask; |
| } |
| |
| tpm_db_mod2_update_next_free_chain_entry(gmac_port, chain_type); |
| |
| return next_free; |
| } |
| |
| uint16_t tpm_db_mod2_convert_chain_to_pmt_entry(tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| tpm_mod2_chain_cfg_t *cfg_p = NULL; |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) |
| return TPM_MOD2_NULL_ENT_IDX; |
| |
| cfg_p = &tpm_db_mod2_chain_cfg[chain_type]; |
| |
| if (chain_id >= cfg_p->total_num) |
| return TPM_MOD2_NULL_ENT_IDX; |
| |
| return (chain_id * cfg_p->max_size + cfg_p->base_entry); |
| } |
| |
| int32_t tpm_db_mod2_get_chain_id_by_pmt_entry(tpm_gmacs_enum_t gmac_port, uint16_t entry_id, |
| tpm_chain_type_t *chain_type, uint16_t *chain_id) |
| { |
| uint16_t entry_offset; |
| tpm_mod2_chain_pmt_info_t *pmt_array = NULL; |
| |
| if (chain_type == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_id == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (entry_id >= TPM_MOD2_TOTAL_PMT_SIZE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| entry_offset = entry_id - tpm_mod2_chain_area_base; |
| if (entry_offset >= tpm_mod2_total_chain_num) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][entry_offset]; |
| |
| if (pmt_array->status != TPM_MOD_ENTRY_OCCUPIED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid pmt entry \n"); |
| return TPM_DB_ERR_REC_INV; |
| } |
| |
| *chain_type = pmt_array->chain_type; |
| *chain_id = pmt_array->chain_id; |
| |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_mod2_update_next_free_jump_entry(tpm_gmacs_enum_t gmac_port) |
| { |
| uint16_t entry_id /*, total_num */ ; |
| /*tpm_mod2_jump_pmt_info_t *info_array = NULL; */ |
| uint32_t bm_idx, bit_idx, data; |
| uint32_t *booked_bm = NULL, *occupied_bm = NULL, *split_mod_occupied_bm = NULL; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return; |
| } |
| |
| booked_bm = tpm_db_mod2_jump_booked_entry_bm[gmac_port]; |
| occupied_bm = tpm_db_mod2_jump_occupied_entry_bm[gmac_port]; |
| split_mod_occupied_bm = tpm_db_mod2_jump_split_mod_all_entry_bm[gmac_port]; |
| #if 0 |
| info_array = tpm_db_mod2_jump_pmt_info[gmac_port]; |
| total_num = tpm_db_mod2_jump_area_cfg.total_num; |
| |
| for (entry_id = 0; entry_id < total_num; entry_id++) |
| #endif |
| for (bm_idx = 0; bm_idx < tpm_db_mod2_jump_bm_group; bm_idx++) { |
| /*if (info_array[entry_id].status == TPM_MOD_ENTRY_FREE) */ |
| data = ((booked_bm[bm_idx] | occupied_bm[bm_idx] | split_mod_occupied_bm[bm_idx]) ^ 0xffffffff); |
| if (data) { |
| entry_id = bm_idx << 5; /* multiply 32 */ |
| bit_idx = 0; |
| while (data) { |
| if (data & 0x1) { |
| entry_id += bit_idx; |
| if (entry_id < tpm_db_mod2_jump_area_cfg.total_num) { |
| tpm_db_mod2_jump_area_cfg.next_free[gmac_port] = entry_id; |
| return; |
| } |
| break; |
| } |
| bit_idx++; |
| data = data >> 1; |
| } |
| } |
| } |
| |
| tpm_db_mod2_jump_area_cfg.next_free[gmac_port] = TPM_MOD2_NULL_ENT_IDX; |
| return; |
| } |
| |
| uint16_t tpm_db_mod2_get_next_free_jump_entry(tpm_gmacs_enum_t gmac_port) |
| { |
| uint16_t next_free; |
| uint32_t i, j, mask; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return TPM_MOD2_NULL_ENT_IDX; |
| |
| next_free = tpm_db_mod2_jump_area_cfg.next_free[gmac_port]; |
| if (next_free != TPM_MOD2_NULL_ENT_IDX) { |
| tpm_db_mod2_jump_pmt_info[gmac_port][next_free].status = TPM_MOD_ENTRY_BOOKED; |
| |
| i = j = 0; |
| j = TPM_DB_MOD_32(next_free); |
| i = TPM_DB_DIVIDED_BY_32(next_free); |
| mask = 1 << j; |
| |
| tpm_db_mod2_jump_booked_entry_bm[gmac_port][i] |= mask; |
| } |
| |
| tpm_db_mod2_update_next_free_jump_entry(gmac_port); |
| |
| return next_free; |
| } |
| |
| uint32_t tpm_db_mod2_split_mod_get_vlan_num_in_use(tpm_gmacs_enum_t gmac_port) |
| { |
| uint32_t i; |
| uint32_t vlan_num = 0; |
| |
| for (i = 0; i < TPM_DB_SPLIT_MOD_NUM_VLANS_MAX; i++) { |
| if (tpm_db.split_mod_conf.gmac_vlan_conf[gmac_port].split_mod_vlan[i].valid) |
| vlan_num++; |
| } |
| |
| return vlan_num; |
| } |
| |
| uint16_t tpm_db_mod2_get_next_split_mod_free_jump_entry(tpm_gmacs_enum_t gmac_port, tpm_pkt_mod_t *mod_data) |
| { |
| uint16_t next_free; |
| uint32_t i, j, mask; |
| uint32_t vlan_index, db_ret; |
| uint32_t pbit_index = 0; |
| tpm_vlan_key_t *vlan_out; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return TPM_MOD2_NULL_ENT_IDX; |
| |
| db_ret = tpm_db_mod2_split_mod_get_vlan_index(gmac_port, mod_data, &vlan_index); |
| if (TPM_DB_OK != db_ret) |
| return TPM_MOD2_NULL_ENT_IDX; |
| |
| /* get next_free pmt index from vid index */ |
| if (0 == vlan_index) |
| /* first vlan, means vlan 0, default */ |
| next_free = 1; |
| else |
| next_free = (16 * vlan_index); |
| |
| if (VLANOP_EXT_TAG_MOD_INS == mod_data->vlan_mod.vlan_op) |
| vlan_out = &mod_data->vlan_mod.vlan2_out; |
| else |
| vlan_out = &mod_data->vlan_mod.vlan1_out; |
| |
| if (0 == vlan_out->pbit_mask) |
| /* pbit AS_IS */ |
| pbit_index = 0; |
| else { |
| pbit_index = vlan_out->pbit; |
| if (next_free != 1) |
| pbit_index++; |
| } |
| |
| next_free += pbit_index; |
| |
| if (next_free != TPM_MOD2_NULL_ENT_IDX) { |
| tpm_db_mod2_jump_pmt_info[gmac_port][next_free].status = TPM_MOD_ENTRY_BOOKED; |
| |
| i = j = 0; |
| j = TPM_DB_MOD_32(next_free); |
| i = TPM_DB_DIVIDED_BY_32(next_free); |
| mask = 1 << j; |
| |
| tpm_db_mod2_jump_booked_entry_bm[gmac_port][i] |= mask; |
| } |
| |
| return next_free; |
| } |
| int32_t tpm_db_mod2_split_mod_insert_vlan(tpm_gmacs_enum_t port, tpm_pkt_mod_t *mod_data) |
| { |
| uint32_t i; |
| uint32_t vlan_num; |
| |
| /* check vlan num right now */ |
| vlan_num = tpm_db_mod2_split_mod_get_vlan_num_in_use(port); |
| if (vlan_num >= tpm_db_split_mod_get_num_vlans()){ |
| TPM_OS_ERROR(TPM_DB_MOD, "already has %d num_vlans\n", vlan_num - TPM_DB_SPLIT_MOD_INIT_VLANS_NUM); |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| |
| for (i = 0; i < TPM_DB_SPLIT_MOD_NUM_VLANS_MAX; i++) { |
| if (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].valid) |
| continue; |
| |
| //here finds a spot |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].valid = 1; |
| |
| if (mod_data->vlan_mod.vlan1_out.vid_mask) |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_1 = mod_data->vlan_mod.vlan1_out.vid; |
| |
| if (mod_data->vlan_mod.vlan2_out.vid_mask) |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_2 = mod_data->vlan_mod.vlan2_out.vid; |
| |
| if (mod_data->vlan_mod.vlan1_out.tpid_mask) |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_1 = mod_data->vlan_mod.vlan1_out.tpid; |
| |
| if (mod_data->vlan_mod.vlan2_out.tpid_mask) |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_2 = mod_data->vlan_mod.vlan2_out.tpid; |
| |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_op = mod_data->vlan_mod.vlan_op; |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].user_num = 1; |
| |
| return TPM_DB_OK; |
| } |
| |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| int32_t tpm_db_mod2_split_mod_get_vlan_index(tpm_gmacs_enum_t port, tpm_pkt_mod_t *mod_data, uint32_t *index) |
| { |
| uint32_t i; |
| //printk("input: port: %d, vlan_op: %d, vlan1: %d(%d), vlan2: %d(%d)\n", |
| //port, mod_data->vlan_mod.vlan_op, mod_data->vlan_mod.vlan1_out.vid, mod_data->vlan_mod.vlan1_out.vid_mask, |
| //mod_data->vlan_mod.vlan2_out.vid, mod_data->vlan_mod.vlan2_out.vid_mask); |
| for (i = 0; i < TPM_DB_SPLIT_MOD_NUM_VLANS_MAX; i++) { |
| //printk("output: port: %d, vlan_op: %d, vlan1: %d, vlan2: %d\n", |
| //tpm_db.split_mod_conf.gmac_vlan_conf[i].gmac_port, tpm_db.split_mod_conf.gmac_vlan_conf[i].vlan_op, |
| //tpm_db.split_mod_conf.gmac_vlan_conf[i].vlan_1, tpm_db.split_mod_conf.gmac_vlan_conf[i].vlan_2); |
| if (!tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].valid) |
| continue; |
| |
| if (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_op != mod_data->vlan_mod.vlan_op) |
| continue; |
| |
| if ( (mod_data->vlan_mod.vlan1_out.vid_mask) |
| && (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_1 != mod_data->vlan_mod.vlan1_out.vid)) |
| continue; |
| |
| if ( (mod_data->vlan_mod.vlan2_out.vid_mask) |
| && (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_2 != mod_data->vlan_mod.vlan2_out.vid)) |
| continue; |
| |
| if ( (mod_data->vlan_mod.vlan1_out.tpid_mask) |
| && (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_1 != mod_data->vlan_mod.vlan1_out.tpid)) |
| continue; |
| |
| if ( (mod_data->vlan_mod.vlan2_out.tpid_mask) |
| && (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_2 != mod_data->vlan_mod.vlan2_out.tpid)) |
| continue; |
| |
| if ( (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_1) |
| && (!mod_data->vlan_mod.vlan1_out.vid_mask)) |
| continue; |
| |
| if ( (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].vlan_2) |
| && (!mod_data->vlan_mod.vlan2_out.vid_mask)) |
| continue; |
| |
| if ( (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_1) |
| && (!mod_data->vlan_mod.vlan1_out.tpid_mask)) |
| continue; |
| |
| if ( (tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[i].tpid_2) |
| && (!mod_data->vlan_mod.vlan2_out.tpid_mask)) |
| continue; |
| |
| //here finds the vlan |
| *index = i; |
| return TPM_DB_OK; |
| } |
| |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| int32_t tpm_db_mod2_split_mod_increase_vlan_user_num(tpm_gmacs_enum_t port, tpm_pkt_mod_t *mod_data) |
| { |
| uint32_t index; |
| int32_t int_ret_code; |
| |
| int_ret_code = tpm_db_mod2_split_mod_get_vlan_index(port, mod_data, &index); |
| if (TPM_DB_OK != int_ret_code) { |
| TPM_OS_ERROR(TPM_TPM_LOG_MOD, "failed to get split mod vlan index\n"); |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[index].user_num++; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_split_mod_decrease_vlan_user_num(tpm_gmacs_enum_t port, |
| uint32_t vlan_index, |
| uint32_t *user_num) |
| { |
| if (port > TPM_MAX_GMAC) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid port: %d\n", port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (vlan_index >= TPM_DB_SPLIT_MOD_NUM_VLANS_MAX) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid vlan_index: %d\n", vlan_index); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (!tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[vlan_index].valid) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid vlan entry: %d\n", vlan_index); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[vlan_index].user_num--; |
| *user_num = tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[vlan_index].user_num; |
| |
| if (!tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[vlan_index].user_num) { |
| TPM_OS_INFO(TPM_DB_MOD, "user num is 0, remove this vlan\n"); |
| memset(&(tpm_db.split_mod_conf.gmac_vlan_conf[port].split_mod_vlan[vlan_index]), 0, sizeof(tpm_db_split_mod_vlan_t)); |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| uint8_t tpm_db_mod2_rollback_jump_area(tpm_gmacs_enum_t gmac_port, uint16_t entry_id, uint8_t on_failure) |
| { |
| /*uint16_t entry_idx, total_num; */ |
| uint8_t dirty = 0; |
| tpm_mod2_jump_pmt_info_t *info_array = NULL; |
| uint32_t i, j, mask; |
| |
| if (tpm_db_mod2_jump_pmt_info[gmac_port] == NULL) |
| return 0; |
| |
| info_array = tpm_db_mod2_jump_pmt_info[gmac_port]; |
| if (info_array[entry_id].status == TPM_MOD_ENTRY_BOOKED) { |
| /* TODO: check if the pmt entry is for split mod */ |
| i = j = 0; |
| j = entry_id & 0x1f; |
| i = entry_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_jump_booked_entry_bm[gmac_port][i] &= ~mask; |
| |
| info_array[entry_id].status = TPM_MOD_ENTRY_FREE; |
| dirty = 1; |
| } else if (info_array[entry_id].status == TPM_MOD_ENTRY_OCCUPIED) { |
| if (on_failure) { |
| /* TODO: check if the pmt entry is for split mod */ |
| i = j = 0; |
| j = entry_id & 0x1f; |
| i = entry_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_jump_occupied_entry_bm[gmac_port][i] &= ~mask; |
| |
| info_array[entry_id].status = TPM_MOD_ENTRY_FREE; |
| dirty = 1; |
| } |
| } |
| |
| return dirty; |
| } |
| |
| uint8_t tpm_db_mod2_rollback_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, |
| uint16_t chain_id, uint8_t on_failure) |
| { |
| uint8_t dirty = 0; |
| uint16_t entry_index, entry_num; |
| tpm_mod2_chain_info_t *info_array = NULL; |
| tpm_mod2_chain_pmt_info_t *pmt_array = NULL; |
| uint32_t i, j, mask; |
| |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type] == NULL) |
| return 0; |
| |
| info_array = tpm_db_mod2_chain_info[gmac_port][chain_type]; |
| if (info_array[chain_id].status == TPM_MOD_ENTRY_BOOKED) { |
| tpm_db_mod2_decrease_chain_user(gmac_port, chain_type, chain_id); |
| |
| if (tpm_db_mod2_chain_user_num(gmac_port, chain_type, chain_id) == 0) { |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][info_array[chain_id].base_entry]; |
| |
| entry_num = info_array[chain_id].entry_num; |
| |
| for (entry_index = 0; entry_index < entry_num; entry_index++) { |
| memset(&pmt_array[entry_index], 0, sizeof(tpm_mod2_chain_pmt_info_t)); |
| pmt_array[entry_index].status = TPM_MOD_ENTRY_FREE; |
| } |
| |
| i = j = 0; |
| j = chain_id & 0x1f; |
| i = chain_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type][i] &= ~mask; |
| info_array[chain_id].status = TPM_MOD_ENTRY_FREE; |
| dirty = 1; |
| } |
| } else if (info_array[chain_id].status == TPM_MOD_ENTRY_OCCUPIED) { |
| if (on_failure) |
| tpm_db_mod2_decrease_chain_user(gmac_port, chain_type, chain_id); |
| |
| if (tpm_db_mod2_chain_user_num(gmac_port, chain_type, chain_id) == 0) { |
| pmt_array = &tpm_db_mod2_chain_pmt_info[gmac_port][info_array[chain_id].base_entry]; |
| |
| entry_num = info_array[chain_id].entry_num; |
| |
| for (entry_index = 0; entry_index < entry_num; entry_index++) { |
| memset(&pmt_array[entry_index], 0, sizeof(tpm_mod2_chain_pmt_info_t)); |
| pmt_array[entry_index].status = TPM_MOD_ENTRY_FREE; |
| } |
| |
| i = j = 0; |
| j = chain_id & 0x1f; |
| i = chain_id >> 5; |
| mask = 1 << j; |
| |
| tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type][i] &= ~mask; |
| |
| info_array[chain_id].status = TPM_MOD_ENTRY_FREE; |
| dirty = 1; |
| } |
| } |
| return dirty; |
| } |
| |
| int32_t tpm_db_mod2_flush_jump_area(tpm_gmacs_enum_t gmac_port, uint16_t entry_id, |
| uint8_t updt_next_free, uint8_t on_failure) |
| { |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_rollback_jump_area(gmac_port, entry_id, on_failure) || updt_next_free) |
| tpm_db_mod2_update_next_free_jump_entry(gmac_port); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_flush_chain_entry(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, |
| uint16_t chain_id, uint8_t updt_next_free, uint8_t on_failure) |
| { |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid input\n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (tpm_db_mod2_rollback_chain_entry(gmac_port, chain_type, chain_id, on_failure) || updt_next_free) |
| tpm_db_mod2_update_next_free_chain_entry(gmac_port, chain_type); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_validate_chain_config(void) |
| { |
| uint16_t chain_type, total_entries, jump_entries, napt_chains, l2_chains, free_entries; |
| uint16_t split_jump_entries, split_jump_free_entries, least_jump_entries; |
| uint8_t naptv4_unlimited, l2_unlimited, main_chain_empty, subr_chain_empty; |
| uint32_t split_vlan_num, split_pbit_num; |
| |
| main_chain_empty = subr_chain_empty = 1; |
| /* check subroutine chain size */ |
| if (tpm_db_mod2_get_multicast_mh_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mh chain \n"); |
| } else { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", TPM_CHAIN_TYPE_MH); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| subr_chain_empty = 0; |
| } |
| } else { |
| TPM_OS_WARN(TPM_DB_MOD, "multicast mh is disabled, mh chain size should be zero \n"); |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num = 0; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mac chain \n"); |
| } else { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", TPM_CHAIN_TYPE_MAC); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| subr_chain_empty = 0; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero vlan chain \n"); |
| } else { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", TPM_CHAIN_TYPE_VLAN); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| subr_chain_empty = 0; |
| } |
| |
| if (tpm_db_mod2_get_pppoe_add_mod_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num != 0 || |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num != 0) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero pppoev4 chain \n"); |
| } else { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", TPM_CHAIN_TYPE_PPPOE); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| subr_chain_empty = 0; |
| } |
| } |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num != 0 || |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero pppoev6 chain \n"); |
| } else { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", TPM_CHAIN_TYPE_IPV6_PPPOE); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| subr_chain_empty = 0; |
| } |
| } |
| } else { |
| TPM_OS_WARN(TPM_DB_MOD, "pppoe mod is disabled, pppoe chain size should be zero \n"); |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num = 0; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].total_num = 0; |
| } |
| |
| if (subr_chain_empty) { |
| TPM_OS_ERROR(TPM_DB_MOD, "All subr chain is zero \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero l2 main chain \n"); |
| } else { |
| main_chain_empty = 0; |
| } |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero naptv4 main chain \n"); |
| } else { |
| main_chain_empty = 0; |
| } |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mcv4 main chain \n"); |
| } else { |
| main_chain_empty = 0; |
| } |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero routev6 main chain \n"); |
| } else { |
| main_chain_empty = 0; |
| } |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mcv6 main chain \n"); |
| } else { |
| main_chain_empty = 0; |
| } |
| if (main_chain_empty) { |
| TPM_OS_ERROR(TPM_DB_MOD, "All main chain is zero \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| /* check total pmt entries for all the chains */ |
| total_entries = 0; |
| naptv4_unlimited = l2_unlimited = 0; |
| for (chain_type = TPM_CHAIN_TYPE_MH; chain_type < TPM_CHAIN_TYPE_MAX; chain_type++) { |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == TPM_CHAIN_NUM_UNLIMITED) { |
| if (naptv4_unlimited || l2_unlimited) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Only one chain type could be assigned unlimited size \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (chain_type == TPM_CHAIN_TYPE_IPV4_NAPT) { |
| naptv4_unlimited = 1; |
| continue; |
| } else if (chain_type == TPM_CHAIN_TYPE_L2) { |
| l2_unlimited = 1; |
| continue; |
| } else { |
| TPM_OS_ERROR(TPM_DB_MOD, "Invalid unlimited chain type %d \n", chain_type); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| } |
| total_entries += |
| tpm_db_mod2_chain_cfg[chain_type].max_size * tpm_db_mod2_chain_cfg[chain_type].total_num; |
| if (total_entries >= TPM_MOD2_TOTAL_PMT_SIZE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Not enough chain area space \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| } |
| |
| /*the jump entries need at least without split mod*/ |
| if (l2_unlimited) |
| least_jump_entries = tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num; |
| else if (naptv4_unlimited) |
| least_jump_entries = tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num; |
| else |
| least_jump_entries = tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num; |
| |
| /*take split mod in consider*/ |
| split_jump_entries = 0; |
| split_jump_free_entries = 0; |
| if (TPM_SPLIT_MOD_ENABLED == tpm_db_split_mod_get_enable()) { |
| split_vlan_num = tpm_db_split_mod_get_num_vlans() - TPM_DB_SPLIT_MOD_INIT_VLANS_NUM; |
| split_pbit_num = TPM_DB_SPLIT_MOD_P_BIT_NUM_MAX; |
| split_jump_entries = 16 * 2/*init added*/ + |
| (split_vlan_num - 1) * 16/*internal VLAN*/ + |
| split_pbit_num + 1/*last VLAN*/; |
| split_jump_free_entries = 2 * (15 - split_pbit_num)/*init occupy*/ + |
| (split_vlan_num - 1) * (16 - split_pbit_num - 1)/*internal VLAN*/; |
| } |
| |
| if (l2_unlimited) { |
| if (split_jump_free_entries >= least_jump_entries) |
| free_entries = TPM_MOD2_TOTAL_PMT_SIZE - total_entries - split_jump_entries; |
| else |
| free_entries = TPM_MOD2_TOTAL_PMT_SIZE - total_entries - split_jump_entries - |
| (least_jump_entries - split_jump_free_entries); |
| l2_chains = free_entries / (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].max_size + 1); |
| if (l2_chains == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero naptv4 main chain \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| total_entries += l2_chains * tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].max_size; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num = l2_chains; |
| } else if (naptv4_unlimited) { |
| if (split_jump_free_entries >= least_jump_entries) |
| free_entries = TPM_MOD2_TOTAL_PMT_SIZE - total_entries - split_jump_entries; |
| else |
| free_entries = TPM_MOD2_TOTAL_PMT_SIZE - total_entries - split_jump_entries - |
| (least_jump_entries - split_jump_free_entries); |
| napt_chains = free_entries / (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].max_size + 1); |
| if (napt_chains == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero naptv4 main chain \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| total_entries += napt_chains * tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].max_size; |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num = napt_chains; |
| } |
| |
| if (total_entries >= TPM_MOD2_TOTAL_PMT_SIZE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero jump area \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| jump_entries = TPM_MOD2_TOTAL_PMT_SIZE - total_entries; |
| if (jump_entries > TPM_MOD2_MAX_JUMP_ENTRIES_NUM) |
| jump_entries = TPM_MOD2_MAX_JUMP_ENTRIES_NUM; |
| |
| if ((tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num + |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num) > jump_entries - (split_jump_entries - split_jump_free_entries)) |
| TPM_OS_WARN(TPM_DB_MOD, "jump entries are not enough for main chain \n"); |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num > 32) |
| TPM_OS_WARN(TPM_DB_MOD, "mh sub chain is too large \n"); |
| |
| if ((tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num < tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num) |
| && (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num < |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num)) |
| TPM_OS_WARN(TPM_DB_MOD, "mac sub chain is too large \n"); |
| |
| if (((tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num + (split_jump_entries - split_jump_free_entries) < |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num)) |
| && ((tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num + (split_jump_entries - split_jump_free_entries) < |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num))) |
| TPM_OS_WARN(TPM_DB_MOD, "vlan sub chain is too large \n"); |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num < |
| tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num) |
| TPM_OS_WARN(TPM_DB_MOD, "pppoe sub chain is too large \n"); |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_L2].total_num > 0) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero vlan subr chain while naptv4 main chain is activated \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_NAPT].total_num > 0) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero mac subr chain while naptv4 main chain is activated \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero vlan subr chain while naptv4 main chain is activated \n"); |
| } |
| |
| if (tpm_db_mod2_get_pppoe_add_mod_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_PPPOE].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, |
| "Zero pppoe subr chain while naptv4 main chain is activated \n"); |
| } |
| } |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_ROUTE].total_num > 0) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MAC].total_num == 0) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Zero mac subr chain while routev6 main chain is activated \n"); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_VLAN].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero vlan subr chain while routev6 main chain is activated \n"); |
| } |
| |
| if (tpm_db_mod2_get_pppoe_add_mod_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_PPPOE].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, |
| "Zero pppoe subr chain while routev6 main chain is activated \n"); |
| } |
| } |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV4_MC].total_num > 0) { |
| if (tpm_db_mod2_get_multicast_mh_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mh subr chain while mcv4 main chain is activated \n"); |
| } |
| } |
| } |
| |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_IPV6_MC].total_num > 0) { |
| if (tpm_db_mod2_get_multicast_mh_state()) { |
| if (tpm_db_mod2_chain_cfg[TPM_CHAIN_TYPE_MH].total_num == 0) { |
| TPM_OS_WARN(TPM_DB_MOD, "Zero mh subr chain while mcv6 main chain is activated \n"); |
| } |
| } |
| } |
| |
| if (jump_entries < split_jump_entries) |
| TPM_OS_WARN(TPM_DB_MOD, "jump entries are not enough for split mod \n"); |
| |
| /* TODO: Check if jump entries are enough for split modification */ |
| |
| tpm_mod2_chain_area_base = jump_entries + 1; |
| tpm_mod2_total_chain_num = total_entries; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_setup_jump_area(tpm_gmacs_enum_t port) |
| { |
| uint32_t info_size, bm_size /*, port */ ; |
| uint32_t vlan_nums; |
| uint32_t p_bits_nums; |
| uint32_t i, j; |
| uint32_t loop; |
| uint32_t loop_in; |
| uint32_t cur_entry, mask; |
| |
| tpm_db_mod2_jump_area_cfg.base_entry = 0; |
| tpm_db_mod2_jump_area_cfg.total_num = tpm_mod2_chain_area_base; |
| #if 0 |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_0] = 1; |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_1] = 1; |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_PMAC] = 1; |
| #endif |
| tpm_db_mod2_jump_area_cfg.next_free[port] = 1; |
| |
| info_size = tpm_db_mod2_jump_area_cfg.total_num * sizeof(tpm_mod2_jump_pmt_info_t); |
| if (tpm_db_mod2_jump_area_cfg.total_num % 32) { |
| bm_size = (tpm_db_mod2_jump_area_cfg.total_num / 32 + 1) * sizeof(uint32_t); |
| tpm_db_mod2_jump_bm_group = tpm_db_mod2_jump_area_cfg.total_num / 32 + 1; |
| } else { |
| bm_size = (tpm_db_mod2_jump_area_cfg.total_num / 32) * sizeof(uint32_t); |
| tpm_db_mod2_jump_bm_group = tpm_db_mod2_jump_area_cfg.total_num / 32; |
| } |
| |
| /*for (port = TPM_ENUM_GMAC_0; port < TPM_MAX_NUM_GMACS; port++) */ |
| { |
| if (tpm_db_mod2_jump_pmt_info[port] != NULL) { |
| vfree(tpm_db_mod2_jump_pmt_info[port]); |
| tpm_db_mod2_jump_pmt_info[port] = NULL; |
| } |
| tpm_db_mod2_jump_pmt_info[port] = (tpm_mod2_jump_pmt_info_t *) vmalloc(info_size); |
| if (tpm_db_mod2_jump_pmt_info[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_jump_pmt_info[port], 0, info_size); |
| tpm_db_mod2_jump_pmt_info[port][0].status = TPM_MOD_ENTRY_OCCUPIED; |
| |
| if (tpm_db_mod2_jump_booked_entry_bm[port] != NULL) { |
| vfree(tpm_db_mod2_jump_booked_entry_bm[port]); |
| tpm_db_mod2_jump_booked_entry_bm[port] = NULL; |
| } |
| tpm_db_mod2_jump_booked_entry_bm[port] = (uint32_t *) vmalloc(bm_size); |
| if (tpm_db_mod2_jump_booked_entry_bm[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_jump_booked_entry_bm[port], 0, bm_size); |
| |
| if (tpm_db_mod2_jump_occupied_entry_bm[port] != NULL) { |
| vfree(tpm_db_mod2_jump_occupied_entry_bm[port]); |
| tpm_db_mod2_jump_occupied_entry_bm[port] = NULL; |
| } |
| tpm_db_mod2_jump_occupied_entry_bm[port] = (uint32_t *) vmalloc(bm_size); |
| if (tpm_db_mod2_jump_occupied_entry_bm[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_jump_occupied_entry_bm[port], 0, bm_size); |
| tpm_db_mod2_jump_occupied_entry_bm[port][0] |= 0x1; |
| |
| if (tpm_db_mod2_jump_split_mod_occupied_entry_bm[port] != NULL) { |
| vfree(tpm_db_mod2_jump_split_mod_occupied_entry_bm[port]); |
| tpm_db_mod2_jump_split_mod_occupied_entry_bm[port] = NULL; |
| } |
| tpm_db_mod2_jump_split_mod_occupied_entry_bm[port] = (uint32_t *) vmalloc(bm_size); |
| if (tpm_db_mod2_jump_split_mod_occupied_entry_bm[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_jump_split_mod_occupied_entry_bm[port], 0xff, bm_size); |
| tpm_db_mod2_jump_split_mod_occupied_entry_bm[port][0] |= 0x1; |
| |
| if (tpm_db_mod2_jump_split_mod_all_entry_bm[port] != NULL) { |
| vfree(tpm_db_mod2_jump_split_mod_all_entry_bm[port]); |
| tpm_db_mod2_jump_split_mod_all_entry_bm[port] = NULL; |
| } |
| tpm_db_mod2_jump_split_mod_all_entry_bm[port] = (uint32_t *) vmalloc(bm_size); |
| if (tpm_db_mod2_jump_split_mod_all_entry_bm[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_jump_split_mod_all_entry_bm[port], 0, bm_size); |
| } |
| |
| /* split mod init */ |
| if (TPM_SPLIT_MOD_DISABLED == tpm_db_split_mod_get_enable()) |
| { |
| TPM_OS_DEBUG(TPM_MODZ2_HM_MOD, "SPLIT_MOD_DISABLED\n"); |
| return(TPM_OK); |
| } |
| |
| vlan_nums = tpm_db_split_mod_get_num_vlans(); |
| p_bits_nums = TPM_DB_SPLIT_MOD_P_BIT_NUM_MAX; |
| |
| |
| tpm_db_mod2_jump_area_cfg.next_free[port] = p_bits_nums + 1; |
| //tpm_db_mod2_jump_area_cfg.next_split[port] = 16; |
| |
| for (loop = 0; loop <= vlan_nums; loop++) { |
| for (loop_in = 0; loop_in <= p_bits_nums; loop_in++) { |
| cur_entry = (loop * 16) + loop_in; |
| i = j = 0; |
| j = cur_entry & 0x1f; |
| i = cur_entry >> 5; |
| mask = 1 << j; |
| tpm_db_mod2_jump_split_mod_all_entry_bm[port][i] |= mask; |
| //tpm_db_mod2_jump_occupied_entry_bm[port][i] |= mask; |
| //tpm_db_mod2_jump_split_mod_occupied_entry_bm[port][i] &= (~mask); |
| } |
| } |
| //tpm_db_mod2_jump_split_mod_occupied_entry_bm[port][0] |= (0x1); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_setup_chain_area(tpm_gmacs_enum_t port) |
| { |
| uint32_t size, /* port, */ chain; |
| uint16_t base; |
| |
| printk(" ===== chain_area: base entry 0x%0x ===== \r\n", tpm_mod2_chain_area_base); |
| |
| /*for (port = TPM_ENUM_GMAC_0; port < TPM_MAX_NUM_GMACS; port++) */ |
| { |
| printk("[GMAC%d]:\r\n", port); |
| base = tpm_mod2_chain_area_base; |
| for (chain = TPM_CHAIN_TYPE_MH; chain < TPM_CHAIN_TYPE_MAX; chain++) { |
| if (tpm_db_mod2_chain_cfg[chain].total_num != 0) { |
| tpm_db_mod2_chain_cfg[chain].base_entry = base; |
| tpm_db_mod2_chain_cfg[chain].next_free[TPM_ENUM_GMAC_0] = 0; |
| tpm_db_mod2_chain_cfg[chain].next_free[TPM_ENUM_GMAC_1] = 0; |
| tpm_db_mod2_chain_cfg[chain].next_free[TPM_ENUM_PMAC] = 0; |
| |
| size = tpm_db_mod2_chain_cfg[chain].total_num * sizeof(tpm_mod2_chain_info_t); |
| |
| printk("\t chain-%d, 0x%0x - 0x%0x, chain_num: %d\r\n", |
| chain, base, |
| base + |
| tpm_db_mod2_chain_cfg[chain].total_num * tpm_db_mod2_chain_cfg[chain].max_size - |
| 1, tpm_db_mod2_chain_cfg[chain].total_num); |
| |
| if (tpm_db_mod2_chain_info[port][chain] != NULL) { |
| vfree(tpm_db_mod2_chain_info[port][chain]); |
| tpm_db_mod2_chain_info[port][chain] = NULL; |
| } |
| tpm_db_mod2_chain_info[port][chain] = (tpm_mod2_chain_info_t *) vmalloc(size); |
| if (tpm_db_mod2_chain_info[port][chain] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_chain_info[port][chain], 0, size); |
| |
| if (tpm_db_mod2_chain_cfg[chain].total_num % 32) { |
| size = (tpm_db_mod2_chain_cfg[chain].total_num / 32 + 1) * sizeof(uint32_t); |
| tpm_db_mod2_chain_bm_group[chain] = |
| tpm_db_mod2_chain_cfg[chain].total_num / 32 + 1; |
| } else { |
| size = (tpm_db_mod2_chain_cfg[chain].total_num / 32) * sizeof(uint32_t); |
| tpm_db_mod2_chain_bm_group[chain] = tpm_db_mod2_chain_cfg[chain].total_num / 32; |
| } |
| |
| if (tpm_db_mod2_chain_booked_entry_bm[port][chain] != NULL) { |
| vfree(tpm_db_mod2_chain_booked_entry_bm[port][chain]); |
| tpm_db_mod2_chain_booked_entry_bm[port][chain] = NULL; |
| } |
| tpm_db_mod2_chain_booked_entry_bm[port][chain] = (uint32_t *) vmalloc(size); |
| if (tpm_db_mod2_chain_booked_entry_bm[port][chain] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_chain_booked_entry_bm[port][chain], 0, size); |
| |
| if (tpm_db_mod2_chain_occupied_entry_bm[port][chain] != NULL) { |
| vfree(tpm_db_mod2_chain_occupied_entry_bm[port][chain]); |
| tpm_db_mod2_chain_occupied_entry_bm[port][chain] = NULL; |
| } |
| tpm_db_mod2_chain_occupied_entry_bm[port][chain] = (uint32_t *) vmalloc(size); |
| if (tpm_db_mod2_chain_occupied_entry_bm[port][chain] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_chain_occupied_entry_bm[port][chain], 0, size); |
| |
| base += tpm_db_mod2_chain_cfg[chain].total_num * tpm_db_mod2_chain_cfg[chain].max_size; |
| } |
| } |
| |
| if (tpm_db_mod2_chain_pmt_info[port] != NULL) { |
| vfree(tpm_db_mod2_chain_pmt_info[port]); |
| tpm_db_mod2_chain_pmt_info[port] = NULL; |
| } |
| size = tpm_mod2_total_chain_num * sizeof(tpm_mod2_chain_pmt_info_t); |
| tpm_db_mod2_chain_pmt_info[port] = (tpm_mod2_chain_pmt_info_t *) vmalloc(size); |
| if (tpm_db_mod2_chain_pmt_info[port] == NULL) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Memory allocation failure \n"); |
| return TPM_DB_ERR_MEM_ALLOC_FAIL; |
| } |
| memset(tpm_db_mod2_chain_pmt_info[port], 0, size); |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_setup(void) |
| { |
| uint32_t port; |
| |
| if (tpm_db_mod2_validate_chain_config() != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Chain config validation failure \n"); |
| return TPM_FAIL; |
| } |
| |
| for (port = TPM_ENUM_GMAC_0; port < TPM_MAX_NUM_GMACS; port++) { |
| if (tpm_db_mod2_setup_jump_area(port) != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Failed to setup jump area \n"); |
| return TPM_FAIL; |
| } |
| if (tpm_db_mod2_setup_chain_area(port) != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Failed to setup chain area \n"); |
| return TPM_FAIL; |
| } |
| } |
| |
| /* init split mod data */ |
| memset(&(tpm_db.split_mod_conf.gmac_vlan_conf), 0, sizeof(tpm_db.split_mod_conf.gmac_vlan_conf)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_mod2_inv_mac_entries(tpm_gmacs_enum_t gmac_port) |
| { |
| if (tpm_db_mod2_setup_jump_area(gmac_port) != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Failed to setup jump area \n"); |
| return TPM_FAIL; |
| } |
| if (tpm_db_mod2_setup_chain_area(gmac_port) != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Failed to setup chain area \n"); |
| return TPM_FAIL; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| void tpm_db_mod2_show_jump_pmt_entries(tpm_gmacs_enum_t gmac_port) |
| { |
| uint16_t entry_idx; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return; |
| |
| printk(" STATUS OPCODE | DATA | LAST | UPDT_IP | UPDT_CHK \r\n"); |
| for (entry_idx = 0; entry_idx < tpm_db_mod2_jump_area_cfg.total_num; entry_idx++) { |
| if (tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].status != TPM_MOD_ENTRY_FREE) { |
| printk("[PMT 0x%04x]: %s 0x%04x | 0x%04x | %d | %d | %d \r\n", entry_idx, |
| entry_state_str[tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].status], |
| tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].pattern.opcode, |
| tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].pattern.data, |
| tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].pattern.last, |
| tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].pattern.updt_ipv4, |
| tpm_db_mod2_jump_pmt_info[gmac_port][entry_idx].pattern.updt_tcp); |
| } |
| } |
| } |
| |
| void tpm_db_mod2_show_jump_cfg_data(void) |
| { |
| uint32_t i; |
| printk("[JUMP AREA]: base_entry 0x%04x, total_num %d, split_mod_num %d, split_mod_pbit_num %d\r\n", |
| tpm_db_mod2_jump_area_cfg.base_entry, tpm_db_mod2_jump_area_cfg.total_num, |
| tpm_db_mod2_jump_area_cfg.split_num, tpm_db_mod2_jump_area_cfg.split_pbit_num); |
| |
| printk("[NEXT FREE]: GMAC0(G/S) GMAC1(G/S) PMAC(G/S) \r\n"); |
| printk("[NEXT FREE]: 0x%04x/0x%04x 0x%04x/0x%04x 0x%04x/0x%04x \r\n", |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_0], |
| tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_GMAC_0], |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_GMAC_1], |
| tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_GMAC_1], |
| tpm_db_mod2_jump_area_cfg.next_free[TPM_ENUM_PMAC], tpm_db_mod2_jump_area_cfg.next_split[TPM_ENUM_PMAC]); |
| #if 1 |
| printk("[BOOKED_MAP]:\r\n"); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_booked_entry_bm[TPM_ENUM_GMAC_0][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_booked_entry_bm[TPM_ENUM_GMAC_1][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_booked_entry_bm[TPM_ENUM_PMAC][i]); |
| |
| printk("[OCCUPIED_MAP]:\r\n"); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_occupied_entry_bm[TPM_ENUM_GMAC_0][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_occupied_entry_bm[TPM_ENUM_GMAC_1][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_occupied_entry_bm[TPM_ENUM_PMAC][i]); |
| |
| printk("[SPLIT MOD OCCUPIED_MAP]:\r\n"); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_split_mod_occupied_entry_bm[TPM_ENUM_GMAC_0][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_split_mod_occupied_entry_bm[TPM_ENUM_GMAC_1][i]); |
| |
| for (i = 0; i < tpm_db_mod2_jump_bm_group; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_jump_split_mod_occupied_entry_bm[TPM_ENUM_PMAC][i]); |
| #endif |
| } |
| |
| void tpm_db_mod2_show_chain_pmt_entries(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type) |
| { |
| uint16_t entry_idx, pmt_idx, entry_num; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return; |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX) |
| return; |
| |
| printk(" STATUS CHAIN/ID OPCODE | DATA | LAST | UPDT_IP | UPDT_CHK \r\n"); |
| if (chain_type == TPM_CHAIN_TYPE_NONE) { |
| for (chain_type = TPM_CHAIN_TYPE_MH; chain_type < TPM_CHAIN_TYPE_MAX; chain_type++) { |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) |
| continue; |
| |
| entry_num = tpm_db_mod2_chain_cfg[chain_type].total_num * tpm_db_mod2_chain_cfg[chain_type].max_size; |
| |
| for (entry_idx = 0; entry_idx < entry_num; entry_idx++) { |
| pmt_idx = entry_idx + tpm_db_mod2_chain_cfg[chain_type].base_entry - tpm_mod2_chain_area_base; |
| if (tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].status != TPM_MOD_ENTRY_FREE) { |
| printk("[PMT 0x%04x]: %s %d/%d 0x%04x | 0x%04x | %d | %d | %d \r\n", |
| tpm_mod2_chain_area_base + pmt_idx, |
| entry_state_str[tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].status], |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].chain_type, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].chain_id, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.opcode, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.data, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.last, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.updt_ipv4, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.updt_tcp); |
| } |
| } |
| } |
| } else { |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) |
| return; |
| |
| entry_num = tpm_db_mod2_chain_cfg[chain_type].total_num * tpm_db_mod2_chain_cfg[chain_type].max_size; |
| |
| for (entry_idx = 0; entry_idx < entry_num; entry_idx++) { |
| pmt_idx = entry_idx + tpm_db_mod2_chain_cfg[chain_type].base_entry - tpm_mod2_chain_area_base; |
| if (tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].status != TPM_MOD_ENTRY_FREE) { |
| printk("[PMT 0x%04x]: %s %d/%d 0x%04x | 0x%04x | %d | %d | %d \r\n", |
| tpm_mod2_chain_area_base + pmt_idx, |
| entry_state_str[tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].status], |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].chain_type, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].chain_id, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.opcode, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.data, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.last, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.updt_ipv4, |
| tpm_db_mod2_chain_pmt_info[gmac_port][pmt_idx].pattern.updt_tcp); |
| } |
| } |
| } |
| } |
| |
| void tpm_db_mod2_show_chain_info_entries(tpm_gmacs_enum_t gmac_port, tpm_chain_type_t chain_type, uint16_t chain_id) |
| { |
| uint32_t i; |
| |
| if (gmac_port >= TPM_MAX_NUM_GMACS) |
| return; |
| |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) |
| return; |
| |
| if (tpm_db_mod2_chain_cfg[chain_type].total_num == 0) |
| return; |
| |
| printk("[CHAIN-%d Valid Entries]:\r\n", chain_type); |
| |
| if (chain_id == TPM_MOD2_INVALID_CHAIN_ID) { |
| for (chain_id = 0; chain_id < tpm_db_mod2_chain_cfg[chain_type].total_num; chain_id++) { |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].status != TPM_MOD_ENTRY_FREE) { |
| if (chain_id < tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| printk(" STATUS BASE_ENTR ENTR_NUM USER_NUM\r\n"); |
| printk("[CHAIN-%d 0x%04x]: %s 0x%04x %d %d \r\n", |
| chain_type, chain_id, |
| entry_state_str[tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id]. |
| status], |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].base_entry + |
| tpm_mod2_chain_area_base, |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].entry_num, |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num); |
| } |
| } |
| } |
| } else { |
| if (tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].status != TPM_MOD_ENTRY_FREE) { |
| if (chain_id < tpm_db_mod2_chain_cfg[chain_type].total_num) { |
| printk("[CHAIN-%d 0x%04x]: %s 0x%04x %d %d \r\n", chain_type, chain_id, |
| entry_state_str[tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].status], |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].base_entry + |
| tpm_mod2_chain_area_base, |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].entry_num, |
| tpm_db_mod2_chain_info[gmac_port][chain_type][chain_id].user_num); |
| } |
| } |
| } |
| #if 1 |
| printk("[CHAIN-%d BOOKED_MAP]:\r\n", chain_type); |
| |
| for (i = 0; i < tpm_db_mod2_chain_bm_group[chain_type]; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_chain_booked_entry_bm[gmac_port][chain_type][i]); |
| |
| printk("[CHAIN-%d OCCUPIED_MAP]:\r\n", chain_type); |
| |
| for (i = 0; i < tpm_db_mod2_chain_bm_group[chain_type]; i++) |
| printk("%02d - 0x%08x\r\n", i, tpm_db_mod2_chain_occupied_entry_bm[gmac_port][chain_type][i]); |
| #endif |
| printk("\r\n"); |
| } |
| |
| void tpm_db_mod2_show_all_chain(tpm_gmacs_enum_t gmac_port) |
| { |
| uint16_t chain_idx; |
| |
| for (chain_idx = TPM_CHAIN_TYPE_MH; chain_idx < TPM_CHAIN_TYPE_MAX; chain_idx++) |
| tpm_db_mod2_show_chain_info_entries(gmac_port, chain_idx, TPM_MOD2_INVALID_CHAIN_ID); |
| } |
| |
| void tpm_db_mod2_show_chain_cfg_data(tpm_chain_type_t chain_type) |
| { |
| if (chain_type >= TPM_CHAIN_TYPE_MAX || chain_type == TPM_CHAIN_TYPE_NONE) |
| return; |
| |
| printk("[CHAIN %d]: base_entry 0x%04x, total_num %d, max_size %d, subr_chain %d\r\n", chain_type, |
| tpm_db_mod2_chain_cfg[chain_type].base_entry, tpm_db_mod2_chain_cfg[chain_type].total_num, |
| tpm_db_mod2_chain_cfg[chain_type].max_size, tpm_db_mod2_chain_cfg[chain_type].subr_chain); |
| printk("[NEXT FREE]: GMAC0 GMAC1 PMAC \r\n"); |
| printk("[NEXT FREE]: 0x%04x 0x%04x 0x%04x \r\n", |
| tpm_db_mod2_chain_cfg[chain_type].next_free[TPM_ENUM_GMAC_0], |
| tpm_db_mod2_chain_cfg[chain_type].next_free[TPM_ENUM_GMAC_1], |
| tpm_db_mod2_chain_cfg[chain_type].next_free[TPM_ENUM_PMAC]); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mod2_init() |
| * |
| * DESCRIPTION: The API initializes shadow DB and modification patterns |
| * |
| * INPUTS: None |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * None |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mod2_init(void) |
| { |
| tpm_db_mod2_init_jump_area_cfg(); |
| tpm_db_mod2_init_chain_cfg(); |
| |
| tpm_db_mod2_init_pmt_info(); |
| tpm_db_mod2_init_chain_info(); |
| |
| return TPM_DB_OK; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv4_us() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv4_mtu_us(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv4_mtu_us = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv4_mtu_us() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv4_mtu_us(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv4_mtu_us; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv4_pppoe_mtu_us() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv4_pppoe_mtu_us(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv4_pppoe_mtu_us = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv4_pppoe_mtu_us() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv4_pppoe_mtu_us(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv4_pppoe_mtu_us; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_mtu_us() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv6_mtu_us(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv6_mtu_us = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_mtu_us() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv6_mtu_us(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv6_mtu_us; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_pppoe_mtu_us() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv6_pppoe_mtu_us(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv6_pppoe_mtu_us = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_pppoe_mtu_us() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv6_pppoe_mtu_us(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv6_pppoe_mtu_us; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv4_mtu_ds() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv4_mtu_ds(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv4_mtu_ds = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv4_mtu_ds() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv4_mtu_ds(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv4_mtu_ds; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_set_ipv6_mtu_ds(uint32_t mtu) |
| { |
| tpm_db.tpm_mtu_cfg.ipv6_mtu_ds = mtu; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mtu_get_ipv6_mtu_ds(uint32_t *mtu) |
| { |
| *mtu = tpm_db.tpm_mtu_cfg.ipv6_mtu_ds; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_set_num_vlan_tags(uint32_t number) |
| { |
| tpm_db.num_vlan_tags = number; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_get_num_vlan_tags(uint32_t *number) |
| { |
| *number = tpm_db.num_vlan_tags; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_set_pppoe_add_enable(tpm_db_pppoe_add_enable_t enable) |
| { |
| tpm_db.tpm_pppoe_add_enable = enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_get_pppoe_add_enable(tpm_db_pppoe_add_enable_t *enable) |
| { |
| *enable = tpm_db.tpm_pppoe_add_enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_set_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Set queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * igmp_snoop - queue number |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_set_mtu_enable(tpm_db_mtu_setting_enable_t enable) |
| { |
| tpm_db.tpm_mtu_cfg.mtu_enable = enable; |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mtu_get_ipv6_mtu_ds() |
| * |
| * DESCRIPTION: Get queue number which IGMP packets are forwarded to |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * igmp_snoop - queue number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_get_mtu_enable(tpm_db_mtu_setting_enable_t *enable) |
| { |
| *enable = tpm_db.tpm_mtu_cfg.mtu_enable; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_cpu_rx_queue(uint32_t cpu_rx_queue) |
| { |
| tpm_db.cpu_rx_queue = cpu_rx_queue; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_cpu_rx_queue(uint32_t *cpu_rx_queue) |
| { |
| *cpu_rx_queue = tpm_db.cpu_rx_queue; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_ttl_illegal_action(uint32_t ttl_illegal_action) |
| { |
| tpm_db.ttl_illegal_action = ttl_illegal_action; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_ttl_illegal_action(uint32_t *ttl_illegal_action) |
| { |
| *ttl_illegal_action = tpm_db.ttl_illegal_action; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_tcp_flag_check(uint32_t tcp_flag_check) |
| { |
| tpm_db.tcp_flag_check = tcp_flag_check; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_tcp_flag_check(uint32_t *tcp_flag_check) |
| { |
| *tcp_flag_check = tpm_db.tcp_flag_check; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_mru(uint32_t mru) |
| { |
| tpm_db.tpm_mtu_cfg.mru = mru; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_mru(uint32_t *mru) |
| { |
| *mru = tpm_db.tpm_mtu_cfg.mru; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_catch_all_pkt_action(tpm_init_pnc_last_init_t catch_all_pkt_action) |
| { |
| tpm_db.catch_all_pkt_action = catch_all_pkt_action; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_catch_all_pkt_action(tpm_init_pnc_last_init_t *catch_all_pkt_action) |
| { |
| *catch_all_pkt_action = tpm_db.catch_all_pkt_action; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_switch_dev_num(int32_t switch_dev_num) |
| { |
| tpm_db.switch_dev_num = switch_dev_num; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_switch_dev_num(int32_t *switch_dev_num) |
| { |
| *switch_dev_num = tpm_db.switch_dev_num; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_set_ety_dsa_enable(tpm_db_ety_dsa_enable_t ety_dsa_enable) |
| { |
| tpm_db.func_profile.ety_dsa_enable = ety_dsa_enable; |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_get_ety_dsa_enable(tpm_db_ety_dsa_enable_t *ety_dsa_enable) |
| { |
| *ety_dsa_enable = tpm_db.func_profile.ety_dsa_enable; |
| return (TPM_DB_OK); |
| } |
| |
| void tpm_db_show_mtu_cfg(void) |
| { |
| tpm_db_mtu_setting_enable_t mtu_setting_enable; |
| uint32_t mtu, mru; |
| uint32_t num_vlan_tags; |
| tpm_db_pppoe_add_enable_t pppoe_add_enable; |
| |
| tpm_db_get_mtu_enable(&mtu_setting_enable); |
| printk("mtu_config: %d, \n", mtu_setting_enable); |
| |
| tpm_db_mtu_get_ipv4_mtu_us(&mtu); |
| printk("ipv4_mtu_us: %d, \n", mtu); |
| |
| tpm_db_mtu_get_ipv4_pppoe_mtu_us(&mtu); |
| printk("ipv4_pppoe_mtu_us: %d, \n", mtu); |
| |
| tpm_db_mtu_get_ipv6_mtu_us(&mtu); |
| printk("ipv6_mtu_us: %d, \n", mtu); |
| |
| tpm_db_mtu_get_ipv6_pppoe_mtu_us(&mtu); |
| printk("ipv6_pppoe_mtu_us: %d, \n", mtu); |
| |
| tpm_db_mtu_get_ipv4_mtu_ds(&mtu); |
| printk("ipv4_mtu_ds: %d, \n", mtu); |
| |
| tpm_db_mtu_get_ipv6_mtu_ds(&mtu); |
| printk("ipv6_mtu_ds: %d, \n", mtu); |
| |
| tpm_db_get_pppoe_add_enable(&pppoe_add_enable); |
| printk("pppoe_add_enable: %d, \n", pppoe_add_enable); |
| |
| tpm_db_get_num_vlan_tags(&num_vlan_tags); |
| printk("num_vlan_tags: %d, \n", num_vlan_tags); |
| |
| tpm_db_get_mru(&mru); |
| printk("mru: %d, \n", mru); |
| } |
| |
| void tpm_db_api_busy_init(void) |
| { |
| memset(tpm_db.tpm_busy_apis, TPM_DB_API_NOT_BUSY, sizeof(tpm_db.tpm_busy_apis)); |
| } |
| |
| uint32_t tpm_db_get_api_busy(tpm_api_type_t api_type) |
| { |
| uint32_t i; |
| |
| for (i=0;i<TPM_MAX_PARALLEL_API_CALLS;i++) { |
| if (tpm_db.tpm_busy_apis[api_type][i] != TPM_DB_API_NOT_BUSY) |
| return(TPM_TRUE); |
| } |
| return(TPM_FALSE); |
| } |
| |
| uint32_t tpm_db_get_api_rule_num_busy(tpm_api_type_t api_type, uint32_t rule_num) |
| { |
| uint32_t i; |
| |
| for (i=0;i<TPM_MAX_PARALLEL_API_CALLS;i++) { |
| if ( tpm_db.tpm_busy_apis[api_type][i] == rule_num) |
| return(TPM_TRUE); |
| } |
| return(TPM_FALSE); |
| } |
| |
| |
| void tpm_db_get_api_all_busy(tpm_api_type_t api_type, uint32_t *num_busy, uint32_t *rule_num_list) |
| { |
| uint32_t i, l_num_busy=0; |
| |
| for (i=0;i<TPM_MAX_PARALLEL_API_CALLS;i++) { |
| if ( tpm_db.tpm_busy_apis[api_type][i] != TPM_DB_API_NOT_BUSY) { |
| rule_num_list[l_num_busy] = tpm_db.tpm_busy_apis[api_type][i]; |
| l_num_busy++; |
| } |
| } |
| *num_busy = l_num_busy; |
| return; |
| } |
| |
| |
| |
| uint32_t tpm_db_set_api_busy(tpm_api_type_t api_type, uint32_t rule_num) |
| { |
| uint32_t i; |
| |
| for (i=0;i<TPM_MAX_PARALLEL_API_CALLS;i++) { |
| if ( tpm_db.tpm_busy_apis[api_type][i] == TPM_DB_API_NOT_BUSY){ |
| tpm_db.tpm_busy_apis[api_type][i] = rule_num; |
| return (TPM_DB_OK); |
| } |
| } |
| return(TPM_DB_ERR_DB_TBL_FULL); |
| } |
| |
| |
| uint32_t tpm_db_set_api_free(tpm_api_type_t api_type, uint32_t rule_num) |
| { |
| uint32_t i; |
| |
| for (i=0;i<TPM_MAX_PARALLEL_API_CALLS;i++) { |
| if ( tpm_db.tpm_busy_apis[api_type][i] == rule_num){ |
| tpm_db.tpm_busy_apis[api_type][i] = -1; |
| return (TPM_DB_OK); |
| } |
| } |
| return(TPM_DB_ERR_REC_NOT_EXIST); |
| } |
| |
| |
| |
| uint32_t tpm_db_find_matched_ipv6_gen_key(tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| uint32_t i; |
| tpm_db_ipv6_gen_key_t *key_array = &tpm_db.ipv6_key_shadow.gen_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) |
| continue; |
| if (!memcmp(&key_array[i].gen_key, gen_key, sizeof(tpm_ipv6_gen_acl_key_t))) |
| return i; |
| } |
| |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| uint32_t tpm_db_get_ipv6_gen_key_user_num(uint32_t key_id) |
| { |
| return tpm_db.ipv6_key_shadow.gen_key[key_id].user_num; |
| } |
| |
| void tpm_db_increase_ipv6_gen_key_user_num(uint32_t key_id) |
| { |
| tpm_db.ipv6_key_shadow.gen_key[key_id].user_num++; |
| } |
| |
| void tpm_db_decrease_ipv6_gen_key_user_num(uint32_t key_id) |
| { |
| if (tpm_db.ipv6_key_shadow.gen_key[key_id].user_num > 0) |
| tpm_db.ipv6_key_shadow.gen_key[key_id].user_num--; |
| } |
| |
| uint32_t tpm_db_set_ipv6_gen_key(tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| uint32_t i, key_id = TPM_DB_INVALID_IPV6_KEY_ID; |
| tpm_db_ipv6_gen_key_t *key_array = &tpm_db.ipv6_key_shadow.gen_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) { |
| key_id = i; |
| break; |
| } |
| } |
| |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_gen_key_t)); |
| |
| key_array[key_id].valid = TPM_TRUE; |
| memcpy(&key_array[i].gen_key, gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| return key_id; |
| } |
| |
| int32_t tpm_db_get_ipv6_gen_key(uint32_t key_id, tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| tpm_db_ipv6_gen_key_t *key_array = &tpm_db.ipv6_key_shadow.gen_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| memcpy(gen_key, &key_array[key_id].gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_gen_key(uint32_t key_id) |
| { |
| uint32_t user_num; |
| tpm_db_ipv6_gen_key_t *key_array = &tpm_db.ipv6_key_shadow.gen_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| user_num = tpm_db_get_ipv6_gen_key_user_num(key_id); |
| |
| if (user_num == 0) |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_gen_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| uint32_t tpm_db_find_matched_ipv6_dip_key(tpm_ipv6_addr_key_t *dip_key) |
| { |
| uint32_t i; |
| tpm_db_ipv6_dip_key_t *key_array = &tpm_db.ipv6_key_shadow.dip_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) |
| continue; |
| if (!memcmp(&key_array[i].dip_key, dip_key, sizeof(tpm_ipv6_addr_key_t))) |
| return i; |
| } |
| |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| uint32_t tpm_db_get_ipv6_dip_key_user_num(uint32_t key_id) |
| { |
| return tpm_db.ipv6_key_shadow.dip_key[key_id].user_num; |
| } |
| |
| void tpm_db_increase_ipv6_dip_key_user_num(uint32_t key_id) |
| { |
| tpm_db.ipv6_key_shadow.dip_key[key_id].user_num++; |
| } |
| |
| void tpm_db_decrease_ipv6_dip_key_user_num(uint32_t key_id) |
| { |
| if (tpm_db.ipv6_key_shadow.dip_key[key_id].user_num > 0) |
| tpm_db.ipv6_key_shadow.dip_key[key_id].user_num--; |
| } |
| |
| uint32_t tpm_db_set_ipv6_dip_key(tpm_ipv6_addr_key_t *dip_key) |
| { |
| uint32_t i, key_id = TPM_DB_INVALID_IPV6_KEY_ID; |
| tpm_db_ipv6_dip_key_t *key_array = &tpm_db.ipv6_key_shadow.dip_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) { |
| key_id = i; |
| break; |
| } |
| } |
| |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_dip_key_t)); |
| |
| key_array[key_id].valid = TPM_TRUE; |
| memcpy(&key_array[i].dip_key, dip_key, sizeof(tpm_ipv6_addr_key_t)); |
| |
| return key_id; |
| } |
| |
| int32_t tpm_db_get_ipv6_dip_key(uint32_t key_id, tpm_ipv6_addr_key_t *dip_key) |
| { |
| tpm_db_ipv6_dip_key_t *key_array = &tpm_db.ipv6_key_shadow.dip_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| memcpy(dip_key, &key_array[key_id].dip_key, sizeof(tpm_ipv6_addr_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_dip_key(uint32_t key_id) |
| { |
| uint32_t user_num; |
| tpm_db_ipv6_dip_key_t *key_array = &tpm_db.ipv6_key_shadow.dip_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| user_num = tpm_db_get_ipv6_dip_key_user_num(key_id); |
| |
| if (user_num == 0) |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_dip_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| uint32_t tpm_db_find_matched_ipv6_l4_key(uint32_t protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| uint32_t i; |
| tpm_db_ipv6_l4_key_t *key_array = &tpm_db.ipv6_key_shadow.l4_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) |
| continue; |
| if (!memcmp(&key_array[i].l4_key, l4_key, sizeof(tpm_l4_ports_key_t)) && |
| key_array[i].protocol == protocol) |
| return i; |
| } |
| |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| uint32_t tpm_db_get_ipv6_l4_key_user_num(uint32_t key_id) |
| { |
| return tpm_db.ipv6_key_shadow.l4_key[key_id].user_num; |
| } |
| |
| void tpm_db_increase_ipv6_l4_key_user_num(uint32_t key_id) |
| { |
| tpm_db.ipv6_key_shadow.l4_key[key_id].user_num++; |
| } |
| |
| void tpm_db_decrease_ipv6_l4_key_user_num(uint32_t key_id) |
| { |
| if (tpm_db.ipv6_key_shadow.l4_key[key_id].user_num > 0) |
| tpm_db.ipv6_key_shadow.l4_key[key_id].user_num--; |
| } |
| |
| uint32_t tpm_db_set_ipv6_l4_key(uint32_t protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| uint32_t i, key_id = TPM_DB_INVALID_IPV6_KEY_ID; |
| tpm_db_ipv6_l4_key_t *key_array = &tpm_db.ipv6_key_shadow.l4_key[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_KEY_NUM; i++) { |
| if (key_array[i].valid == TPM_FALSE) { |
| key_id = i; |
| break; |
| } |
| } |
| |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| return TPM_DB_INVALID_IPV6_KEY_ID; |
| } |
| |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_l4_key_t)); |
| |
| key_array[key_id].valid = TPM_TRUE; |
| memcpy(&key_array[i].l4_key, l4_key, sizeof(tpm_l4_ports_key_t)); |
| key_array[key_id].protocol = protocol; |
| |
| return key_id; |
| } |
| |
| int32_t tpm_db_get_ipv6_l4_key(uint32_t key_id, uint32_t *protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| tpm_db_ipv6_l4_key_t *key_array = &tpm_db.ipv6_key_shadow.l4_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| memcpy(l4_key, &key_array[key_id].l4_key, sizeof(tpm_l4_ports_key_t)); |
| *protocol = key_array[key_id].protocol; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_l4_key(uint32_t key_id) |
| { |
| uint32_t user_num; |
| tpm_db_ipv6_l4_key_t *key_array = &tpm_db.ipv6_key_shadow.l4_key[0]; |
| |
| if (key_id >= TPM_DB_IPV6_MAX_KEY_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (key_array[key_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| user_num = tpm_db_get_ipv6_l4_key_user_num(key_id); |
| |
| if (user_num == 0) |
| memset(&key_array[key_id], 0, sizeof(tpm_db_ipv6_l4_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| uint32_t tpm_db_find_matched_ipv6_l4_subflow(uint32_t src_dir, uint32_t parse_bm, uint32_t protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| int32_t ret; |
| uint32_t i, _protocol; |
| tpm_db_ipv6_l4_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[0]; |
| tpm_l4_ports_key_t _l4_key; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_SUBFLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) |
| continue; |
| |
| if (parse_bm == flow_array[i].parse_bm) { |
| memset(&_l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| ret = tpm_db_get_ipv6_l4_key(flow_array[i].l4_key, &_protocol, &_l4_key); |
| if (ret != TPM_DB_OK) |
| break; |
| |
| if (_protocol != protocol) |
| continue; |
| |
| if (parse_bm & TPM_PARSE_L4_SRC) { |
| if (_l4_key.l4_src_port != l4_key->l4_src_port) |
| continue; |
| } |
| |
| if (parse_bm & TPM_PARSE_L4_DST) { |
| if (_l4_key.l4_dst_port != l4_key->l4_dst_port) |
| continue; |
| } |
| |
| return i; |
| } |
| } |
| |
| if (i < TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| TPM_OS_WARN(TPM_DB_MOD, "Warning: DB inconsistency\n"); |
| |
| return TPM_DB_INVALID_IPV6_FLOW_ID; |
| } |
| |
| uint32_t tpm_db_get_ipv6_l4_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| return tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[flow_id].user_num; |
| } |
| |
| void tpm_db_increase_ipv6_l4_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[flow_id].user_num++; |
| } |
| |
| void tpm_db_decrease_ipv6_l4_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| if (tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[flow_id].user_num > 0) |
| tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[flow_id].user_num--; |
| } |
| |
| uint32_t tpm_db_get_free_ipv6_l4_subflow(uint32_t src_dir) |
| { |
| uint32_t i; |
| tpm_db_ipv6_l4_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_SUBFLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) |
| return i; |
| } |
| |
| return TPM_DB_INVALID_IPV6_FLOW_ID; |
| } |
| |
| int32_t tpm_db_set_ipv6_l4_subflow(uint32_t src_dir, uint32_t flow_id, uint32_t parse_bm, uint32_t protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| uint32_t l4_key_id; |
| tpm_db_ipv6_l4_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[0]; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid != TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| l4_key_id = tpm_db_find_matched_ipv6_l4_key(protocol, l4_key); |
| |
| if (l4_key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| l4_key_id = tpm_db_set_ipv6_l4_key(protocol, l4_key); |
| if (l4_key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| } |
| |
| tpm_db_increase_ipv6_l4_key_user_num(l4_key_id); |
| |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_l4_flow_t)); |
| |
| flow_array[flow_id].valid = TPM_TRUE; |
| flow_array[flow_id].parse_bm = parse_bm; |
| flow_array[flow_id].l4_key = l4_key_id; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv6_l4_subflow(uint32_t src_dir, uint32_t flow_id, uint32_t *parse_bm, uint32_t *protocol, tpm_l4_ports_key_t *l4_key) |
| { |
| int32_t ret; |
| tpm_db_ipv6_l4_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[0]; |
| uint32_t _protocol; |
| tpm_l4_ports_key_t _l4_key; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| memset(&_l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| ret = tpm_db_get_ipv6_l4_key(flow_array[flow_id].l4_key, &_protocol, &_l4_key); |
| |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| *parse_bm = flow_array[flow_id].parse_bm; |
| *protocol = _protocol; |
| memcpy(l4_key, &_l4_key, sizeof(tpm_l4_ports_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_l4_subflow(uint32_t src_dir, uint32_t flow_id) |
| { |
| uint32_t user_num; |
| tpm_db_ipv6_l4_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[0]; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| |
| user_num = tpm_db_get_ipv6_l4_subflow_user_num(src_dir, flow_id); |
| if (user_num == 0) { |
| tpm_db_decrease_ipv6_l4_key_user_num(flow_array[flow_id].l4_key); |
| tpm_db_del_ipv6_l4_key(flow_array[flow_id].l4_key); |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_l4_flow_t)); |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| uint32_t tpm_db_find_matched_ipv6_gen_subflow(uint32_t src_dir, uint32_t parse_bm, uint32_t protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| uint32_t i, l4_key_id, gen_key_id; |
| tpm_db_ipv6_gen_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_SUBFLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) |
| continue; |
| |
| if (parse_bm == flow_array[i].parse_bm) { |
| if (flow_array[i].l4_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| l4_key_id = tpm_db_find_matched_ipv6_l4_key(protocol, l4_key); |
| if (l4_key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| continue; |
| if (l4_key_id != flow_array[i].l4_key) |
| continue; |
| } |
| |
| if (flow_array[i].gen_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| gen_key_id = tpm_db_find_matched_ipv6_gen_key(gen_key); |
| if (gen_key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| continue; |
| if (gen_key_id != flow_array[i].gen_key) |
| continue; |
| } |
| |
| return i; |
| } |
| } |
| |
| return TPM_DB_INVALID_IPV6_FLOW_ID; |
| } |
| |
| uint32_t tpm_db_get_ipv6_gen_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| return tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[flow_id].user_num; |
| } |
| |
| void tpm_db_increase_ipv6_gen_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[flow_id].user_num++; |
| } |
| |
| void tpm_db_decrease_ipv6_gen_subflow_user_num(uint32_t src_dir, uint32_t flow_id) |
| { |
| if (tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[flow_id].user_num > 0) |
| tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[flow_id].user_num--; |
| } |
| |
| uint32_t tpm_db_get_free_ipv6_gen_subflow(uint32_t src_dir) |
| { |
| uint32_t i; |
| tpm_db_ipv6_gen_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_SUBFLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) |
| return i; |
| } |
| |
| return TPM_DB_INVALID_IPV6_FLOW_ID; |
| } |
| |
| int32_t tpm_db_set_ipv6_gen_subflow(uint32_t src_dir, uint32_t flow_id, uint32_t parse_bm, uint32_t protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| uint32_t l4_parse_bm, gen_parse_bm, l4_flow_id, l4_key_id, gen_key_id; |
| tpm_db_ipv6_gen_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[0]; |
| |
| l4_key_id = gen_key_id = TPM_DB_INVALID_IPV6_KEY_ID; |
| l4_flow_id = TPM_DB_INVALID_IPV6_FLOW_ID; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid != TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| l4_parse_bm = parse_bm & TPM_DB_IPV6_L4_SUBFLOW_PARSE_BM_MASK; |
| |
| if (l4_parse_bm != 0) { |
| l4_flow_id = tpm_db_find_matched_ipv6_l4_subflow(src_dir, l4_parse_bm, protocol, l4_key); |
| |
| if (l4_flow_id == TPM_DB_INVALID_IPV6_FLOW_ID) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| |
| l4_key_id = tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[l4_flow_id].l4_key; |
| } |
| |
| gen_parse_bm = parse_bm & ~TPM_DB_IPV6_L4_SUBFLOW_PARSE_BM_MASK; |
| |
| if (gen_parse_bm != 0) { |
| gen_key_id = tpm_db_find_matched_ipv6_gen_key(gen_key); |
| |
| if (gen_key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| gen_key_id = tpm_db_set_ipv6_gen_key(gen_key); |
| if (gen_key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| } |
| } |
| |
| if (l4_flow_id != TPM_DB_INVALID_IPV6_FLOW_ID) |
| tpm_db_increase_ipv6_l4_subflow_user_num(src_dir, l4_flow_id); |
| |
| if (gen_key_id != TPM_DB_INVALID_IPV6_KEY_ID) |
| tpm_db_increase_ipv6_gen_key_user_num(gen_key_id); |
| |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_gen_flow_t)); |
| |
| flow_array[flow_id].valid = TPM_TRUE; |
| flow_array[flow_id].parse_bm = parse_bm; |
| flow_array[flow_id].l4_key = l4_key_id; |
| flow_array[flow_id].gen_key = gen_key_id; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv6_gen_subflow(uint32_t src_dir, uint32_t flow_id, uint32_t *parse_bm, uint32_t *protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key) |
| { |
| int32_t ret; |
| tpm_db_ipv6_gen_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[0]; |
| uint32_t _protocol = 0; |
| tpm_l4_ports_key_t _l4_key; |
| tpm_ipv6_gen_acl_key_t _gen_key; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| if (flow_array[flow_id].l4_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| memset(&_l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| ret = tpm_db_get_ipv6_l4_key(flow_array[flow_id].l4_key, &_protocol, &_l4_key); |
| |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| if (flow_array[flow_id].gen_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| memset(&_gen_key, 0, sizeof(tpm_ipv6_gen_acl_key_t)); |
| ret = tpm_db_get_ipv6_gen_key(flow_array[flow_id].gen_key, &_gen_key); |
| |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| *parse_bm = flow_array[flow_id].parse_bm; |
| *protocol = _protocol; |
| memcpy(l4_key, &_l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(gen_key, &_gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_gen_subflow(uint32_t src_dir, uint32_t flow_id) |
| { |
| int32_t ret; |
| uint32_t user_num, l4_flow_id, l4_parse_bm, protocol; |
| tpm_db_ipv6_gen_flow_t *flow_array = &tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[0]; |
| tpm_l4_ports_key_t l4_key; |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_SUBFLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_STATUS_ERR; |
| |
| user_num = tpm_db_get_ipv6_gen_subflow_user_num(src_dir, flow_id); |
| if (user_num == 0) { |
| if (flow_array[flow_id].gen_key != TPM_DB_INVALID_IPV6_KEY_ID) |
| tpm_db_decrease_ipv6_gen_key_user_num(flow_array[flow_id].gen_key); |
| |
| tpm_db_del_ipv6_gen_key(flow_array[flow_id].gen_key); |
| |
| if (flow_array[flow_id].l4_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| memset(&l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| ret = tpm_db_get_ipv6_l4_key(flow_array[flow_id].l4_key, &protocol, &l4_key); |
| |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| |
| l4_parse_bm = flow_array[flow_id].parse_bm & TPM_DB_IPV6_L4_SUBFLOW_PARSE_BM_MASK; |
| l4_flow_id = tpm_db_find_matched_ipv6_l4_subflow(src_dir, l4_parse_bm, protocol, &l4_key); |
| |
| if (l4_flow_id == TPM_DB_INVALID_IPV6_FLOW_ID) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| |
| tpm_db_decrease_ipv6_l4_subflow_user_num(src_dir, l4_flow_id); |
| } |
| |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_gen_flow_t)); |
| } |
| return TPM_DB_OK; |
| } |
| |
| uint32_t tpm_db_find_matched_ipv6_5t_flow(uint32_t src_dir, uint32_t parse_bm, uint32_t is_pppoe, uint32_t protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key, tpm_ipv6_addr_key_t *dip_key) |
| { |
| uint32_t i, key_id; |
| tpm_db_ipv6_5t_flow_shadow_t *flow_array = &tpm_db.ipv6_5t_flow_shadow[0]; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_5T_FLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) |
| continue; |
| |
| if (parse_bm == flow_array[i].parse_bm && |
| src_dir == flow_array[i].src_dir && |
| is_pppoe == flow_array[i].is_pppoe) { |
| if (flow_array[i].l4_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| key_id = tpm_db_find_matched_ipv6_l4_key(protocol, l4_key); |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| continue; |
| if (key_id != flow_array[i].l4_key) |
| continue; |
| } |
| |
| if (flow_array[i].gen_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| key_id = tpm_db_find_matched_ipv6_gen_key(gen_key); |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| continue; |
| if (key_id != flow_array[i].gen_key) |
| continue; |
| } |
| |
| if (flow_array[i].dip_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| key_id = tpm_db_find_matched_ipv6_dip_key(dip_key); |
| if (key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| continue; |
| if (key_id != flow_array[i].dip_key) |
| continue; |
| } |
| |
| return i; |
| } |
| } |
| |
| return TPM_DB_INVALID_IPV6_FLOW_ID; |
| } |
| |
| int32_t tpm_db_set_ipv6_5t_flow(uint32_t src_dir, uint32_t parse_bm, uint32_t is_pppoe, uint32_t protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key, tpm_ipv6_addr_key_t *dip_key) |
| { |
| uint32_t i, _parse_bm, subflow_id, l4_key_id, gen_key_id, dip_key_id, flow_id = TPM_DB_INVALID_IPV6_FLOW_ID; |
| tpm_db_ipv6_5t_flow_shadow_t *flow_array = &tpm_db.ipv6_5t_flow_shadow[0]; |
| |
| l4_key_id = gen_key_id = dip_key_id = TPM_DB_INVALID_IPV6_KEY_ID; |
| |
| for (i = 0; i < TPM_DB_IPV6_MAX_5T_FLOW_NUM; i++) { |
| if (flow_array[i].valid == TPM_FALSE) { |
| flow_id = i; |
| break; |
| } |
| } |
| |
| if (flow_id == TPM_DB_INVALID_IPV6_FLOW_ID) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| _parse_bm = parse_bm & ~TPM_DB_IPV6_GEN_SUBFLOW_PARSE_BM_MASK; |
| if (_parse_bm != 0) { |
| dip_key_id = tpm_db_find_matched_ipv6_dip_key(dip_key); |
| if (dip_key_id == TPM_DB_INVALID_IPV6_KEY_ID) { |
| dip_key_id = tpm_db_set_ipv6_dip_key(dip_key); |
| if (dip_key_id == TPM_DB_INVALID_IPV6_KEY_ID) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| } |
| |
| _parse_bm = parse_bm & TPM_DB_IPV6_GEN_SUBFLOW_PARSE_BM_MASK; |
| if (_parse_bm != 0) { |
| subflow_id = tpm_db_find_matched_ipv6_gen_subflow(src_dir, _parse_bm, protocol, l4_key, gen_key); |
| if (subflow_id != TPM_DB_INVALID_IPV6_FLOW_ID) { |
| tpm_db_increase_ipv6_gen_subflow_user_num(src_dir, subflow_id); |
| gen_key_id = tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[subflow_id].gen_key; |
| l4_key_id = tpm_db.ipv6_subflow_shadow[src_dir].gen_flow[subflow_id].l4_key; |
| } else { |
| _parse_bm = parse_bm & TPM_DB_IPV6_L4_SUBFLOW_PARSE_BM_MASK; |
| if (_parse_bm != 0) { |
| subflow_id = tpm_db_find_matched_ipv6_l4_subflow(src_dir, _parse_bm, protocol, l4_key); |
| if (subflow_id != TPM_DB_INVALID_IPV6_FLOW_ID) { |
| tpm_db_increase_ipv6_l4_subflow_user_num(src_dir, subflow_id); |
| l4_key_id = tpm_db.ipv6_subflow_shadow[src_dir].l4_flow[subflow_id].l4_key; |
| } |
| } |
| } |
| } |
| |
| if (dip_key_id != TPM_DB_INVALID_IPV6_KEY_ID) |
| tpm_db_increase_ipv6_dip_key_user_num(dip_key_id); |
| |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_5t_flow_shadow_t)); |
| |
| flow_array[flow_id].valid = TPM_TRUE; |
| flow_array[flow_id].src_dir = src_dir; |
| flow_array[flow_id].parse_bm = parse_bm; |
| flow_array[flow_id].is_pppoe = is_pppoe; |
| flow_array[flow_id].gen_key = gen_key_id; |
| flow_array[flow_id].dip_key = dip_key_id; |
| flow_array[flow_id].l4_key = l4_key_id; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv6_5t_flow(uint32_t flow_id, uint32_t *src_dir, uint32_t *parse_bm, uint32_t *is_pppoe, uint32_t *protocol, |
| tpm_l4_ports_key_t *l4_key, tpm_ipv6_gen_acl_key_t *gen_key, tpm_ipv6_addr_key_t *dip_key) |
| { |
| int32_t ret; |
| tpm_db_ipv6_5t_flow_shadow_t *flow_array = &tpm_db.ipv6_5t_flow_shadow[0]; |
| tpm_l4_ports_key_t _l4_key; |
| tpm_ipv6_gen_acl_key_t _gen_key; |
| tpm_ipv6_addr_key_t _dip_key; |
| uint32_t _protocol = 0; |
| |
| memset(&_l4_key, 0, sizeof(tpm_l4_ports_key_t)); |
| memset(&_gen_key, 0, sizeof(tpm_ipv6_gen_acl_key_t)); |
| memset(&_dip_key, 0, sizeof(tpm_ipv6_addr_key_t)); |
| |
| if (flow_id >= TPM_DB_IPV6_MAX_5T_FLOW_NUM) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| if (flow_array[flow_id].valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_INV; |
| |
| if (flow_array[flow_id].l4_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| ret = tpm_db_get_ipv6_l4_key(flow_array[flow_id].l4_key, &_protocol, &_l4_key); |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| if (flow_array[flow_id].gen_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| ret = tpm_db_get_ipv6_gen_key(flow_array[flow_id].gen_key, &_gen_key); |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| if (flow_array[flow_id].dip_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| ret = tpm_db_get_ipv6_dip_key(flow_array[flow_id].dip_key, &_dip_key); |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } |
| |
| *src_dir = flow_array[flow_id].src_dir; |
| *parse_bm = flow_array[flow_id].parse_bm; |
| *is_pppoe = flow_array[flow_id].is_pppoe; |
| *protocol = _protocol; |
| memcpy(l4_key, &_l4_key, sizeof(tpm_l4_ports_key_t)); |
| memcpy(gen_key, &_gen_key, sizeof(tpm_ipv6_gen_acl_key_t)); |
| memcpy(dip_key, &_dip_key, sizeof(tpm_ipv6_addr_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv6_5t_flow(uint32_t flow_id) |
| { |
| int32_t ret; |
| tpm_db_ipv6_5t_flow_shadow_t *flow_array = &tpm_db.ipv6_5t_flow_shadow[0]; |
| tpm_l4_ports_key_t l4_key; |
| tpm_ipv6_gen_acl_key_t gen_key; |
| tpm_ipv6_addr_key_t dip_key; |
| uint32_t src_dir, parse_bm, protocol, subflow_bm, subflow_id, is_pppoe; |
| |
| |
| ret = tpm_db_get_ipv6_5t_flow(flow_id, &src_dir, &parse_bm, &is_pppoe, &protocol, &l4_key, &gen_key, &dip_key); |
| |
| if (ret != TPM_DB_OK) |
| return TPM_DB_ERR_REC_INV; |
| |
| subflow_bm = parse_bm & TPM_DB_IPV6_GEN_SUBFLOW_PARSE_BM_MASK; |
| if (subflow_bm != 0) { |
| subflow_id = tpm_db_find_matched_ipv6_gen_subflow(src_dir, subflow_bm, protocol, &l4_key, &gen_key); |
| if (subflow_id != TPM_DB_INVALID_IPV6_FLOW_ID) |
| tpm_db_decrease_ipv6_gen_subflow_user_num(src_dir, subflow_id); |
| else { |
| subflow_bm = parse_bm & TPM_DB_IPV6_L4_SUBFLOW_PARSE_BM_MASK; |
| if (subflow_bm != 0) { |
| subflow_id = tpm_db_find_matched_ipv6_l4_subflow(src_dir, subflow_bm, protocol, &l4_key); |
| if (subflow_id != TPM_DB_INVALID_IPV6_FLOW_ID) |
| tpm_db_decrease_ipv6_l4_subflow_user_num(src_dir, subflow_id); |
| } |
| } |
| } |
| |
| if (flow_array[flow_id].dip_key != TPM_DB_INVALID_IPV6_KEY_ID) { |
| tpm_db_decrease_ipv6_dip_key_user_num(flow_array[flow_id].dip_key); |
| tpm_db_del_ipv6_dip_key(flow_array[flow_id].dip_key); |
| } |
| |
| memset(&flow_array[flow_id], 0, sizeof(tpm_db_ipv6_5t_flow_shadow_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_init_ipv6_5t_flow_reset(void) |
| { |
| memset(&tpm_db.ipv6_key_shadow, 0, sizeof(tpm_db_ipv6_key_shadow_t)); |
| memset(tpm_db.ipv6_subflow_shadow, 0, TPM_NUM_DIRECTIONS * sizeof(tpm_db_ipv6_subflow_shadow_t)); |
| memset(tpm_db.ipv6_5t_flow_shadow, 0, TPM_DB_IPV6_MAX_5T_FLOW_NUM * sizeof(tpm_db_ipv6_5t_flow_shadow_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_mode_set(tpm_drop_precedence_t mode) |
| { |
| tpm_db.drop_precedence.mode = mode; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_mode_get(tpm_drop_precedence_t *mode) |
| { |
| *mode = tpm_db.drop_precedence.mode; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_rule_set(uint32_t rule_index) |
| { |
| uint32_t index; |
| tpm_db_drop_precedence_rule_entry_t *rule_entry; |
| |
| for (index = 0; index < TPM_MAX_NUM_DROP_PRECEDENCE; index++) { |
| rule_entry = &tpm_db.drop_precedence.drop_rule[index]; |
| if (rule_entry->valid == TPM_FALSE) |
| break; |
| } |
| |
| if(index >= TPM_MAX_NUM_DROP_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "PnC partition for drop precedence is full %d\n", rule_index); |
| return TPM_DB_ERR_DB_TBL_FULL; |
| } |
| |
| rule_entry->rule_index = rule_index; |
| rule_entry->valid = TPM_TRUE; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_rule_delete(uint32_t rule_index) |
| { |
| uint32_t index; |
| tpm_db_drop_precedence_rule_entry_t *rule_entry; |
| |
| for (index = 0; index < TPM_MAX_NUM_DROP_PRECEDENCE; index++) { |
| rule_entry = &tpm_db.drop_precedence.drop_rule[index]; |
| if ((rule_entry->valid == TPM_TRUE) && |
| (rule_entry->rule_index == rule_index)) |
| break; |
| } |
| |
| if(index >= TPM_MAX_NUM_DROP_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "Did not find drop precedence PnC rule for index %d\n", rule_index); |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| memset(rule_entry, 0, sizeof(tpm_db_drop_precedence_rule_entry_t)); |
| rule_entry->valid = TPM_FALSE; |
| rule_entry->rule_index = 0; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_rule_get(uint32_t index, |
| tpm_db_drop_precedence_rule_entry_t *rule_entry) |
| { |
| if(index >= TPM_MAX_NUM_DROP_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "The index(%d) >= Maximium number(%d)\n", |
| index, index); |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| rule_entry->valid = tpm_db.drop_precedence.drop_rule[index].valid; |
| rule_entry->rule_index = tpm_db.drop_precedence.drop_rule[index].rule_index; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_drop_precedence_db_reset(void) |
| { |
| uint32_t index; |
| |
| memset(&tpm_db.drop_precedence, 0, sizeof(tpm_db.drop_precedence)); |
| for (index = 0; index < TPM_MAX_NUM_DROP_PRECEDENCE; index++) { |
| tpm_db.drop_precedence.drop_rule[index].valid = TPM_FALSE; |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ctc_cm_rule_set(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_sub_pattern_index, |
| uint32_t rule_index) |
| { |
| tpm_db_ctc_cm_rule_entry_t *rule_entry; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if(precedence >= TPM_MAX_NUM_CTC_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input precedence(%d)\n", precedence); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| rule_entry = &tpm_db.ctc_cm_data.cm_rule[src_port][precedence]; |
| |
| rule_entry->l2_parse_rule_bm = l2_parse_rule_bm; |
| rule_entry->ipv4_parse_rule_bm = ipv4_parse_rule_bm; |
| rule_entry->ipv6_parse_rule_bm = ipv6_parse_rule_bm; |
| memcpy(&rule_entry->l2_key, l2_key, sizeof(tpm_l2_acl_key_t)); |
| memcpy(&rule_entry->ipv4_key, ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| memcpy(&rule_entry->ipv6_key, ipv6_key, sizeof(tpm_ipv6_acl_key_t)); |
| memcpy(&rule_entry->pkt_frwd, pkt_frwd, sizeof(tpm_pkt_frwd_t)); |
| rule_entry->pkt_act = pkt_act; |
| rule_entry->pbits = pbits; |
| rule_entry->cm_main_rule_index = rule_index; |
| rule_entry->ipv4_sub_pattern_key = ipv4_sub_pattern_index; |
| rule_entry->valid = 1; |
| |
| if(l2_parse_rule_bm & ipv4_parse_rule_bm) |
| rule_entry->rule_type = TPM_CTC_CM_COMBO; |
| else if(l2_parse_rule_bm) |
| rule_entry->rule_type = TPM_CTC_CM_L2; |
| else if(ipv4_parse_rule_bm) |
| rule_entry->rule_type = TPM_CTC_CM_IPv4; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ctc_cm_rule_delete(tpm_src_port_type_t src_port, uint32_t precedence) |
| { |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if(precedence >= TPM_MAX_NUM_CTC_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input precedence(%d)\n", precedence); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| memset(&tpm_db.ctc_cm_data.cm_rule[src_port][precedence], 0, sizeof(tpm_db_ctc_cm_rule_entry_t)); |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ctc_cm_rule_get(tpm_src_port_type_t src_port, uint32_t precedence, tpm_db_ctc_cm_rule_entry_t *cm_rule) |
| { |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if(precedence >= TPM_MAX_NUM_CTC_PRECEDENCE) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input precedence(%d)\n", precedence); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| memcpy(cm_rule, &tpm_db.ctc_cm_data.cm_rule[src_port][precedence], sizeof(tpm_db_ctc_cm_rule_entry_t)); |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ctc_cm_get_num_rules(tpm_src_port_type_t src_port) |
| { |
| int32_t loop; |
| int32_t num_rules = 0; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| for(loop = 0; loop < TPM_MAX_NUM_CTC_PRECEDENCE; loop++) |
| if(tpm_db.ctc_cm_data.cm_rule[src_port][loop].valid) |
| num_rules++; |
| |
| return num_rules; |
| } |
| |
| int32_t tpm_db_ctc_cm_get_ipv6_num_rules(void) |
| { |
| int32_t loop; |
| int32_t num_rules = 0; |
| tpm_src_port_type_t src_port; |
| |
| for (src_port = TPM_SRC_PORT_UNI_0; src_port < TPM_MAX_NUM_UNI_PORTS; src_port++) |
| for(loop = 0; loop < TPM_MAX_NUM_CTC_PRECEDENCE; loop++) |
| if( (tpm_db.ctc_cm_data.cm_rule[src_port][loop].valid) |
| && (tpm_db.ctc_cm_data.cm_rule[src_port][loop].ipv6_parse_rule_bm)) |
| num_rules++; |
| |
| return num_rules; |
| } |
| |
| int32_t tpm_db_ctc_cm_db_reset(void) |
| { |
| memset(&tpm_db.ctc_cm_data.cm_rule, 0, sizeof(tpm_db.ctc_cm_data.cm_rule)); |
| memset(&tpm_db.ctc_cm_data.ipv4_pre_table, 0, sizeof(tpm_db_cnm_ipv4_pre_table_t)); |
| memset(&tpm_db.ctc_cm_data.ipv4_pre_filter, 0, TPM_MAX_NUM_UNI_PORTS * sizeof(tpm_db_cnm_ipv4_pre_filter_t)); |
| tpm_db.ctc_cm_data.ipv6_parse_win = tpm_db.ctc_cm_data.ipv6_parse_win_original; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ipv6_mc_sip_db_reset(void) |
| { |
| memset(&tpm_db.ipv6_mc_sip, 0, sizeof(tpm_db.ipv6_mc_sip)); |
| /* reserve the first IPv6 MC SIP entry for not matching any SIP */ |
| tpm_db.ipv6_mc_sip[0].valid = 1; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ipv6_mc_sip_index_get(uint8_t *src_ip) |
| { |
| uint32_t i; |
| int32_t ret; |
| tpm_db_pnc_range_t range_data; |
| |
| /*check param*/ |
| if (src_ip == NULL) |
| return 0; |
| |
| ret = tpm_db_pnc_rng_get(TPM_PNC_IPV6_MC_SIP, &range_data); |
| if(ret != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "TPM_PNC_IPV6_MC_SIP is not created!\n"); |
| return 0; |
| } |
| |
| for (i = 1; i < range_data.pnc_range_conf.range_size; i++) { |
| if (tpm_db.ipv6_mc_sip[i].valid == 0) |
| continue; |
| |
| if (memcmp(tpm_db.ipv6_mc_sip[i].src_ip, src_ip, 16)== 0) |
| return i; |
| } |
| |
| /* does not find this src_ip */ |
| return 0; |
| } |
| |
| int32_t tpm_db_ipv6_mc_sip_add(uint8_t *src_ip) |
| { |
| uint32_t i; |
| int32_t ret; |
| tpm_db_pnc_range_t range_data; |
| |
| /*check param*/ |
| if (src_ip == NULL) |
| return 0; |
| |
| ret = tpm_db_pnc_rng_get(TPM_PNC_IPV6_MC_SIP, &range_data); |
| if(ret != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "TPM_PNC_IPV6_MC_SIP is not created!\n"); |
| return 0; |
| } |
| |
| for (i = 1; i < range_data.pnc_range_conf.range_size; i++) { |
| if (tpm_db.ipv6_mc_sip[i].valid == 1) |
| continue; |
| |
| memcpy(tpm_db.ipv6_mc_sip[i].src_ip, src_ip, 16); |
| tpm_db.ipv6_mc_sip[i].valid = 1; |
| tpm_db.ipv6_mc_sip[i].reference_num = 1; |
| return i; |
| } |
| |
| /* do not have slot for this src_ip */ |
| return 0; |
| } |
| int32_t tpm_db_ipv6_mc_sip_ref_num_inc(uint8_t src_ip_index) |
| { |
| /*check param*/ |
| if (src_ip_index >= TPM_MC_IPv6_SIP_NUM_MAX) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (tpm_db.ipv6_mc_sip[src_ip_index].valid == 0) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.ipv6_mc_sip[src_ip_index].reference_num++; |
| |
| return TPM_DB_OK; |
| } |
| int32_t tpm_db_ipv6_mc_sip_ref_num_dec(uint8_t src_ip_index, uint8_t *new_ref_num) |
| { |
| /*check param*/ |
| if (src_ip_index >= TPM_MC_IPv6_SIP_NUM_MAX) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (tpm_db.ipv6_mc_sip[src_ip_index].valid == 0) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (tpm_db.ipv6_mc_sip[src_ip_index].reference_num == 0) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.ipv6_mc_sip[src_ip_index].reference_num--; |
| |
| *new_ref_num = tpm_db.ipv6_mc_sip[src_ip_index].reference_num; |
| /* if new ref num is 0, remove this SIP in DB */ |
| if (tpm_db.ipv6_mc_sip[src_ip_index].reference_num == 0) { |
| memset(&tpm_db.ipv6_mc_sip[src_ip_index], 0, sizeof(tpm_db.ipv6_mc_sip[src_ip_index])); |
| } |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_ipv6_mc_sip_free_slot_num_get(void) |
| { |
| uint32_t i; |
| int32_t ret; |
| tpm_db_pnc_range_t range_data; |
| uint32_t free_slot_num = 0; |
| |
| ret = tpm_db_pnc_rng_get(TPM_PNC_IPV6_MC_SIP, &range_data); |
| if(ret != TPM_DB_OK) { |
| TPM_OS_ERROR(TPM_DB_MOD, "TPM_PNC_IPV6_MC_SIP is not created!\n"); |
| return 0; |
| } |
| |
| for (i = 1; i < range_data.pnc_range_conf.range_size; i++) { |
| if (tpm_db.ipv6_mc_sip[i].valid == 1) |
| continue; |
| free_slot_num++; |
| } |
| |
| return free_slot_num; |
| } |
| |
| int32_t tpm_db_ctc_cm_enable_set(tpm_db_ctc_cm_enable_t ctc_cm_enable) |
| { |
| tpm_db.ctc_cm_data.enable = ctc_cm_enable; |
| return(TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_ctc_cm_enable_get(tpm_db_ctc_cm_enable_t *ctc_cm_enable) |
| { |
| *ctc_cm_enable = tpm_db.ctc_cm_data.enable; |
| return(TPM_DB_OK); |
| } |
| int32_t tpm_db_ctc_cm_ipv6_parse_win_set(tpm_db_ctc_cm_ipv6_parse_win_t ctc_cm_ipv6_parse_win) |
| { |
| tpm_db.ctc_cm_data.ipv6_parse_win = ctc_cm_ipv6_parse_win; |
| return(TPM_DB_OK); |
| } |
| int32_t tpm_db_ctc_cm_ipv6_parse_win_orig_set(tpm_db_ctc_cm_ipv6_parse_win_t ctc_cm_ipv6_parse_win) |
| { |
| tpm_db.ctc_cm_data.ipv6_parse_win_original = ctc_cm_ipv6_parse_win; |
| return(TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_ctc_cm_ipv6_parse_win_get(tpm_db_ctc_cm_ipv6_parse_win_t *ctc_cm_ipv6_parse_win) |
| { |
| *ctc_cm_ipv6_parse_win = tpm_db.ctc_cm_data.ipv6_parse_win; |
| return(TPM_DB_OK); |
| } |
| int32_t tpm_db_ctc_cm_ipv6_ety_rule_num_set(uint32_t ipv6_ety_rule_num) |
| { |
| tpm_db.ctc_cm_data.ipv6_ety_rule_num = ipv6_ety_rule_num; |
| return(TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_ctc_cm_ipv6_ety_rule_num_get(uint32_t *ipv6_ety_rule_num) |
| { |
| *ipv6_ety_rule_num = tpm_db.ctc_cm_data.ipv6_ety_rule_num; |
| return(TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_add_ipv4_pre_rule(tpm_src_port_type_t src_port, uint32_t key_pattern, uint32_t *rule_num) |
| { |
| uint32_t rule_index, i, j; |
| uint32_t *rule_table = &tpm_db.ctc_cm_data.ipv4_pre_table.rule_index[0]; |
| |
| if (rule_num == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| rule_index = TPM_DB_CNM_GEN_IPV4_PRE_RULE_INDEX(src_port, key_pattern); |
| if (rule_index == TPM_DB_CNM_INVALID_IPV4_PRE_RULE_INDEX) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "add rule_index(0x%x)\n", rule_index); |
| |
| for (i = 0; i < tpm_db.ctc_cm_data.ipv4_pre_table.num_rules; i++) { |
| if (rule_index == rule_table[i]) { |
| TPM_OS_ERROR(TPM_DB_MOD, " ipv4_pre_rule already exists!\n"); |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| } else if (rule_index > rule_table[i]) { |
| break; |
| } |
| } |
| |
| for (j = tpm_db.ctc_cm_data.ipv4_pre_table.num_rules; j > i; j--) |
| rule_table[j] = rule_table[j - 1]; |
| |
| rule_table[j] = rule_index; |
| tpm_db.ctc_cm_data.ipv4_pre_table.num_rules++; |
| |
| *rule_num = i; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv4_pre_rule(tpm_src_port_type_t src_port, uint32_t key_pattern, uint32_t *rule_num) |
| { |
| uint32_t rule_index, i, j; |
| uint32_t *rule_table = &tpm_db.ctc_cm_data.ipv4_pre_table.rule_index[0]; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| rule_index = TPM_DB_CNM_GEN_IPV4_PRE_RULE_INDEX(src_port, key_pattern); |
| if (rule_index == TPM_DB_CNM_INVALID_IPV4_PRE_RULE_INDEX) |
| return TPM_DB_ERR_REC_EXIST; |
| |
| TPM_OS_DEBUG(TPM_DB_MOD, "delete rule_index(0x%x)\n", rule_index); |
| |
| for (i = 0; i < tpm_db.ctc_cm_data.ipv4_pre_table.num_rules; i++) { |
| if (rule_index == rule_table[i]) |
| break; |
| } |
| |
| if (i == tpm_db.ctc_cm_data.ipv4_pre_table.num_rules) { |
| TPM_OS_ERROR(TPM_DB_MOD, " ipv4_pre_rule does not exist!\n"); |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| for (j = i; j < tpm_db.ctc_cm_data.ipv4_pre_table.num_rules; j++) |
| rule_table[j] = rule_table[j + 1]; |
| |
| rule_table[j] = TPM_DB_CNM_INVALID_IPV4_PRE_RULE_INDEX; |
| tpm_db.ctc_cm_data.ipv4_pre_table.num_rules--; |
| |
| *rule_num = i; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv4_pre_rule_num(uint32_t *num_rules) |
| { |
| *num_rules = tpm_db.ctc_cm_data.ipv4_pre_table.num_rules; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_alloc_ipv4_pre_filter_key(tpm_src_port_type_t src_port, uint32_t *key_idx) |
| { |
| uint32_t i; |
| |
| /*check param*/ |
| if (key_idx == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].num_keys >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_DB_TBL_FULL; |
| |
| for (i = 0; i < TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM; i++) { |
| if (tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[i].valid == TPM_FALSE) |
| break; |
| } |
| |
| if (i >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_DB_INCONSISTENCY; |
| |
| *key_idx = i; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_set_ipv4_pre_filter_key(tpm_src_port_type_t src_port, |
| uint32_t key_idx, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_ipv4_acl_key_t *ipv4_key) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| /*check param*/ |
| if (ipv4_key == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid != TPM_FALSE) |
| return TPM_DB_ERR_REC_EXIST; |
| |
| key->valid = TPM_TRUE; |
| key->num_users = 0; |
| key->parse_rule_bm = parse_rule_bm; |
| memcpy(&key->ipv4_key, ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| |
| tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].num_keys++; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_del_ipv4_pre_filter_key(tpm_src_port_type_t src_port, uint32_t key_idx) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| memset(key, 0, sizeof(tpm_db_cnm_ipv4_pre_filter_key_t)); |
| |
| tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].num_keys--; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_set_gmac_rate_limit(tpm_db_tx_mod_t gmac_i, |
| uint32_t bucket_size, |
| uint32_t rate_limit, |
| uint32_t prio) |
| { |
| /*check param*/ |
| if (gmac_i >= TPM_MAX_NUM_TX_PORTS) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| tpm_db.gmac_tx[gmac_i].bucket_size = bucket_size; |
| tpm_db.gmac_tx[gmac_i].rate_limit = rate_limit; |
| tpm_db.gmac_tx[gmac_i].prio = prio; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_gmac_rate_limit(tpm_gmacs_enum_t gmac_i, |
| uint32_t *bucket_size, |
| uint32_t *rate_limit, |
| uint32_t *prio) |
| { |
| /*check param*/ |
| if (gmac_i >= TPM_MAX_NUM_TX_PORTS) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| *bucket_size = tpm_db.gmac_tx[gmac_i].bucket_size; |
| *rate_limit = tpm_db.gmac_tx[gmac_i].rate_limit; |
| *prio = tpm_db.gmac_tx[gmac_i].prio; |
| |
| return TPM_DB_OK; |
| } |
| int32_t tpm_db_set_gmac_q_rate_limit(tpm_db_tx_mod_t gmac_i, |
| uint32_t queue, |
| uint32_t bucket_size, |
| uint32_t rate_limit, |
| uint32_t wrr) |
| { |
| /*check param*/ |
| if (gmac_i >= TPM_MAX_NUM_TX_PORTS) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (queue >= TPM_MAX_NUM_TX_QUEUE) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| tpm_db.gmac_tx[gmac_i].tx_queue[queue].bucket_size = bucket_size; |
| tpm_db.gmac_tx[gmac_i].tx_queue[queue].rate_limit = rate_limit; |
| tpm_db.gmac_tx[gmac_i].tx_queue[queue].wrr = wrr; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_gmac_q_rate_limit(tpm_gmacs_enum_t gmac_i, |
| uint32_t queue, |
| uint32_t *bucket_size, |
| uint32_t *rate_limit, |
| uint32_t *wrr) |
| { |
| /*check param*/ |
| if (gmac_i >= TPM_MAX_NUM_TX_PORTS) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (queue >= TPM_MAX_NUM_TX_QUEUE) |
| return TPM_DB_ERR_INV_INPUT; |
| |
| *bucket_size = tpm_db.gmac_tx[gmac_i].tx_queue[queue].bucket_size; |
| *rate_limit = tpm_db.gmac_tx[gmac_i].tx_queue[queue].rate_limit; |
| *wrr = tpm_db.gmac_tx[gmac_i].tx_queue[queue].wrr; |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv4_pre_filter_key_num(tpm_src_port_type_t src_port, uint32_t *num_keys) |
| { |
| /*check param*/ |
| if (num_keys == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| *num_keys = tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].num_keys; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv4_pre_filter_key(tpm_src_port_type_t src_port, |
| uint32_t key_idx, |
| tpm_parse_fields_t *parse_rule_bm, |
| tpm_ipv4_acl_key_t *ipv4_key) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| /*check param*/ |
| if (parse_rule_bm == NULL || ipv4_key == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| *parse_rule_bm = key->parse_rule_bm; |
| memcpy(ipv4_key, &key->ipv4_key, sizeof(tpm_ipv4_acl_key_t)); |
| |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_find_ipv4_pre_filter_key(tpm_src_port_type_t src_port, |
| tpm_parse_fields_t parse_rule_bm, |
| tpm_ipv4_acl_key_t *ipv4_key, |
| uint32_t *key_idx) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key; |
| uint32_t i; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[0]; |
| |
| /*check param*/ |
| if (key_idx == NULL || ipv4_key == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| for (i = 0; i < TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM; i++) { |
| if (key[i].valid == TPM_FALSE) |
| continue; |
| if (key[i].parse_rule_bm != parse_rule_bm) |
| continue; |
| if (parse_rule_bm & TPM_IPv4_PARSE_SIP) { |
| if (memcmp(ipv4_key->ipv4_src_ip_add, key[i].ipv4_key.ipv4_src_ip_add, 4 * sizeof(uint8_t)) || |
| memcmp(ipv4_key->ipv4_src_ip_add_mask, key[i].ipv4_key.ipv4_src_ip_add_mask, 4 * sizeof(uint8_t))) |
| continue; |
| } |
| if (parse_rule_bm & TPM_IPv4_PARSE_DIP) { |
| if (memcmp(ipv4_key->ipv4_dst_ip_add, key[i].ipv4_key.ipv4_dst_ip_add, 4 * sizeof(uint8_t)) || |
| memcmp(ipv4_key->ipv4_dst_ip_add_mask, key[i].ipv4_key.ipv4_dst_ip_add_mask, 4 * sizeof(uint8_t))) |
| continue; |
| } |
| if (parse_rule_bm & TPM_IPv4_PARSE_DSCP) { |
| if ((ipv4_key->ipv4_dscp & ipv4_key->ipv4_dscp_mask) != (key[i].ipv4_key.ipv4_dscp & key[i].ipv4_key.ipv4_dscp_mask)) |
| continue; |
| } |
| if (parse_rule_bm & TPM_IPv4_PARSE_PROTO) { |
| if (ipv4_key->ipv4_proto != key[i].ipv4_key.ipv4_proto) |
| continue; |
| } |
| if (parse_rule_bm & TPM_PARSE_L4_SRC) { |
| if (ipv4_key->l4_src_port != key[i].ipv4_key.l4_src_port) |
| continue; |
| } |
| if (parse_rule_bm & TPM_PARSE_L4_DST) { |
| if (ipv4_key->l4_dst_port != key[i].ipv4_key.l4_dst_port) |
| continue; |
| } |
| *key_idx = i; |
| return TPM_DB_OK; |
| } |
| |
| *key_idx = TPM_CNM_INVALID_IPV4_PRE_FILTER_KEY_ID; |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| } |
| |
| int32_t tpm_db_inc_ipv4_pre_filter_key_user_num(tpm_src_port_type_t src_port, uint32_t key_idx) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| key->num_users++; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_dec_ipv4_pre_filter_key_user_num(tpm_src_port_type_t src_port, uint32_t key_idx) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| if (key->num_users > 0) |
| key->num_users--; |
| return TPM_DB_OK; |
| } |
| |
| int32_t tpm_db_get_ipv4_pre_filter_key_user_num(tpm_src_port_type_t src_port, uint32_t key_idx, uint32_t *num_users) |
| { |
| tpm_db_cnm_ipv4_pre_filter_key_t *key = NULL; |
| |
| /*check param*/ |
| if (num_users == NULL) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| if (key_idx >= TPM_DB_CNM_MAX_IPV4_PRE_FILTER_KEY_NUM) |
| return TPM_DB_ERR_REC_INV; |
| |
| if(src_port >= TPM_MAX_NUM_UNI_PORTS) { |
| TPM_OS_ERROR(TPM_DB_MOD, "invalid input Src Port(%d)\n", src_port); |
| return TPM_DB_ERR_INV_INPUT; |
| } |
| |
| key = &tpm_db.ctc_cm_data.ipv4_pre_filter[src_port].key[key_idx]; |
| |
| if (key->valid == TPM_FALSE) |
| return TPM_DB_ERR_REC_NOT_EXIST; |
| |
| *num_users = key->num_users; |
| return TPM_DB_OK; |
| } |
| |
| |
| /******************************************************************************* |
| * tpm_db_mac_learn_mod_idx_set() |
| * |
| * DESCRIPTION: Set mac leanring pmt mod index, just for mac learning |
| * |
| * INPUTS: |
| * mod_idx |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mac_learn_mod_idx_set(uint32_t mod_idx) |
| { |
| tpm_db.mac_learn_mod_idx = mod_idx; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_mac_learn_mod_idx_get() |
| * |
| * DESCRIPTION: Get mac leanring pmt mod index, just for mac learning |
| * |
| * INPUTS: |
| * mod_idx |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_mac_learn_mod_idx_get(uint32_t *mod_idx) |
| { |
| *mod_idx = tpm_db.mac_learn_mod_idx; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ds_mac_based_trunk_enable_set() |
| * |
| * DESCRIPTION: Set ds_mac_based_trunk_enable |
| * |
| * INPUTS: |
| * enable - ds_mac_based_trunk_enable |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ds_mac_based_trunk_enable_set(tpm_db_ds_mac_based_trunk_enable_t enable) |
| { |
| tpm_db.ds_mac_based_trunk_enable = enable; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_ds_mac_based_trunk_enable_get() |
| * |
| * DESCRIPTION: Get ds_mac_based_trunk_enable |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * enable - ds_mac_based_trunk_enable |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_ds_mac_based_trunk_enable_get(tpm_db_ds_mac_based_trunk_enable_t *enable) |
| { |
| *enable = tpm_db.ds_mac_based_trunk_enable; |
| |
| return (TPM_DB_OK); |
| } |
| int32_t tpm_db_api_data_backup(void) |
| { |
| memcpy(hot_swap_bak_db.api_ent_mem_area_bak, tpm_db.api_ent_mem_area, sizeof(tpm_db.api_ent_mem_area)); |
| memcpy(hot_swap_bak_db.api_section_bak, tpm_db.api_section, sizeof(tpm_db.api_section)); |
| memcpy(hot_swap_bak_db.mc_vid_port_cfg_bak, tpm_db.mc_vid_port_cfg, sizeof(tpm_db.mc_vid_port_cfg)); |
| memcpy(hot_swap_bak_db.gmac_tx_bak, tpm_db.gmac_tx, sizeof(tpm_db.gmac_tx)); |
| memcpy(hot_swap_bak_db.igmp_proxy_sa_mac, tpm_db_mc_igmp_proxy_sa_mac, 6); |
| hot_swap_bak_db.igmp_proxy_sa_mac_valid = tpm_db_mc_igmp_proxy_sa_mac_valid; |
| hot_swap_bak_db.switch_init = tpm_db.func_profile.switch_init; |
| |
| return (TPM_DB_OK); |
| } |
| int32_t tpm_db_api_data_rcvr(void) |
| { |
| memcpy(tpm_db.mc_vid_port_cfg, hot_swap_bak_db.mc_vid_port_cfg_bak, sizeof(tpm_db.mc_vid_port_cfg)); |
| memcpy(tpm_db.gmac_tx, hot_swap_bak_db.gmac_tx_bak, sizeof(tpm_db.gmac_tx)); |
| memcpy(tpm_db_mc_igmp_proxy_sa_mac, hot_swap_bak_db.igmp_proxy_sa_mac, 6); |
| tpm_db_mc_igmp_proxy_sa_mac_valid = hot_swap_bak_db.igmp_proxy_sa_mac_valid; |
| tpm_db.func_profile.switch_init = hot_swap_bak_db.switch_init; |
| |
| return (TPM_DB_OK); |
| } |
| void tpm_db_exchange_value(uint32_t *v1, uint32_t *v2) |
| { |
| uint32_t tmp; |
| |
| tmp = *v1; |
| *v1 = *v2; |
| *v2 = tmp; |
| |
| return; |
| } |
| int32_t tpm_db_wan_lan_rate_limit_exchange_db(tpm_db_gmac_tx_t *gmac_tx) |
| { |
| int32_t queue; |
| |
| for (queue = 0; queue < TPM_MAX_NUM_TX_QUEUE; queue++) { |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].tx_queue[queue].bucket_size), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].tx_queue[queue].bucket_size)); |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].tx_queue[queue].rate_limit), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].tx_queue[queue].rate_limit)); |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].tx_queue[queue].wrr), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].tx_queue[queue].wrr)); |
| } |
| |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].bucket_size), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].bucket_size)); |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].rate_limit), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].rate_limit)); |
| tpm_db_exchange_value(&(gmac_tx[TPM_TX_MOD_GMAC0].prio), |
| &(gmac_tx[TPM_TX_MOD_GMAC1].prio)); |
| |
| return (TPM_DB_OK); |
| } |
| int32_t tpm_db_wan_lan_rate_limit_exchange(void) |
| { |
| tpm_db_wan_lan_rate_limit_exchange_db(tpm_db.gmac_tx); |
| tpm_db_wan_lan_rate_limit_exchange_db(hot_swap_bak_db.gmac_tx_bak); |
| return (TPM_DB_OK); |
| } |
| |
| int32_t tpm_db_api_section_bak_num_entries_get(tpm_api_sections_t api_section, uint32_t *num_entries) |
| { |
| if (hot_swap_bak_db.api_section_bak[api_section].valid == TPM_DB_INVALID) { |
| printk("api_section: %d is not valid\n", api_section); |
| *num_entries = 0; |
| } else |
| *num_entries = hot_swap_bak_db.api_section_bak[api_section].num_valid_entries; |
| |
| printk("api_section: %d, number_valid: %d\n", api_section, *num_entries); |
| return (TPM_DB_OK); |
| } |
| int32_t tpm_db_api_section_bak_ent_tbl_get(tpm_api_sections_t api_sec, tpm_db_api_entry_t *api_ent_mem_area, uint32_t index) |
| { |
| if (ILLEGAL_API_SEC(api_sec)) |
| IF_ERROR_I(TPM_DB_ERR_REC_NOT_EXIST, api_sec); |
| |
| if (NULL == api_ent_mem_area) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memcpy(api_ent_mem_area, |
| &hot_swap_bak_db.api_ent_mem_area_bak[(hot_swap_bak_db.api_section_bak[api_sec].table_start) + index], |
| sizeof(tpm_db_api_entry_t)); |
| |
| return (TPM_DB_OK); |
| } |
| int32_t tpm_db_api_entry_bak_get_next(tpm_api_sections_t api_section, |
| int32_t cur_rule, |
| int32_t *next_rule) |
| { |
| int32_t ind = -1; |
| int32_t i; |
| uint32_t min_rule, l_next_rule = ~0; |
| tpm_db_api_entry_t *api_tbl; |
| |
| api_tbl = &(hot_swap_bak_db.api_ent_mem_area_bak[hot_swap_bak_db.api_section_bak[api_section].table_start]); |
| |
| if (cur_rule <= -1) |
| min_rule = 0; |
| else |
| min_rule = cur_rule + 1; |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "min_rule(%d) \n", min_rule); */ |
| |
| for (i = 0; i <= hot_swap_bak_db.api_section_bak[api_section].last_valid_index; i++) { |
| if (((api_tbl + i)->valid == TPM_DB_VALID) && |
| ((api_tbl + i)->rule_num >= min_rule) && ((api_tbl + i)->rule_num < l_next_rule)) { |
| l_next_rule = (api_tbl + i)->rule_num; |
| ind = i; |
| TPM_OS_INFO(TPM_DB_MOD, "rule_num(%d), rule_idx(%d) update\n", (api_tbl + i)->rule_num, (api_tbl + i)->rule_idx); |
| } else |
| TPM_OS_INFO(TPM_DB_MOD, "rule_num(%d), rule_idx(%d) \n", (api_tbl + i)->rule_num, (api_tbl + i)->rule_idx); |
| } |
| |
| /*TPM_OS_DEBUG(TPM_DB_MOD, "l_next_rule(%d) ind(%d) \n", l_next_rule, ind); */ |
| |
| if ((l_next_rule < (uint32_t) (~0)) && (ind != -1)) { |
| *next_rule = ind; |
| } else /* Not found */ |
| *next_rule = -1; |
| |
| TPM_OS_INFO(TPM_DB_MOD, "next_rule(%d) \n", *next_rule); |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_max_uni_port_nr_get() |
| * |
| * DESCRIPTION: Get max UNI port number |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * max_uni_port_nr - max UNI port number |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_max_uni_port_nr_get(uint32_t *max_uni_port_nr) |
| { |
| *max_uni_port_nr = tpm_db.max_uni_port_nr + 1; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_uni_egr_rate_limit_set() |
| * |
| * DESCRIPTION: Set GMAC UNI egress rate limit |
| * |
| * INPUTS: |
| * port - GMAC UNI port to do rate limit |
| * rate_limit - rate limit value |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_uni_egr_rate_limit_set(tpm_src_port_type_t port, uint32_t rate_limit) |
| { |
| tpm_db.gmac_uni_egr_rate_limit[port] = rate_limit; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_uni_egr_rate_limit_get() |
| * |
| * DESCRIPTION: Get GMAC UNI egress rate limit |
| * |
| * INPUTS: |
| * port - GMAC UNI port to do rate limit |
| * OUTPUTS: |
| * rate_limit - rate limit value, if value got is 0, means no rate limit set |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_uni_egr_rate_limit_get(tpm_src_port_type_t port, uint32_t *rate_limit) |
| { |
| if (NULL == rate_limit) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| *rate_limit = tpm_db.gmac_uni_egr_rate_limit[port]; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_lpk_uni_ingr_rate_limit_set() |
| * |
| * DESCRIPTION: Set GMAC UNI ingress rate limit only with loopback mode |
| * |
| * INPUTS: |
| * port - GMAC UNI port to do rate limit |
| * rate_limit - rate limit value |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_lpk_uni_ingr_rate_limit_set(tpm_src_port_type_t port, tpm_db_gmac_lpk_uni_ingr_rate_limit_t rate_limit) |
| { |
| tpm_db.gmac_lpk_uni_ingr_rate_limit[port].count_mode = rate_limit.count_mode; |
| tpm_db.gmac_lpk_uni_ingr_rate_limit[port].cir = rate_limit.cir; |
| tpm_db.gmac_lpk_uni_ingr_rate_limit[port].cbs = rate_limit.cbs; |
| tpm_db.gmac_lpk_uni_ingr_rate_limit[port].ebs = rate_limit.ebs; |
| |
| return (TPM_DB_OK); |
| } |
| |
| /******************************************************************************* |
| * tpm_db_gmac_lpk_uni_ingr_rate_limit_get() |
| * |
| * DESCRIPTION: Get GMAC UNI ingress rate limit with loopback mode |
| * |
| * INPUTS: |
| * port - GMAC UNI port to do rate limit |
| * OUTPUTS: |
| * rate_limit - rate limit value, if value got is 0, means no rate limit set |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_gmac_lpk_uni_ingr_rate_limit_get(tpm_src_port_type_t port, tpm_db_gmac_lpk_uni_ingr_rate_limit_t *rate_limit) |
| { |
| if (NULL == rate_limit) |
| return (TPM_DB_ERR_INV_INPUT); |
| |
| memcpy(rate_limit, |
| &tpm_db.gmac_lpk_uni_ingr_rate_limit[port], |
| sizeof(tpm_db_gmac_lpk_uni_ingr_rate_limit_t)); |
| |
| return (TPM_DB_OK); |
| } |
| |
| #ifdef CONFIG_MV_INCLUDE_PON |
| static PON_SHUTDOWN_FUNC gb_pon_callback_func = NULL; |
| |
| /******************************************************************************* |
| * tpm_db_register_pon_callback() |
| * |
| * DESCRIPTION: Function used to register PON callback functions. |
| * |
| * INPUTS: |
| * pon_func: PON callback function |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * On success, the function returns TPM_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| *******************************************************************************/ |
| int32_t tpm_db_register_pon_callback(PON_SHUTDOWN_FUNC pon_func) |
| { |
| tpm_error_code_t ret_code = TPM_OK; |
| |
| gb_pon_callback_func = pon_func; |
| |
| return ret_code; |
| } |
| |
| /******************************************************************************* |
| * tpm_db_get_pon_callback() |
| * |
| * DESCRIPTION: Function used to get PON callback functions. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * pon_func: PON callback function |
| * |
| * RETURNS: |
| * On success, the function returns TPM_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| *******************************************************************************/ |
| int32_t tpm_db_get_pon_callback(PON_SHUTDOWN_FUNC *pon_func) |
| { |
| tpm_error_code_t ret_code = TPM_OK; |
| |
| *pon_func = gb_pon_callback_func; |
| |
| return ret_code; |
| } |
| #endif |
| |
| /******************************************************************************* |
| * tpm_db_init() |
| * |
| * DESCRIPTION: Perform DB Initialization. Set all structures to 0, and all valid fields to TPM_DB_INVALID |
| * |
| * INPUTS: |
| * |
| * OUTPUTS: |
| * |
| * RETURNS: |
| * On success, the function returns TPM_DB_OK. On error different types are returned |
| * according to the case - see tpm_db_err_t. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int32_t tpm_db_init(void) |
| { |
| uint32_t i, j; |
| |
| /* Erase DB */ |
| memset(&tpm_db, 0, sizeof(tpm_db_t)); |
| |
| /* Set All entries in all structures to invalid */ |
| |
| for (i = 0; i < TPM_MAX_NUM_ETH_PORTS; i++) |
| tpm_db.eth_ports[i].valid = TPM_DB_INVALID; |
| |
| /* GMAC Connect */ |
| for (i = 0; i < TPM_NUM_GMACS; i++) |
| tpm_db.gmac_port_conf[i].valid = TPM_DB_INVALID; |
| tpm_db.num_valid_tcont_llid = 0; |
| |
| /* GMAC Func. */ |
| for (i = 0; i < TPM_MAX_NUM_GMACS; i++) |
| tpm_db.gmac_func[i] = TPM_GMAC_FUNC_NONE; |
| |
| for (i = 0; i < TPM_MAX_NUM_TX_PORTS; i++) { |
| tpm_db.gmac_tx[i].valid = TPM_DB_INVALID; |
| for (j = 0; j < TPM_MAX_NUM_TX_QUEUE; j++) |
| tpm_db.gmac_tx[i].tx_queue[j].valid = TPM_DB_INVALID; |
| } |
| |
| /* IGMP */ |
| tpm_db.igmp_def.frwd_mode[TPM_SRC_PORT_WAN] = TPM_IGMP_FRWD_MODE_DROP; |
| for (i = TPM_SRC_PORT_UNI_0; i <= TPM_SRC_PORT_UNI_7; i++) |
| tpm_db.igmp_def.frwd_mode[i] = TPM_IGMP_FRWD_MODE_DROP; |
| tpm_db.igmp_def.cpu_queue = 0; |
| tpm_db.igmp_def.igmp_snoop_enable = TPM_FALSE; |
| |
| tpm_db.igmp_def.mc_lpbk_enable[TPM_IP_VER_4] = TPM_FALSE; |
| tpm_db.igmp_def.mc_lpbk_enable[TPM_IP_VER_6] = TPM_FALSE; |
| |
| /* Misc. */ |
| tpm_db.init_misc.omci_etype = TPM_DB_INVALID; |
| tpm_db.init_misc.pnc_init_debug_port = TPM_DB_INVALID; |
| tpm_db.init_misc.pon_type = TPM_DB_INVALID; |
| tpm_db.init_misc.ds_mh_set_conf = TPM_DB_INVALID; |
| tpm_db.init_misc.cfg_pnc_parse = TPM_DB_INVALID; |
| tpm_db.init_misc.cpu_loopback = TPM_DB_INVALID; |
| tpm_db.init_misc.tpm_init_succeeded = TPM_DB_INVALID; |
| tpm_db.func_profile.virt_uni_info.enabled = TPM_DB_INVALID; |
| tpm_db.func_profile.virt_uni_info.switch_port = TPM_DB_INVALID; |
| tpm_db.func_profile.virt_uni_info.uni_port = TPM_DB_INVALID; |
| |
| /* Ownership */ |
| for (i = 0; i < TPM_MAX_API_TYPES; i++) |
| tpm_db.owners[i].valid = TPM_DB_INVALID; |
| |
| /* API Ranges */ |
| for (i = 0; i < TPM_MAX_NUM_API_SECTIONS; i++) { |
| for (j = 0; j < TPM_NUM_DIRECTIONS; j++) |
| tpm_db_api_section_invalidate(i); |
| } |
| |
| /* API_Busy */ |
| tpm_db_api_busy_init(); |
| |
| /* API Entries Area, stripe whole area */ |
| tpm_db_api_entries_area_reset(); |
| |
| /* PNC Tables */ |
| for (i = 0; i < TPM_MAX_NUM_RANGES; i++) |
| tpm_db.pnc_range[i].valid = TPM_DB_INVALID; |
| |
| for (i = 0; i < TPM_PNC_SIZE; i++) |
| tpm_db.pnc_shadow[i].valid = TPM_DB_INVALID; |
| |
| /* Modification Tables */ |
| tpm_db_mod2_init(); |
| |
| /* Vlan Ethertype */ |
| for (i = 0; i < TPM_NUM_VLAN_ETYPE_REGS; i++) |
| tpm_db.vlan_etype[i].valid = TPM_DB_INVALID; |
| |
| /* Multicast Tables */ |
| tpm_db_mc_lpbk_entries_num = 0; |
| memset(tpm_db_mc_stream_table, 0, TPM_MC_MAX_STREAM_NUM * sizeof(tpm_db_mc_stream_entry_t *)); |
| memset(tpm_db_mc_mac_table, 0, TPM_MC_MAX_MAC_NUM * sizeof(tpm_db_mc_mac_entry_t *)); |
| memset(tpm_db_mc_lpbk_table, 0, TPM_MC_MAX_LPBK_ENTRIES_NUM * sizeof(tpm_db_mc_lpbk_entry_t *)); |
| memset(tpm_db_mc_vlan_xits_table, 0, TPM_MC_MAX_MVLAN_XITS_NUM * sizeof(tpm_db_mc_vlan_entry_t *)); |
| memset(tpm_db_mc_virt_uni_entry_state_table, 0, TPM_MC_MAX_STREAM_NUM * sizeof(uint8_t)); |
| tpm_db_mc_igmp_proxy_sa_mac_valid = 0; |
| memset(tpm_db_mc_igmp_proxy_sa_mac, 0, 6 * sizeof(uint8_t)); |
| |
| /* IPV6 Flow Tables */ |
| tpm_db_init_ipv6_5t_flow_reset(); |
| |
| /* CTC CnM db */ |
| tpm_db_ctc_cm_db_reset(); |
| |
| /* IPv6 MC SIP db */ |
| tpm_db_ipv6_mc_sip_db_reset(); |
| |
| return (TPM_DB_OK); |
| } |
