| /******************************************************************************* |
| * 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. |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| ** FILE : mv_mac_learn_mod.c ** |
| ** ** |
| ** DESCRIPTION : This file implements MAC learn module init ** |
| ******************************************************************************* |
| * * |
| * MODIFICATION HISTORY: * |
| * * |
| * 12June2012 Evan Wang created * |
| * =========================================================================== * |
| ******************************************************************************/ |
| #include "tpm_common.h" |
| #include "tpm_header.h" |
| |
| #include "mv_mac_learn_header.h" |
| |
| /* Global variable */ |
| mac_learn_t mc_mac_learn; |
| uint32_t mac_learn_glob_trace = 0; |
| |
| /******************************************************************************* |
| * mac_learn_queue_work_insert() |
| * |
| * DESCRIPTION: Insert a work into work queue for mac learning. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * void |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mac_learn_queue_work_insert(void) |
| { |
| if (true == mc_mac_learn.queue_init) |
| return queue_work(mc_mac_learn.mac_learn_queue, &mc_mac_learn.mac_learn_work); |
| return 0; |
| } |
| |
| /******************************************************************************* |
| * mac_learn_tpm_api_lock_get() |
| * |
| * DESCRIPTION: Get spin lock for tpm api. |
| * |
| * INPUTS: |
| * lock_type: TPM api, add or del |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * void |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| void mac_learn_tpm_api_lock_get(mac_learn_tpm_lock_t lock_type) |
| { |
| /*get lock*/ |
| spin_lock(&mc_mac_learn.tpm_api_lock[lock_type]); |
| } |
| |
| /******************************************************************************* |
| * mac_learn_tpm_api_lock_release() |
| * |
| * DESCRIPTION: Release spin lock for tpm api. |
| * |
| * INPUTS: |
| * lock_type: TPM api, add or del |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * void |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| void mac_learn_tpm_api_lock_release(mac_learn_tpm_lock_t lock_type) |
| { |
| /*release lock*/ |
| spin_unlock(&mc_mac_learn.tpm_api_lock[lock_type]); |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_queue_write() |
| * |
| * DESCRIPTION: Write the mac address to learn into buffer queue. |
| * |
| * INPUTS: |
| * src_mac: pointer to mac address to learn |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * failed --MAC_LEARN_FAIL |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_queue_write(char *src_mac) |
| { |
| uint32_t i; |
| |
| if (down_trylock(&mc_mac_learn.sc_mac_queue.queue_sem)) |
| return MAC_LEARN_FAIL; |
| |
| for (i = 0; i < MAC_LEARN_QUEUE_SIZE; i ++) { |
| if (!memcmp(mc_mac_learn.sc_mac_queue.mc_src_mac[i].mac_addr_entry, src_mac, MV_MAC_ADDR_SIZE)) { |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| return MAC_LEARN_FAIL; |
| } |
| } |
| |
| if (mc_mac_learn.sc_mac_queue.queue_full) { |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| return MAC_LEARN_FAIL; |
| } |
| |
| memcpy(mc_mac_learn.sc_mac_queue.mc_src_mac[mc_mac_learn.sc_mac_queue.wr_idx].mac_addr_entry, |
| src_mac, sizeof(char) * MV_MAC_ADDR_SIZE); |
| |
| /* insert work queue, if failed remove MAC from cycle buffer */ |
| if (1 != mac_learn_queue_work_insert()) { |
| memset(mc_mac_learn.sc_mac_queue.mc_src_mac[mc_mac_learn.sc_mac_queue.wr_idx].mac_addr_entry, 0, |
| sizeof(char) * MV_MAC_ADDR_SIZE); |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| return MAC_LEARN_FAIL; |
| } |
| |
| mc_mac_learn.sc_mac_queue.wr_idx++; |
| if (mc_mac_learn.sc_mac_queue.wr_idx == MAC_LEARN_QUEUE_SIZE) |
| mc_mac_learn.sc_mac_queue.wr_idx = 0; |
| if (mc_mac_learn.sc_mac_queue.wr_idx == mc_mac_learn.sc_mac_queue.rd_idx) |
| mc_mac_learn.sc_mac_queue.queue_full = true; |
| |
| if (mc_mac_learn.sc_mac_queue.queue_empty) |
| mc_mac_learn.sc_mac_queue.queue_empty = false; |
| |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_queue_read() |
| * |
| * DESCRIPTION: Read the mac address to learn in buffer queue. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * src_mac: pointer to mac address to learn |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * failed --MAC_LEARN_FAIL |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_queue_read(char *src_mac) |
| { |
| if (down_interruptible(&mc_mac_learn.sc_mac_queue.queue_sem)) |
| return MAC_LEARN_FAIL; |
| |
| if (mc_mac_learn.sc_mac_queue.queue_empty) { |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| return MAC_LEARN_FAIL; |
| } |
| |
| memcpy(src_mac, mc_mac_learn.sc_mac_queue.mc_src_mac[mc_mac_learn.sc_mac_queue.rd_idx].mac_addr_entry, |
| sizeof(char) * MV_MAC_ADDR_SIZE); |
| memset(mc_mac_learn.sc_mac_queue.mc_src_mac[mc_mac_learn.sc_mac_queue.rd_idx].mac_addr_entry, 0, |
| sizeof(char) * MV_MAC_ADDR_SIZE); |
| mc_mac_learn.sc_mac_queue.rd_idx++; |
| if (mc_mac_learn.sc_mac_queue.rd_idx == MAC_LEARN_QUEUE_SIZE) |
| mc_mac_learn.sc_mac_queue.rd_idx = 0; |
| if (mc_mac_learn.sc_mac_queue.wr_idx == mc_mac_learn.sc_mac_queue.rd_idx) |
| mc_mac_learn.sc_mac_queue.queue_empty = true; |
| |
| if (mc_mac_learn.sc_mac_queue.queue_full) |
| mc_mac_learn.sc_mac_queue.queue_full = false; |
| |
| up(&mc_mac_learn.sc_mac_queue.queue_sem); |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_enable_set() |
| * |
| * DESCRIPTION: Set the enable state of mac learning. |
| * |
| * INPUTS: |
| * mac_learn_enable: enable state |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_enable_set(bool mac_learn_enable) |
| { |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| tpm_db_pnc_range_conf_t range_conf; |
| tpm_init_pnc_mac_learn_enable_t pnc_mac_learn_enable; |
| tpm_gmacs_enum_t lpk_gmac; |
| uint32_t data_queue, mac_larn_queue; |
| uint32_t lpk_gmac_mh_en; |
| |
| /*check original value and new value, if equal, return OK*/ |
| if (mac_learn_enable == mc_mac_learn.mac_learn_enable) |
| return MAC_LEARN_OK; |
| |
| if (true == mac_learn_enable) { |
| /*check TPM init succeed or not, before enable MAC learning*/ |
| if (!tpm_db_init_done_get()) { |
| MVMACLEARN_ERR_PRINT("TPM initialization not success\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*check TPM XML pnc_mac_learn_enable*/ |
| tpm_db_pnc_mac_learn_enable_get(&pnc_mac_learn_enable); |
| if (TPM_PNC_MAC_LEARN_DISABLED == pnc_mac_learn_enable) { |
| MVMACLEARN_ERR_PRINT("TPM XML para pnc_mac_learn_enable not enabled\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*Set MAX count to min(range_size, FDB_max_count)*/ |
| 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 (range_conf.api_end - range_conf.api_start + 1 > MAC_LEARN_FDB_MAX_COUNT) |
| mc_mac_learn.mac_learn_max_count = MAC_LEARN_FDB_MAX_COUNT / 2; |
| else |
| mc_mac_learn.mac_learn_max_count = (range_conf.api_end - range_conf.api_start + 1) / 2; |
| MVMACLEARN_DEBUG_PRINT("non-static entry max count: %d\n",mc_mac_learn.mac_learn_max_count); |
| |
| /* set PMT entry for MH modification on GMAC1 */ |
| /*check data queue and mac learn queue, if equal, return error*/ |
| if (TPM_DB_OK != tpm_db_gmac_lpk_queue_get(&lpk_gmac, |
| &data_queue, |
| TPM_GMAC1_QUEUE_DATA_TRAFFIC)) { |
| MVMACLEARN_ERR_PRINT("loopback gmac data queue get failed \n"); |
| return MAC_LEARN_FAIL; |
| } |
| if (TPM_DB_OK != tpm_db_gmac_lpk_queue_get(&lpk_gmac, |
| &mac_larn_queue, |
| TPM_GMAC1_QUEUE_MAC_LEARN_TRAFFIC)) { |
| MVMACLEARN_ERR_PRINT("loopback gmac mac learn queue get failed \n"); |
| return MAC_LEARN_FAIL; |
| } |
| if (data_queue == mac_larn_queue) { |
| MVMACLEARN_ERR_PRINT("loopback gmac Tx queue %d for data traffix and MAC learn equal\n", |
| data_queue); |
| return MAC_LEARN_FAIL; |
| } |
| MVMACLEARN_DEBUG_PRINT("lpk gmac %d Tx queue for mac learn: %d\n", lpk_gmac, mac_larn_queue); |
| |
| /* limit band width on Tx mac learn queue of lpk gmac */ |
| if (mvNetaTxqBurstSet((int)lpk_gmac, 0, mac_larn_queue, MAC_LEARN_BUCKET_SIZE) || |
| mvNetaTxqRateSet((int)lpk_gmac, 0, mac_larn_queue, MAC_LEARN_RATE_LIMIT)) { |
| MVMACLEARN_ERR_PRINT("MAC learning CPU rate limit on queue %d failed\n", mac_larn_queue); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /* Check MH on lpk gmac */ |
| if (tpm_db_gmac_mh_en_conf_get(lpk_gmac, &lpk_gmac_mh_en)) { |
| MVMACLEARN_ERR_PRINT("Marvell Header enable info get failed on GMAC%d\n", lpk_gmac); |
| return MAC_LEARN_FAIL; |
| } |
| if (!lpk_gmac_mh_en) { |
| MVMACLEARN_ERR_PRINT("Marvell Header is not enabled on GMAC%d\n", lpk_gmac); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /* Trap packet to CPU */ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_TRAP)) { |
| MVMACLEARN_ERR_PRINT("TPM default rule action set failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*Add timer*/ |
| add_timer(&mc_mac_learn.mac_learn_timer); |
| } else { |
| /*delete timer*/ |
| del_timer(&mc_mac_learn.mac_learn_timer); |
| /*Forward packet to GMAC1*/ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_CONTINUE)) { |
| MVMACLEARN_ERR_PRINT("TPM default rule action set failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*Reset FDB and delete PNC rule*/ |
| if (mac_learn_db_reset()) { |
| MVMACLEARN_ERR_PRINT("FDB reset failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } |
| |
| mc_mac_learn.mac_learn_enable = mac_learn_enable; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_enable_get() |
| * |
| * DESCRIPTION: Get the enable state of mac learning. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * mac_learn_enable: enable state |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_enable_get(bool *mac_learn_enable) |
| { |
| *mac_learn_enable = mc_mac_learn.mac_learn_enable; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_overwrite_set() |
| * |
| * DESCRIPTION: Set the enable state of overwrite if non-static up to max. |
| * |
| * INPUTS: |
| * overwrite_enable: enable state |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_overwrite_set(bool overwrite_enable) |
| { |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| |
| if ((true == overwrite_enable) && true == (mc_mac_learn.mac_learn_enable)) { |
| /* Trap packet to CPU when enable overwrite */ |
| 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; |
| } |
| } |
| mc_mac_learn.mac_learn_overwrite_enable = overwrite_enable; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_overwrite_get() |
| * |
| * DESCRIPTION: Get the enable state of overwrite if non-static up to max. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * overwrite_enable: enable state |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_overwrite_get(bool *overwrite_enable) |
| { |
| *overwrite_enable = mc_mac_learn.mac_learn_overwrite_enable; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_max_count_set() |
| * |
| * DESCRIPTION: Set the max count of non-static entry. |
| * |
| * INPUTS: |
| * mac_learn_max_count: max count |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_max_count_set(uint32_t mac_learn_max_count) |
| { |
| const uint32_t tpm_owner_id = TPM_MOD_OWNER_TPM; |
| uint32_t non_static_count, valid_count, pnc_count; |
| tpm_db_pnc_range_conf_t range_conf; |
| |
| if (true == mc_mac_learn.mac_learn_enable) { |
| MVMACLEARN_DEBUG_PRINT("Old max count: %d, New max count: %d\n", mc_mac_learn.mac_learn_max_count, mac_learn_max_count); |
| if (mac_learn_max_count < mc_mac_learn.mac_learn_max_count) { |
| if (!mac_learn_db_nonstatic_count_get(&non_static_count)) { |
| MVMACLEARN_DEBUG_PRINT("Current non-static num: %d\n", non_static_count); |
| if (mac_learn_max_count < non_static_count) { |
| /*delete timer*/ |
| del_timer(&mc_mac_learn.mac_learn_timer); |
| /*Clear non-static in FDB and delete PNC rule*/ |
| mc_mac_learn.mac_learn_enable = false; |
| if (mac_learn_db_nonstatic_clear()) { |
| mc_mac_learn.mac_learn_enable = true; |
| /*add timer*/ |
| add_timer(&mc_mac_learn.mac_learn_timer); |
| MVMACLEARN_ERR_PRINT("FDB non-static entry clear failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| mc_mac_learn.mac_learn_max_count = mac_learn_max_count; |
| mc_mac_learn.mac_learn_enable = true; |
| /*add timer*/ |
| add_timer(&mc_mac_learn.mac_learn_timer); |
| } else |
| mc_mac_learn.mac_learn_max_count = mac_learn_max_count; |
| } else { |
| return MAC_LEARN_FAIL; |
| } |
| } else { |
| /* Get available PNC number */ |
| 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; |
| } |
| pnc_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)) |
| return MAC_LEARN_FAIL; |
| if (mac_learn_max_count > (pnc_count - (valid_count - non_static_count))) { |
| MVMACLEARN_ERR_PRINT("Non enough free entry left\n"); |
| return MAC_LEARN_FAIL; |
| } |
| mc_mac_learn.mac_learn_max_count = mac_learn_max_count; |
| } |
| /*Trap packet to CPU*/ |
| if (tpm_mac_learn_default_rule_act_set(tpm_owner_id, TPM_UNK_MAC_TRAP)) { |
| MVMACLEARN_ERR_PRINT("TPM default rule action set failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| } else { |
| mc_mac_learn.mac_learn_max_count = mac_learn_max_count; |
| } |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_max_count_get() |
| * |
| * DESCRIPTION: Get the max count of non-static entry. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * mac_learn_max_count: max count |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_max_count_get(uint32_t *mac_learn_max_count) |
| { |
| *mac_learn_max_count = mc_mac_learn.mac_learn_max_count; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_expire_set() |
| * |
| * DESCRIPTION: Set the non-static entry expired time. |
| * |
| * INPUTS: |
| * mac_learn_expire_time: expired time (s) |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_expire_set(uint32_t mac_learn_expire_time) |
| { |
| /*Set new expired time*/ |
| mc_mac_learn.mac_learn_expire_time = mac_learn_expire_time; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_expire_get() |
| * |
| * DESCRIPTION: Get the non-static entry expired time. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * mac_learn_expire_time: expired time (s) |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_expire_get(uint32_t *mac_learn_expire_time) |
| { |
| *mac_learn_expire_time = mc_mac_learn.mac_learn_expire_time; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_op_trace_level_set() |
| * |
| * DESCRIPTION: Set the trace level for print info. |
| * |
| * INPUTS: |
| * trace_level: trace level for print info |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * success--MAC_LEARN_OK |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_op_trace_level_set(uint32_t trace_level) |
| { |
| /*Set trace level*/ |
| mac_learn_glob_trace = trace_level; |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_var_init() |
| * |
| * DESCRIPTION: Init variable mac_learn_t *mc_mac_learn. |
| * |
| * INPUTS: |
| * mc_mac_learn Variable to init |
| * aging_func Function pointer for aging of non-static MAC learning entry |
| * queue_work_func Function pointer for work queue, used to receive packet to CPU |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * Init success--MAC_LEARN_OK |
| * Init failed --MAC_LEARN_FAIL |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| int mv_mac_learn_var_init(mac_learn_t *mc_mac_learn, void (*aging_func)(unsigned long mac_learn_aging), void (*queue_work_func)(struct work_struct *work)) |
| { |
| /* Input Check */ |
| if (NULL == mc_mac_learn || NULL == aging_func) { |
| MVMACLEARN_ERR_PRINT("Invalid input, pointer NULL\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| /* Default init to disable mac learning */ |
| mc_mac_learn->mac_learn_enable = false; |
| /* Default init to disable overwrite action after full */ |
| mc_mac_learn->mac_learn_overwrite_enable = false; |
| /* Max count set to API range size */ |
| mc_mac_learn->mac_learn_max_count = MAC_LEARN_NON_STATIC_DEFAULT; |
| /* Default expired time set to 300s*/ |
| mc_mac_learn->mac_learn_expire_time = MAC_LEARN_EX_TIME_DEFAULT; |
| /* Init source MAC queue */ |
| memset(mc_mac_learn->sc_mac_queue.mc_src_mac, 0, sizeof(src_mac_addr_t)*MAC_LEARN_QUEUE_SIZE); |
| mc_mac_learn->sc_mac_queue.rd_idx = 0; |
| mc_mac_learn->sc_mac_queue.wr_idx = 0; |
| mc_mac_learn->sc_mac_queue.queue_empty = true; |
| mc_mac_learn->sc_mac_queue.queue_full = false; |
| init_MUTEX(&mc_mac_learn->sc_mac_queue.queue_sem); |
| /* Init timer for aging */ |
| init_timer(&mc_mac_learn->mac_learn_timer); |
| mc_mac_learn->mac_learn_timer.function = aging_func; |
| mc_mac_learn->mac_learn_timer.data = (unsigned long)mc_mac_learn; |
| mc_mac_learn->mac_learn_timer.expires = jiffies + HZ; |
| /*Init overwrite time*/ |
| mc_mac_learn->mac_learn_overwrite_time = jiffies; |
| /* Init work queue for PnC rule adding */ |
| mc_mac_learn->mac_learn_queue = create_workqueue("mac_work_queue"); |
| INIT_WORK(&mc_mac_learn->mac_learn_work, queue_work_func); |
| mc_mac_learn->queue_init = true; |
| |
| /*Init tpm api spin lock*/ |
| spin_lock_init(&mc_mac_learn->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_ADD]); |
| spin_lock_init(&mc_mac_learn->tpm_api_lock[MAC_LEARN_TPM_API_LOCK_DEL]); |
| |
| /* Debug Info */ |
| MVMACLEARN_DEBUG_PRINT("MAC learn default init: enable = %d, mac_learn_max_count = %d, mac_learn_expire_time = %d\n", |
| mc_mac_learn->mac_learn_enable, mc_mac_learn->mac_learn_max_count, mc_mac_learn->mac_learn_expire_time); |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_module_exit() |
| * |
| * DESCRIPTION: Finish all initialization for module insmod. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * Init success--MAC_LEARN_OK |
| * Init failed --MAC_LEARN_FAIL |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| static int __init mv_mac_learn_module_init(void) |
| { |
| /* Init Global Valriable */ |
| if (mv_mac_learn_var_init(&mc_mac_learn, mv_mac_learn_aging, mv_mac_learn_pnc_rule_add)) { |
| MVMACLEARN_ERR_PRINT("MAC learn global variable init failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /* Init FDB */ |
| if (mac_learn_fdb_init()) { |
| MVMACLEARN_ERR_PRINT("MAC learn global variable init failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /* Init Netdev */ |
| if (mv_mac_learn_netdev_init()) { |
| MVMACLEARN_ERR_PRINT("MAC learn netdev init failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| /*Init sysfs*/ |
| if(mv_mac_learn_sysfs_init()) { |
| MVMACLEARN_ERR_PRINT("MAC learn sysfs init failed\n"); |
| return MAC_LEARN_FAIL; |
| } |
| |
| return MAC_LEARN_OK; |
| } |
| |
| /******************************************************************************* |
| * mv_mac_learn_module_exit() |
| * |
| * DESCRIPTION: Release related resources when module del. |
| * |
| * INPUTS: |
| * None |
| * |
| * OUTPUTS: |
| * None |
| * |
| * RETURNS: |
| * void |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| static void __exit mv_mac_learn_module_exit(void) |
| { |
| /*release sysfs*/ |
| mv_mac_learn_sysfs_exit(); |
| } |
| |
| device_initcall_sync(mv_mac_learn_module_init); |
| |
| module_exit(mv_mac_learn_module_exit); |
| |
| MODULE_AUTHOR("Evan Wang"); |
| MODULE_DESCRIPTION("MAC learn module for Media Convert"); |
| MODULE_LICENSE("GPL"); |