| /* |
| * Copyright (c) 2012, 2015-2018, The Linux Foundation. All rights reserved. |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all copies. |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| |
| /** |
| * @defgroup fal_fdb FAL_FDB |
| * @{ |
| */ |
| #include "sw.h" |
| #include "fal_fdb.h" |
| #include "hsl_api.h" |
| #include "adpt.h" |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_entry_add(a_uint32_t dev_id, const fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_add) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_add(dev_id, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_add) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_add(dev_id, entry); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_entry_flush(a_uint32_t dev_id, a_uint32_t flag) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_del_all) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_del_all(dev_id, flag); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_del_all) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_del_all(dev_id, flag); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_entry_del_byport(a_uint32_t dev_id, fal_port_t port_id, a_uint32_t flag) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_del_by_port) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_del_by_port(dev_id, port_id, flag); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_del_by_port) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_del_by_port(dev_id, port_id, flag); |
| return rv; |
| } |
| |
| |
| static sw_error_t |
| _fal_fdb_entry_del_bymac(a_uint32_t dev_id, const fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_del_by_mac) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_del_by_mac(dev_id, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_del_by_mac) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_del_by_mac(dev_id, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_entry_getfirst(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_first) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_first(dev_id, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_first) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_first(dev_id, entry); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_entry_getnext(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_next) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_next(dev_id, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_next) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_next(dev_id, entry); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_entry_search(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_find) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_find(dev_id, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_find) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_find(dev_id, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_port_learn_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_port_learn_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_port_learn_set(dev_id, port_id, enable); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_learn_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_learn_set(dev_id, port_id, enable); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_port_learn_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t * enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_port_learn_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_port_learn_get(dev_id, port_id, enable); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_learn_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_learn_get(dev_id, port_id, enable); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_port_learning_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable, fal_fwd_cmd_t cmd) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_newaddr_lrn_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_newaddr_lrn_set(dev_id, port_id, enable, cmd); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_port_learning_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable, fal_fwd_cmd_t *cmd) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_newaddr_lrn_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_newaddr_lrn_get(dev_id, port_id, enable, cmd); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_port_stamove_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable, fal_fwd_cmd_t cmd) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_stamove_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_stamove_set(dev_id, port_id, enable, cmd); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_port_stamove_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable, fal_fwd_cmd_t *cmd) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_stamove_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_stamove_get(dev_id, port_id, enable, cmd); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_aging_ctrl_set(a_uint32_t dev_id, a_bool_t enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_age_ctrl_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_age_ctrl_set(dev_id, enable); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->age_ctrl_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->age_ctrl_set(dev_id, enable); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_aging_ctrl_get(a_uint32_t dev_id, a_bool_t * enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_age_ctrl_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_age_ctrl_get(dev_id, enable); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->age_ctrl_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->age_ctrl_get(dev_id, enable); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_vlan_ivl_svl_set(a_uint32_t dev_id, fal_fdb_smode smode) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->vlan_ivl_svl_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->vlan_ivl_svl_set(dev_id, smode); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_vlan_ivl_svl_get(a_uint32_t dev_id, fal_fdb_smode* smode) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->vlan_ivl_svl_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->vlan_ivl_svl_get(dev_id, smode); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_aging_time_set(a_uint32_t dev_id, a_uint32_t * time) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_age_time_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_age_time_set(dev_id, time); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->age_time_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->age_time_set(dev_id, time); |
| return rv; |
| } |
| |
| |
| static sw_error_t |
| _fal_fdb_aging_time_get(a_uint32_t dev_id, a_uint32_t * time) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_age_time_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_age_time_get(dev_id, time); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->age_time_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->age_time_get(dev_id, time); |
| return rv; |
| } |
| #endif |
| |
| static sw_error_t |
| _fal_fdb_entry_getnext_byindex(a_uint32_t dev_id, a_uint32_t * iterator, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_iterate) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_iterate(dev_id, iterator, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_iterate) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_iterate(dev_id, iterator, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_entry_extend_getnext(a_uint32_t dev_id, fal_fdb_op_t * option, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_extend_next) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_extend_next(dev_id, option, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_extend_next) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_extend_next(dev_id, option, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_entry_extend_getfirst(a_uint32_t dev_id, fal_fdb_op_t * option, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_extend_first) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_extend_first(dev_id, option, entry); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_extend_first) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_extend_first(dev_id, option, entry); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| static sw_error_t |
| _fal_fdb_entry_update_byport(a_uint32_t dev_id, fal_port_t old_port, fal_port_t new_port, |
| a_uint32_t fid, fal_fdb_op_t * option) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_transfer) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_transfer(dev_id, old_port, new_port, fid, option); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_transfer) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_transfer(dev_id, old_port, new_port, fid, option); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_port_fdb_learn_limit_set(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t enable, a_uint32_t cnt) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_port_fdb_learn_limit_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_port_fdb_learn_limit_set(dev_id, port_id, enable, cnt); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_fdb_learn_limit_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_fdb_learn_limit_set(dev_id, port_id, enable, cnt); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_port_fdb_learn_limit_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t * enable, a_uint32_t * cnt) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_port_fdb_learn_limit_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_port_fdb_learn_limit_get(dev_id, port_id, enable, cnt); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_fdb_learn_limit_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_fdb_learn_limit_get(dev_id, port_id, enable, cnt); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_port_fdb_learn_exceed_cmd_set(a_uint32_t dev_id, fal_port_t port_id, |
| fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_port_fdb_learn_exceed_cmd_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_port_fdb_learn_exceed_cmd_set(dev_id, port_id, cmd); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_fdb_learn_exceed_cmd_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_fdb_learn_exceed_cmd_set(dev_id, port_id, cmd); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_port_fdb_learn_exceed_cmd_get(a_uint32_t dev_id, fal_port_t port_id, |
| fal_fwd_cmd_t * cmd) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_port_fdb_learn_exceed_cmd_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_port_fdb_learn_exceed_cmd_get(dev_id, port_id, cmd); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->port_fdb_learn_exceed_cmd_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->port_fdb_learn_exceed_cmd_get(dev_id, port_id, cmd); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_learn_limit_set(a_uint32_t dev_id, a_bool_t enable, a_uint32_t cnt) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_learn_limit_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_learn_limit_set(dev_id, enable, cnt); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_learn_limit_get(a_uint32_t dev_id, a_bool_t * enable, a_uint32_t * cnt) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_learn_limit_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_learn_limit_get(dev_id, enable, cnt); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_learn_exceed_cmd_set(a_uint32_t dev_id, fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_learn_exceed_cmd_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_learn_exceed_cmd_set(dev_id, cmd); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_learn_exceed_cmd_get(a_uint32_t dev_id, fal_fwd_cmd_t * cmd) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_learn_exceed_cmd_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_learn_exceed_cmd_get(dev_id, cmd); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_resv_add(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_resv_add) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_resv_add(dev_id, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_resv_del(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_resv_del) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_resv_del(dev_id, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_resv_find(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_resv_find) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_resv_find(dev_id, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_resv_iterate(a_uint32_t dev_id, a_uint32_t * iterator, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_resv_iterate) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_resv_iterate(dev_id, iterator, entry); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_port_learn_static_set(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_port_learn_static_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_port_learn_static_set(dev_id, port_id, enable); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_port_learn_static_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t * enable) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_port_learn_static_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_port_learn_static_get(dev_id, port_id, enable); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_port_add(a_uint32_t dev_id, a_uint32_t fid, fal_mac_addr_t * addr, fal_port_t port_id) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_port_add) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_port_add(dev_id, fid, addr, port_id); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_port_add) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_port_add(dev_id, fid, addr, port_id); |
| return rv; |
| } |
| |
| static sw_error_t |
| _fal_fdb_port_del(a_uint32_t dev_id, a_uint32_t fid, fal_mac_addr_t * addr, fal_port_t port_id) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| adpt_api_t *p_adpt_api; |
| |
| if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) { |
| if (NULL == p_adpt_api->adpt_fdb_port_del) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_adpt_api->adpt_fdb_port_del(dev_id, fid, addr, port_id); |
| return rv; |
| } |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_port_del) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_port_del(dev_id, fid, addr, port_id); |
| return rv; |
| } |
| |
| sw_error_t |
| _fal_fdb_rfs_set(a_uint32_t dev_id, const fal_fdb_rfs_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_rfs_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_rfs_set(dev_id, entry); |
| return rv; |
| } |
| |
| sw_error_t |
| _fal_fdb_rfs_del(a_uint32_t dev_id, const fal_fdb_rfs_t * entry) |
| { |
| sw_error_t rv; |
| hsl_api_t *p_api; |
| |
| SW_RTN_ON_NULL(p_api = hsl_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->fdb_rfs_del) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->fdb_rfs_del(dev_id, entry); |
| return rv; |
| } |
| #endif |
| |
| sw_error_t |
| _fal_fdb_learning_ctrl_set(a_uint32_t dev_id, a_bool_t enable) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_learn_ctrl_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_learn_ctrl_set(dev_id, enable); |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| sw_error_t |
| _fal_fdb_learning_ctrl_get(a_uint32_t dev_id, a_bool_t * enable) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_learn_ctrl_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_learn_ctrl_get(dev_id, enable); |
| return rv; |
| } |
| sw_error_t |
| _fal_fdb_port_learned_mac_counter_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_uint32_t * cnt) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_port_fdb_learn_counter_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_port_fdb_learn_counter_get(dev_id, port_id, cnt); |
| return rv; |
| } |
| sw_error_t |
| _fal_fdb_port_maclimit_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, fal_maclimit_ctrl_t * maclimit_ctrl) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_maclimit_ctrl_set) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_maclimit_ctrl_set(dev_id, port_id, maclimit_ctrl); |
| return rv; |
| } |
| sw_error_t |
| _fal_fdb_port_maclimit_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, fal_maclimit_ctrl_t * maclimit_ctrl) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_port_maclimit_ctrl_get) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_port_maclimit_ctrl_get(dev_id, port_id, maclimit_ctrl); |
| return rv; |
| } |
| #endif |
| sw_error_t |
| _fal_fdb_entry_del_byfid(a_uint32_t dev_id, a_uint16_t fid, a_uint32_t flag) |
| { |
| adpt_api_t *p_api; |
| sw_error_t rv = SW_OK; |
| |
| SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id)); |
| |
| if (NULL == p_api->adpt_fdb_del_by_fid) |
| return SW_NOT_SUPPORTED; |
| |
| rv = p_api->adpt_fdb_del_by_fid(dev_id, fid, flag); |
| return rv; |
| } |
| #ifndef IN_FDB_MINI |
| /*insert flag for inner fal, don't remove it*/ |
| |
| /** |
| * @brief Add a Fdb entry |
| * @param[in] dev_id device id |
| * @param[in] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_add(a_uint32_t dev_id, const fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_add(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Delete all Fdb entries |
| * @details Comments: |
| * If set FAL_FDB_DEL_STATIC bit in flag which means delete all fdb |
| * entries otherwise only delete dynamic entries. |
| * @param[in] dev_id device id |
| * @param[in] flag delete operation option |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_flush(a_uint32_t dev_id, a_uint32_t flag) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_flush(dev_id, flag); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Delete Fdb entries on a particular port |
| * @details Comments: |
| * If set FAL_FDB_DEL_STATIC bit in flag which means delete all fdb |
| * entries otherwise only delete dynamic entries. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] flag delete operation option |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_del_byport(a_uint32_t dev_id, fal_port_t port_id, a_uint32_t flag) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_del_byport(dev_id, port_id, flag); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Delete a particular Fdb entry through mac address |
| * @details Comments: |
| * Only addr field in entry is meaning. For IVL learning vid or fid field |
| * also is meaning. |
| * @param[in] dev_id device id |
| * @param[in] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_del_bymac(a_uint32_t dev_id, const fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_del_bymac(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get first Fdb entry from particular device |
| * @param[in] dev_id device id |
| * @param[out] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_getfirst(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_getfirst(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Get next Fdb entry from particular device |
| * @details Comments: |
| For input parameter only addr field in entry is meaning. |
| * @param[in] dev_id device id |
| * @param entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_getnext(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_getnext(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Find a particular Fdb entry from device through mac address. |
| * @details Comments: |
| For input parameter only addr field in entry is meaning. |
| * @param[in] dev_id device id |
| * @param[in] entry fdb entry |
| * @param[out] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_search(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_search(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Set dynamic address and station move learning status on a particular port. |
| * @details Comments: |
| * This operation will enable or disable dynamic address and |
| * station move learning feature on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] enable enable or disable |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_learn_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learn_set(dev_id, port_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Get dynamic address and station move learning status on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[out] enable A_TRUE or A_FALSE |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_learn_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t * enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learn_get(dev_id, port_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Set dynamic address learning and forward command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] learning status |
| * @param[in] forward command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_learning_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable, fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learning_ctrl_set(dev_id, port_id, enable, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Get dynamic address learning and forward command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[out] learning status |
| * @param[out] forward command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_learning_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable, fal_fwd_cmd_t *cmd) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learning_ctrl_get(dev_id, port_id, enable, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Set station move learning and forward command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] learning status |
| * @param[in] forward command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_stamove_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable, fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_stamove_ctrl_set(dev_id, port_id, enable, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Get station move learning and forward command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[out] learning status |
| * @param[out] forward command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_port_stamove_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable, fal_fwd_cmd_t *cmd) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_stamove_ctrl_get(dev_id, port_id, enable, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Set dynamic address aging status on particular device. |
| * @details Comments: |
| * This operation will enable or disable dynamic address aging |
| * feature on particular device. |
| * @param[in] dev_id device id |
| * @param[in] enable enable or disable |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_aging_ctrl_set(a_uint32_t dev_id, a_bool_t enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_aging_ctrl_set(dev_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Get dynamic address aging status on particular device. |
| * @param[in] dev_id device id |
| * @param[in] enable enable or disable |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_aging_ctrl_get(a_uint32_t dev_id, a_bool_t * enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_aging_ctrl_get(dev_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief set arl search mode as ivl or svl when vlan invalid. |
| * @param[in] dev_id device id |
| * @param[in] smode INVALID_VLAN_IVL or INVALID_VLAN_SVL |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_vlan_ivl_svl_set(a_uint32_t dev_id, fal_fdb_smode smode) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_vlan_ivl_svl_set(dev_id, smode); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief get arl search mode when vlan invalid. |
| * @param[in] dev_id device id |
| * @param[out] smode INVALID_VLAN_IVL or INVALID_VLAN_SVL |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_vlan_ivl_svl_get(a_uint32_t dev_id, fal_fdb_smode* smode) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_vlan_ivl_svl_get(dev_id, smode); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| |
| |
| |
| /** |
| * @brief Set dynamic address aging time on a particular device. |
| * @details Comments: |
| * This operation will set dynamic address aging time on a particular device. |
| * The unit of time is second. Because different device has differnet |
| * hardware granularity function will return actual time in hardware. |
| * @param[in] dev_id device id |
| * @param time aging time |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_aging_time_set(a_uint32_t dev_id, a_uint32_t * time) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_aging_time_set(dev_id, time); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get dynamic address aging time on a particular device. |
| * @param[in] dev_id device id |
| * @param[out] time aging time |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_aging_time_get(a_uint32_t dev_id, a_uint32_t * time) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_aging_time_get(dev_id, time); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| |
| /** |
| * @brief Iterate all fdb entries on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] iterator fdb entry index if it's zero means get the first entry |
| * @param[out] iterator next valid fdb entry index |
| * @param[out] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_getnext_byindex(a_uint32_t dev_id, a_uint32_t * iterator, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_getnext_byindex(dev_id, iterator, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get next Fdb entry from a particular device |
| * @param[in] dev_id device id |
| * @param[in] option next operation options |
| * @param[out] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_extend_getnext(a_uint32_t dev_id, fal_fdb_op_t * option, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_extend_getnext(dev_id, option, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get first Fdb entry from a particular device |
| * @param[in] dev_id device id |
| * @param[in] option first operation options |
| * @param[out] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_extend_getfirst(a_uint32_t dev_id, fal_fdb_op_t * option, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_extend_getfirst(dev_id, option, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| /** |
| * @brief Transfer fdb entries port information on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] old_port source port id |
| * @param[in] new_port destination port id |
| * @param[in] fid filter database id |
| * @param[in] option transfer operation options |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_entry_update_byport(a_uint32_t dev_id, fal_port_t old_port, fal_port_t new_port, |
| a_uint32_t fid, fal_fdb_op_t * option) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_update_byport(dev_id, old_port, new_port, fid, option); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Set dynamic address learning count limit on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] enable A_TRUE or A_FALSE |
| * @param[in] cnt limit count |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_port_fdb_learn_limit_set(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t enable, a_uint32_t cnt) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_port_fdb_learn_limit_set(dev_id, port_id, enable, cnt); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get dynamic address learning count limit on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[out] enable A_TRUE or A_FALSE |
| * @param[out] cnt limit count |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_port_fdb_learn_limit_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t * enable, a_uint32_t * cnt) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_port_fdb_learn_limit_get(dev_id, port_id, enable, cnt); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Set dynamic address learning count exceed command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[in] cmd forwarding command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_port_fdb_learn_exceed_cmd_set(a_uint32_t dev_id, fal_port_t port_id, |
| fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_port_fdb_learn_exceed_cmd_set(dev_id, port_id, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get dynamic address learning count exceed command on a particular port. |
| * @param[in] dev_id device id |
| * @param[in] port_id port id |
| * @param[out] cmd forwarding command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_port_fdb_learn_exceed_cmd_get(a_uint32_t dev_id, fal_port_t port_id, |
| fal_fwd_cmd_t * cmd) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_port_fdb_learn_exceed_cmd_get(dev_id, port_id, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Set dynamic address learning count limit on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] enable A_TRUE or A_FALSE |
| * @param[in] cnt limit count |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_learn_limit_set(a_uint32_t dev_id, a_bool_t enable, a_uint32_t cnt) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learn_limit_set(dev_id, enable, cnt); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get dynamic address learning count limit on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] enable A_TRUE or A_FALSE |
| * @param[in] cnt limit count |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_learn_limit_get(a_uint32_t dev_id, a_bool_t * enable, a_uint32_t * cnt) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learn_limit_get(dev_id, enable, cnt); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Set dynamic address learning count exceed command on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] cmd forwarding command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_learn_exceed_cmd_set(a_uint32_t dev_id, fal_fwd_cmd_t cmd) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learn_exceed_cmd_set(dev_id, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Get dynamic address learning count exceed command on a particular device. |
| * @param[in] dev_id device id |
| * @param[out] cmd forwarding command |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_learn_exceed_cmd_get(a_uint32_t dev_id, fal_fwd_cmd_t * cmd) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learn_exceed_cmd_get(dev_id, cmd); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Add a particular reserve Fdb entry |
| * @param[in] dev_id device id |
| * @param[in] entry reserve fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_resv_add(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_resv_add(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Delete a particular reserve Fdb entry through mac address |
| * @param[in] dev_id device id |
| * @param[in] entry reserve fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_resv_del(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_resv_del(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Find a particular reserve Fdb entry through mac address |
| * @param[in] dev_id device id |
| * @param[in] entry reserve fdb entry |
| * @param[out] entry reserve fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_resv_find(a_uint32_t dev_id, fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_resv_find(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Iterate all reserve fdb entries on a particular device. |
| * @param[in] dev_id device id |
| * @param[in] iterator reserve fdb entry index if it's zero means get the first entry |
| * @param[out] iterator next valid fdb entry index |
| * @param[out] entry reserve fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_resv_iterate(a_uint32_t dev_id, a_uint32_t * iterator, |
| fal_fdb_entry_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_resv_iterate(dev_id, iterator, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| sw_error_t |
| fal_fdb_port_learn_static_set(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learn_static_set(dev_id, port_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| sw_error_t |
| fal_fdb_port_learn_static_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_bool_t * enable) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learn_static_get(dev_id, port_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Add a port to an exsiting entry |
| * @param[in] dev_id device id |
| * @param[in] fid filtering database id |
| * @param[in] addr MAC address |
| * @param[in] port_id port id |
| * @return SW_OK or error code, If entry not exist will return error. |
| */ |
| sw_error_t |
| fal_fdb_port_add(a_uint32_t dev_id, a_uint32_t fid, fal_mac_addr_t * addr, fal_port_t port_id) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_add(dev_id, fid, addr, port_id); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Delete a port from an exsiting entry |
| * @param[in] dev_id device id |
| * @param[in] fid filtering database id |
| * @param[in] addr MAC address |
| * @param[in] port_id port id |
| * @return SW_OK or error code, If entry not exist will return error. |
| */ |
| sw_error_t |
| fal_fdb_port_del(a_uint32_t dev_id, a_uint32_t fid, fal_mac_addr_t * addr, fal_port_t port_id) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_del(dev_id, fid, addr, port_id); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Add a Fdb rfs entry |
| * @param[in] dev_id device id |
| * @param[in] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_rfs_set(a_uint32_t dev_id, const fal_fdb_rfs_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_rfs_set(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| /** |
| * @brief Del a Fdb rfs entry |
| * @param[in] dev_id device id |
| * @param[in] entry fdb entry |
| * @return SW_OK or error code |
| */ |
| sw_error_t |
| fal_fdb_rfs_del(a_uint32_t dev_id, const fal_fdb_rfs_t * entry) |
| { |
| sw_error_t rv; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_rfs_del(dev_id, entry); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| int ssdk_rfs_mac_rule_set(u16 vid, u8* mac, u8 ldb, int is_set) |
| { |
| fal_fdb_rfs_t entry; |
| memcpy(&entry.addr, mac, 6); |
| entry.fid = vid; |
| entry.load_balance = ldb; |
| if(is_set) |
| return fal_fdb_rfs_set(0, &entry); |
| else |
| return fal_fdb_rfs_del(0, &entry); |
| } |
| #endif |
| |
| #if 0 |
| int ssdk_rfs_mac_rule_set(ssdk_fdb_rfs_t *rfs) |
| { |
| fal_fdb_rfs_t entry; |
| memcpy(&entry.addr, rfs->addr, 6); |
| entry.fid = rfs->fid; |
| entry.load_balance = rfs->load_balance; |
| return fal_fdb_rfs_set(0, &entry); |
| } |
| |
| int ssdk_rfs_mac_rule_del(ssdk_fdb_rfs_t *rfs) |
| { |
| fal_fdb_rfs_t entry; |
| memcpy(&entry.addr, rfs->addr, 6); |
| entry.fid = rfs->fid; |
| entry.load_balance = rfs->load_balance; |
| return fal_fdb_rfs_del(0, &entry); |
| } |
| |
| |
| EXPORT_SYMBOL(ssdk_rfs_mac_rule_set); |
| EXPORT_SYMBOL(ssdk_rfs_mac_rule_del); |
| #endif |
| |
| sw_error_t |
| fal_fdb_learning_ctrl_set(a_uint32_t dev_id, a_bool_t enable) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learning_ctrl_set(dev_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| sw_error_t |
| fal_fdb_learning_ctrl_get(a_uint32_t dev_id, a_bool_t * enable) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_learning_ctrl_get(dev_id, enable); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| sw_error_t |
| fal_fdb_port_learned_mac_counter_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_uint32_t * cnt) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_learned_mac_counter_get(dev_id, port_id, cnt); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| sw_error_t |
| fal_fdb_port_maclimit_ctrl_set(a_uint32_t dev_id, fal_port_t port_id, fal_maclimit_ctrl_t * maclimit_ctrl) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_maclimit_ctrl_set(dev_id, port_id, maclimit_ctrl); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| sw_error_t |
| fal_fdb_port_maclimit_ctrl_get(a_uint32_t dev_id, fal_port_t port_id, fal_maclimit_ctrl_t * maclimit_ctrl) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_port_maclimit_ctrl_get(dev_id, port_id, maclimit_ctrl); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| #endif |
| sw_error_t |
| fal_fdb_entry_del_byfid(a_uint32_t dev_id, a_uint16_t fid, a_uint32_t flag) |
| { |
| sw_error_t rv = SW_OK; |
| |
| FAL_API_LOCK; |
| rv = _fal_fdb_entry_del_byfid(dev_id, fid, flag); |
| FAL_API_UNLOCK; |
| return rv; |
| } |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_entry_add); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_entry_del_byport); |
| |
| |
| EXPORT_SYMBOL(fal_fdb_entry_del_bymac); |
| |
| |
| EXPORT_SYMBOL(fal_fdb_entry_search); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_port_learn_get); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_port_learning_ctrl_set); |
| |
| EXPORT_SYMBOL(fal_fdb_entry_flush); |
| |
| EXPORT_SYMBOL(fal_fdb_entry_getfirst); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_entry_getnext); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_port_learn_set); |
| |
| EXPORT_SYMBOL(fal_fdb_learning_ctrl_set); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_learning_ctrl_get); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_entry_getnext_byindex); |
| |
| EXPORT_SYMBOL(fal_fdb_entry_extend_getnext); |
| |
| EXPORT_SYMBOL(fal_fdb_entry_extend_getfirst); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_port_learning_ctrl_get); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_port_stamove_ctrl_set); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_port_stamove_ctrl_get); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_aging_ctrl_set); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_aging_ctrl_get); |
| |
| EXPORT_SYMBOL(fal_fdb_aging_time_set); |
| |
| EXPORT_SYMBOL(fal_fdb_aging_time_get); |
| |
| EXPORT_SYMBOL(fal_fdb_entry_update_byport); |
| |
| EXPORT_SYMBOL(fal_port_fdb_learn_limit_set); |
| |
| EXPORT_SYMBOL(fal_port_fdb_learn_limit_get); |
| |
| EXPORT_SYMBOL(fal_port_fdb_learn_exceed_cmd_set); |
| |
| EXPORT_SYMBOL(fal_port_fdb_learn_exceed_cmd_get); |
| |
| EXPORT_SYMBOL(fal_fdb_port_add); |
| |
| EXPORT_SYMBOL(fal_fdb_port_del); |
| |
| EXPORT_SYMBOL(fal_fdb_port_maclimit_ctrl_set); |
| |
| EXPORT_SYMBOL(fal_fdb_port_maclimit_ctrl_get); |
| |
| #endif |
| |
| EXPORT_SYMBOL(fal_fdb_entry_del_byfid); |
| |
| #ifndef IN_FDB_MINI |
| |
| EXPORT_SYMBOL(fal_fdb_port_learned_mac_counter_get); |
| |
| #endif |
| |
| /*insert flag for outter fal, don't remove it*/ |
| |
| /** |
| * @} |
| */ |
| |