blob: 02dc74a4f9fb9bf3ddc9d3632203f0d0ba46f7d9 [file] [log] [blame]
/*
* 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*/
/**
* @}
*/