| /************************************************************************ |
| * Copyright (C) 2010, Marvell Technology Group Ltd. |
| * All Rights Reserved. |
| * |
| * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Marvell Technology Group; |
| * the contents of this file may not be disclosed to third parties, copied |
| * or duplicated in any form, in whole or in part, without the prior |
| * written permission of Marvell Technology Group. |
| * |
| ********************************************************************************* |
| * 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. |
| * |
| ********************************************************************************* |
| * mv_mac_learn_logic.c |
| * |
| * DESCRIPTION: |
| * |
| * |
| *******************************************************************************/ |
| #include "tpm_common.h" |
| #include "tpm_header.h" |
| #include "mvOs.h" |
| #include "mv_mac_learn_header.h" |
| |
| /************************************************************************************ |
| * mv_mac_learn_get_lu_hw() |
| * Get LU of MAC leanring PnC entry; but this function is NOT used for long time delay |
| *************************************************************************************/ |
| int32_t mv_mac_learn_get_lu_hw(uint32_t *pnc_idx) |
| { |
| uint32_t i = 0; |
| uint32_t w32,tid; |
| tpm_api_lu_conf_t lu_conf; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| if (tpm_db_pnc_get_lu_conf(TPM_PNC_MAC_LEARN, &lu_conf)) { |
| MVMACLEARN_ERR_PRINT("TPM lookup conf get failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| i = 0; |
| while (i < CONFIG_MV_PNC_TCAM_LINES) { |
| w32 = mvPncAgingLogEntryRead(lu_conf.cntr_grp, 0); |
| if ((w32 & PNC_AGING_LOG_VALID_MASK) == 0) { |
| MVMACLEARN_WARN_PRINT("LU Read ivalid\n"); |
| tid = range_conf.range_start + range_conf.api_end; |
| break; |
| } |
| mvOsDelay(20); |
| tid = w32 & PNC_AGING_LOG_CNTR_IDX_MASK; |
| if (tid >= (range_conf.range_start + range_conf.api_start) && tid <= (range_conf.range_start + range_conf.api_end)) |
| break; |
| i++; |
| |
| if(!(i%8)) |
| mvPncAgingTrigerSet(); |
| } |
| |
| if (CONFIG_MV_PNC_TCAM_LINES == i) { |
| MVMACLEARN_WARN_PRINT("LU Read failed\n"); |
| tid = range_conf.range_start + range_conf.api_end; |
| } |
| |
| *pnc_idx = tid; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /************************************************************************************ |
| * mv_mac_learn_get_lu |
| * Get LU of MAC leanring PnC entry |
| *output: |
| * pnc_idx: PNC index of LU entry |
| *return: |
| * success--MAC_LEARN_OK |
| * failed --MAC_LEARN_FAIL |
| *************************************************************************************/ |
| int32_t mv_mac_learn_get_lu(uint32_t *pnc_idx) |
| { |
| int32_t i; |
| uint32_t hit_count = 0, temp; |
| uint32_t lu_idx = 0; |
| uint32_t first_lu = 0; |
| mac_learn_db_entry_t mac_learn_db_entry; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /* If only one API entry */ |
| if (range_conf.api_start == range_conf.api_end) { |
| *pnc_idx = range_conf.range_start + range_conf.api_start; |
| return MAC_LEARN_OK; |
| } |
| |
| for (i = range_conf.range_start + range_conf.api_start; i <= range_conf.range_start + range_conf.api_end; i++) { |
| /* Static entry not be replaced */ |
| if (!mac_learn_db_entry_info_by_pncidx(i, NULL, &mac_learn_db_entry)) { |
| if (mac_learn_db_entry.state == MAC_LEARN_FDB_STATIC) |
| continue; |
| } else { |
| continue; |
| } |
| if (first_lu == 0) { |
| lu_idx = i; |
| hit_count = mvPncAgingCntrRead(lu_idx) & PNC_AGING_CNTR_MASK; |
| first_lu = 1; |
| } else { |
| temp = mvPncAgingCntrRead(i) & PNC_AGING_CNTR_MASK; |
| if (hit_count > temp) { |
| hit_count = temp; |
| lu_idx = i; |
| } |
| } |
| } |
| |
| /* All entries are static, can not replace */ |
| if (first_lu == 0) |
| return MAC_LEARN_FAIL; |
| |
| *pnc_idx = lu_idx; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /************************************************************************************ |
| * mv_mac_learn_aging |
| * MAC learning aging function for aging timer |
| *input: |
| * mac_learn_aging: pointer of global variable |
| *return: |
| * void |
| *************************************************************************************/ |
| void mv_mac_learn_aging(unsigned long mac_learn_aging) |
| { |
| uint32_t i; |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| uint32_t pnc_idx, read_count,hit_count = 0; |
| uint32_t fdb_valid_count; |
| tpm_l2_acl_key_t del_mac_key; |
| mac_learn_db_entry_t mac_learn_db_entry; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| mac_learn_t *mac_learn_age = (mac_learn_t *)mac_learn_aging; |
| |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return; |
| } |
| |
| for (i = 0; i < MAC_LEARN_FDB_MAX_COUNT; i++) { |
| if (!mac_learn_db_nonstatic_pnc_get_by_fdbidx(i, &pnc_idx, &hit_count)) { |
| if (MAC_LEARN_FDB_INVALID_PNC == pnc_idx) |
| continue; |
| /*check whether PnC hit in last 1s*/ |
| read_count = mvPncAgingCntrRead(pnc_idx); |
| if (read_count & PNC_AGING_CNTR_MASK) { |
| /*clear no hit time*/ |
| mac_learn_db_no_time_clear_update_hit(i, read_count & PNC_AGING_CNTR_MASK); |
| /*clear hit counter, avoid overflow*/ |
| mvPncAgingCntrWrite(pnc_idx, read_count & (~PNC_AGING_CNTR_MASK)); |
| } else { |
| /* Increase No hit time and read it */ |
| mac_learn_db_no_hit_time_inc_read(i, &mac_learn_db_entry); |
| if (mac_learn_db_entry.no_hit_time >= mac_learn_age->mac_learn_expire_time) { |
| memset(&del_mac_key, 0, sizeof(tpm_l2_acl_key_t)); |
| memset(del_mac_key.mac.mac_sa_mask, 0xff, sizeof(u8)*MV_MAC_ADDR_SIZE); |
| memcpy(del_mac_key.mac.mac_sa, mac_learn_db_entry.src_mac_addr, sizeof(char) * MV_MAC_ADDR_SIZE); |
| /*Get tpm del lock*/ |
| spin_lock(&mac_learn_age->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| if (!tpm_del_mac_learn_rule(tpm_owner_id, &del_mac_key)) { |
| /*release lock*/ |
| spin_unlock(&mac_learn_age->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| /*Update FDB first*/ |
| if (TPM_RANGE_TYPE_ACL == range_conf.range_type) |
| mac_learn_db_pncidx_update(0, pnc_idx); |
| if (mac_learn_db_entry_del(i)) { |
| MVMACLEARN_ERR_PRINT("MAC learn FDB del failed\n"); |
| continue; |
| } else { |
| /* dec non static entry count */ |
| mac_learn_db_nonstatic_count_dec(); |
| mac_learn_db_valid_count_get(&fdb_valid_count); |
| /* start MAC learn again */ |
| if ((mac_learn_age->mac_learn_max_count - fdb_valid_count == 1) && |
| (false == mac_learn_age->mac_learn_overwrite_enable)) { |
| /* Trap packet with new address to CPU again */ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_TRAP)) { |
| MVMACLEARN_ERR_PRINT("MAC learn default rule action set failed\n"); |
| continue; |
| } |
| } |
| } |
| } else { |
| /*release lock*/ |
| spin_unlock(&mac_learn_age->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| MVMACLEARN_ERR_PRINT("TPM MAC learn entry del failed\n"); |
| continue; |
| } |
| } |
| } |
| } |
| } |
| |
| /*Continue time*/ |
| mod_timer(&mac_learn_age->mac_learn_timer, jiffies + HZ); |
| } |
| |
| /************************************************************************************ |
| * mv_mac_learn_pnc_rule_add |
| * Function to add new MAC leanring entry automatic in system |
| *input: |
| * work: work queue the function on |
| *return: |
| * void |
| *************************************************************************************/ |
| void mv_mac_learn_pnc_rule_add(struct work_struct *work) |
| { |
| tpm_init_pnc_mac_learn_enable_t pnc_mac_learn_enable; |
| tpm_db_pnc_range_conf_t range_conf; |
| tpm_l2_acl_key_t src_mac_key, del_mac_key; |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| uint32_t valid_count, nonstatic_count; |
| mac_learn_db_entry_t mac_learn_db_entry; |
| int32_t addr_exist = 0; |
| int32_t fdb_addr_exist = 0; |
| uint32_t rule_num, pnc_idx; |
| uint32_t fdb_idx; |
| mac_learn_t *src_mac = container_of(work, mac_learn_t, mac_learn_work); |
| |
| /*check mac learn enable state*/ |
| if (false == src_mac->mac_learn_enable) |
| return; |
| |
| /* Get pnc_mac_learn_enable from TPM XML */ |
| if (tpm_db_pnc_mac_learn_enable_get(&pnc_mac_learn_enable)) |
| return; |
| if (TPM_PNC_MAC_LEARN_DISABLED == pnc_mac_learn_enable) { |
| MVMACLEARN_ERR_PRINT("TPM PNC mac learn disabled\n"); |
| return; |
| } |
| |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return; |
| } |
| |
| memset(&src_mac_key, 0, sizeof(tpm_l2_acl_key_t)); |
| memset(src_mac_key.mac.mac_sa_mask, 0xff, sizeof(u8)*MV_MAC_ADDR_SIZE); |
| memset(&mac_learn_db_entry, 0, sizeof(mac_learn_db_entry_t)); |
| /*Get source MAC address*/ |
| if (mv_mac_learn_queue_read(src_mac_key.mac.mac_sa)) |
| return; |
| |
| /* Check the src mac exist in FDB or not*/ |
| if (mac_learn_db_find_mac_addr(&src_mac_key, &fdb_addr_exist, NULL)) |
| return; |
| /* If Addr exist in FDB, return */ |
| if (fdb_addr_exist == 1) |
| return; |
| |
| /* Get valid entry count currently */ |
| if (mac_learn_db_valid_count_get(&valid_count) || mac_learn_db_nonstatic_count_get(&nonstatic_count)) { |
| MVMACLEARN_ERR_PRINT("Get valid count or nonstatic count failed\n"); |
| return; |
| } |
| |
| /* Check non-static Full or not */ |
| if (src_mac->mac_learn_max_count == nonstatic_count) { |
| if (true == src_mac->mac_learn_overwrite_enable) { |
| /* Interval less than 0.2s, overwrite is forbidden*/ |
| if (time_after(jiffies, (unsigned long)src_mac->mac_learn_overwrite_time)) |
| src_mac->mac_learn_overwrite_time = jiffies + HZ / 5;/*update overwrite time*/ |
| else |
| return;/*return from here, no any operation*/ |
| /* Overwrite LU entry */ |
| if (!mv_mac_learn_get_lu(&pnc_idx)) { |
| MVMACLEARN_DEBUG_PRINT("PnC index need to be overwritten: %d\n", pnc_idx); |
| /* Delete LU in PnC first */ |
| if (!mac_learn_db_entry_info_by_pncidx(pnc_idx, &fdb_idx, &mac_learn_db_entry)) { |
| memset(&del_mac_key, 0, sizeof(tpm_l2_acl_key_t)); |
| memset(del_mac_key.mac.mac_sa_mask, 0xff, sizeof(u8)*MV_MAC_ADDR_SIZE); |
| memcpy(del_mac_key.mac.mac_sa, mac_learn_db_entry.src_mac_addr, sizeof(char) * MV_MAC_ADDR_SIZE); |
| /*get lock*/ |
| spin_lock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| if (!tpm_del_mac_learn_rule(tpm_owner_id, &del_mac_key)) { |
| /*release lock*/ |
| spin_unlock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| /*Update FDB first*/ |
| if (TPM_RANGE_TYPE_ACL == range_conf.range_type) |
| mac_learn_db_pncidx_update(0, pnc_idx); |
| if (mac_learn_db_entry_del(fdb_idx)) { |
| MVMACLEARN_ERR_PRINT("MAC learn FDB del failed\n"); |
| return; |
| } else { |
| mac_learn_db_nonstatic_count_dec(); |
| } |
| } else { |
| /*release lock*/ |
| spin_unlock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| MVMACLEARN_ERR_PRINT("TPM MAC learn entry del failed\n"); |
| return; |
| } |
| } else { |
| MVMACLEARN_ERR_PRINT("MAC learn FDB info get failed\n"); |
| return; |
| } |
| }else { |
| MVMACLEARN_ERR_PRINT("LU MAC learn entry get failed\n"); |
| return; |
| } |
| } else { |
| /* Discarded packet with new address */ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_DROP)) { |
| MVMACLEARN_ERR_PRINT("MAC learn default rule action set failed\n"); |
| return; |
| } |
| /* Return from here */ |
| return; |
| } |
| } |
| |
| /*get lock*/ |
| spin_lock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_ADD]); |
| if (!tpm_add_mac_learn_rule(tpm_owner_id, &src_mac_key)) { |
| /*Release lock*/ |
| spin_unlock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_ADD]); |
| if (fdb_addr_exist == 0) { |
| /* Get PnC index */ |
| if (!tpm_proc_find_mac_addr_db(&src_mac_key, &addr_exist, &rule_num, &pnc_idx)) { |
| if (addr_exist) { |
| memset(&mac_learn_db_entry, 0, sizeof(mac_learn_db_entry_t)); |
| mac_learn_db_entry.valid = MAC_LEARN_FDB_VALID; |
| mac_learn_db_entry.state = MAC_LEARN_FDB_NON_STATIC; |
| mac_learn_db_entry.port = MAC_LEARN_ON_GMAC; |
| mac_learn_db_entry.pnc_idx = range_conf.range_start + range_conf.api_start + pnc_idx; |
| mac_learn_db_entry.hit_count = 0; |
| mac_learn_db_entry.no_hit_time = 0; |
| memcpy(mac_learn_db_entry.src_mac_addr, src_mac_key.mac.mac_sa, sizeof(char) * MV_MAC_ADDR_SIZE); |
| MVMACLEARN_DEBUG_PRINT("New non-static MAC learn entry adding, PnC idex: %d\n",mac_learn_db_entry.pnc_idx); |
| /*Update FDB first*/ |
| if (TPM_RANGE_TYPE_ACL == range_conf.range_type) |
| mac_learn_db_pncidx_update(1, mac_learn_db_entry.pnc_idx); |
| /* Write to FDB */ |
| if (!mac_learn_db_entry_add(&mac_learn_db_entry)) |
| mac_learn_db_nonstatic_count_inc(); |
| } |
| } |
| } |
| } else { |
| /*Release lock*/ |
| spin_unlock(&src_mac->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_ADD]); |
| } |
| } |
| |
| /************************************************************************************ |
| * mv_mac_learn_logic_static_add |
| * Function to add new MAC leanring entry mannuly in system |
| *input: |
| * static_mac_addr: source MAC address |
| *return: |
| * success--MAC_LEARN_OK |
| * failed --MAC_LEARN_FAIL |
| *************************************************************************************/ |
| int32_t mv_mac_learn_logic_static_add(char *static_mac_addr) |
| { |
| tpm_l2_acl_key_t src_mac_key; |
| mac_learn_db_entry_t mac_learn_db_entry; |
| tpm_db_pnc_range_conf_t range_conf; |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| int32_t addr_exist = 0; |
| int32_t fdb_addr_exist = 0; |
| uint32_t rule_num, pnc_idx, pnc_max_count, valid_count, non_static_count, non_static_max; |
| bool mac_learn_enable = false; |
| |
| if (mv_mac_learn_op_enable_get(&mac_learn_enable)) |
| return MAC_LEARN_FAIL; |
| if (false == mac_learn_enable) { |
| MVMACLEARN_ERR_PRINT("MAC learn disabled\n\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /*Input check*/ |
| if (NULL == static_mac_addr) { |
| MVMACLEARN_ERR_PRINT("Invalid input\n"); |
| return MAC_LEARN_FAIL; |
| } |
| MVMACLEARN_DEBUG_PRINT("MAC addr: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", static_mac_addr[0], static_mac_addr[1], static_mac_addr[2], |
| static_mac_addr[3], static_mac_addr[4], static_mac_addr[5]); |
| /*init src_mac_key*/ |
| memset(&src_mac_key, 0, sizeof(tpm_l2_acl_key_t)); |
| memset(src_mac_key.mac.mac_sa_mask, 0xff, sizeof(u8)*MV_MAC_ADDR_SIZE); |
| memcpy(src_mac_key.mac.mac_sa, static_mac_addr, sizeof(char) * MV_MAC_ADDR_SIZE); |
| |
| /* Check the src mac exist in FDB or not*/ |
| if (mac_learn_db_find_mac_addr(&src_mac_key, &fdb_addr_exist, NULL)) { |
| MVMACLEARN_ERR_PRINT("mac_learn_db_find_mac_addr failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /* If Addr exist in FDB, return OK*/ |
| if (fdb_addr_exist == 1) { |
| MVMACLEARN_WARN_PRINT("Entry already exist\n"); |
| return MAC_LEARN_OK; |
| } |
| /*Get MAC learn range info*/ |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*check whether static free entry enough or not*/ |
| pnc_max_count = range_conf.api_end - range_conf.api_start + 1; |
| if (mac_learn_db_valid_count_get(&valid_count) || |
| mac_learn_db_nonstatic_count_get(&non_static_count) || |
| mv_mac_learn_op_max_count_get(&non_static_max)) |
| return MAC_LEARN_FAIL; |
| if ((valid_count - non_static_count) >= (pnc_max_count - non_static_max)) { |
| MVMACLEARN_ERR_PRINT("No free entry for static entry\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /*Add entry through TPM API*/ |
| /*get lock*/ |
| mac_learn_tpm_api_lock_get(MAC_LEARN_TPM_API_LOCK_ADD); |
| if (!tpm_add_mac_learn_rule(tpm_owner_id, &src_mac_key)) { |
| /*release lock*/ |
| mac_learn_tpm_api_lock_release(MAC_LEARN_TPM_API_LOCK_ADD); |
| /* Get PnC index */ |
| if (!tpm_proc_find_mac_addr_db(&src_mac_key, &addr_exist, &rule_num, &pnc_idx)) { |
| /*Update FDB*/ |
| if (addr_exist) { |
| memset(&mac_learn_db_entry, 0, sizeof(mac_learn_db_entry_t)); |
| mac_learn_db_entry.valid = MAC_LEARN_FDB_VALID; |
| mac_learn_db_entry.state = MAC_LEARN_FDB_STATIC; |
| mac_learn_db_entry.port = MAC_LEARN_ON_GMAC; |
| mac_learn_db_entry.pnc_idx = range_conf.range_start + range_conf.api_start + pnc_idx; |
| mac_learn_db_entry.hit_count = 0; |
| memcpy(mac_learn_db_entry.src_mac_addr, src_mac_key.mac.mac_sa, sizeof(char) * MV_MAC_ADDR_SIZE); |
| MVMACLEARN_DEBUG_PRINT("New static MAC learn entry adding, PnC idex: %d\n",mac_learn_db_entry.pnc_idx); |
| /*Update FDB first*/ |
| if (TPM_RANGE_TYPE_ACL == range_conf.range_type) |
| mac_learn_db_pncidx_update(1, mac_learn_db_entry.pnc_idx); |
| /* Write to FDB */ |
| if (mac_learn_db_entry_add(&mac_learn_db_entry)) { |
| MVMACLEARN_ERR_PRINT("mac_learn_db_entry_add failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } |
| } else { |
| MVMACLEARN_ERR_PRINT("tpm_proc_find_mac_addr_db failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| return MAC_LEARN_OK; |
| } else { |
| /*release lock*/ |
| mac_learn_tpm_api_lock_release(MAC_LEARN_TPM_API_LOCK_ADD); |
| MVMACLEARN_ERR_PRINT("tpm_add_mac_learn_rule failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } |
| |
| /************************************************************************************ |
| * mv_mac_learn_logic_static_add |
| * Function to delete a MAC leanring entry mannuly in system |
| *input: |
| * static_mac_addr: source MAC address |
| *return: |
| * success--MAC_LEARN_OK |
| * failed --MAC_LEARN_FAIL |
| *************************************************************************************/ |
| int32_t mv_mac_learn_logic_static_del(char *static_mac_addr) |
| { |
| tpm_l2_acl_key_t del_mac_key; |
| tpm_db_pnc_range_conf_t range_conf; |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| int32_t addr_exist = 0; |
| int32_t fdb_addr_exist = 1; |
| uint32_t rule_num, pnc_idx; |
| uint32_t fdb_idx; |
| bool mac_learn_enable = false; |
| mac_learn_db_entry_t mac_learn_db_entry_info; |
| |
| if (mv_mac_learn_op_enable_get(&mac_learn_enable)) |
| return MAC_LEARN_FAIL; |
| if (false == mac_learn_enable) { |
| MVMACLEARN_ERR_PRINT("MAC learn disabled\n\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /*Input check*/ |
| if (NULL == static_mac_addr) { |
| MVMACLEARN_ERR_PRINT("Invalid input\n"); |
| return MAC_LEARN_FAIL; |
| } |
| MVMACLEARN_DEBUG_PRINT("MAC addr: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", static_mac_addr[0], static_mac_addr[1], static_mac_addr[2], |
| static_mac_addr[3], static_mac_addr[4], static_mac_addr[5]); |
| /*init src_mac_key*/ |
| memset(&del_mac_key, 0, sizeof(tpm_l2_acl_key_t)); |
| memset(del_mac_key.mac.mac_sa_mask, 0xff, sizeof(u8)*MV_MAC_ADDR_SIZE); |
| memcpy(del_mac_key.mac.mac_sa, static_mac_addr, sizeof(char) * MV_MAC_ADDR_SIZE); |
| |
| /* Check the src mac exist in FDB or not*/ |
| if (mac_learn_db_find_mac_addr(&del_mac_key, &fdb_addr_exist, &mac_learn_db_entry_info)) { |
| MVMACLEARN_ERR_PRINT("mac_learn_db_find_mac_addr failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /* If Addr non-exist in FDB, return OK*/ |
| if (fdb_addr_exist == 0) { |
| MVMACLEARN_ERR_PRINT("Entry non-exist\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /* If exist, check it is static mac or non-static, only static mac allow to del with API */ |
| if (mac_learn_db_entry_info.state == MAC_LEARN_FDB_NON_STATIC) { |
| MVMACLEARN_ERR_PRINT("Non-static MAC, not allowed to del with static API\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| if (tpm_db_pnc_rng_conf_get(TPM_PNC_MAC_LEARN, &range_conf)){ |
| MVMACLEARN_ERR_PRINT("TPM PnC range info get failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /* Get PnC index */ |
| if (!tpm_proc_find_mac_addr_db(&del_mac_key, &addr_exist, &rule_num, &pnc_idx)) { |
| if (addr_exist == 0) { |
| MVMACLEARN_ERR_PRINT("TPM DB inconsistent with MAC learn FDB\n"); |
| return MAC_LEARN_FAIL; |
| } |
| pnc_idx = range_conf.range_start + range_conf.api_start + pnc_idx; |
| MVMACLEARN_DEBUG_PRINT("PnC index: %d\n", pnc_idx); |
| /*Get FDB entry by PnCidx*/ |
| if (!mac_learn_db_entry_info_by_pncidx(pnc_idx, &fdb_idx, NULL)) { |
| MVMACLEARN_DEBUG_PRINT("FDB index: %d\n", fdb_idx); |
| /*get lock*/ |
| mac_learn_tpm_api_lock_get(MAC_LEARN_TPM_API_LOCK_DEL); |
| if (!tpm_del_mac_learn_rule(tpm_owner_id, &del_mac_key)) { |
| /*release lock*/ |
| mac_learn_tpm_api_lock_release(MAC_LEARN_TPM_API_LOCK_DEL); |
| /*Update FDB first*/ |
| if (TPM_RANGE_TYPE_ACL == range_conf.range_type) |
| mac_learn_db_pncidx_update(0, pnc_idx); |
| if (mac_learn_db_entry_del(fdb_idx)) { |
| MVMACLEARN_ERR_PRINT("MAC learn FDB del failed\n"); |
| return MAC_LEARN_FAIL; |
| } else { |
| /*start learn again, if fdb full, maybe learn is disabled*/ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_TRAP)) { |
| MVMACLEARN_ERR_PRINT("MAC learn default rule action set failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } |
| } else { |
| /*release lock*/ |
| mac_learn_tpm_api_lock_release(MAC_LEARN_TPM_API_LOCK_DEL); |
| MVMACLEARN_ERR_PRINT("tpm_del_mac_learn_rule failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } else { |
| MVMACLEARN_ERR_PRINT("mac_learn_db_entry_info_by_pncidx failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*del success*/ |
| return MAC_LEARN_OK; |
| } else { |
| MVMACLEARN_ERR_PRINT("tpm_proc_find_mac_addr_db failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } |
