Gitiles
Code Review Sign In
gerrit.opencord.org / voltha-bal / refs/heads/master / . / bal_release / src / core / main / acc_term_fsm.c
blob: c4635b95b44a02ca9732743bb40f9cb9cfc779b4 [file] [log] [blame]
/******************************************************************************
*
* <:copyright-BRCM:2016:DUAL/GPL:standard
*
* Copyright (c) 2016 Broadcom
* All Rights Reserved
*
* Unless you and Broadcom execute a separate written software license
* agreement governing use of this software, this software is licensed
* to you under the terms of the GNU General Public License version 2
* (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
* with the following added to such license:
*
* As a special exception, the copyright holders of this software give
* you permission to link this software with independent modules, and
* to copy and distribute the resulting executable under terms of your
* choice, provided that you also meet, for each linked independent
* module, the terms and conditions of the license of that module.
* An independent module is a module which is not derived from this
* software. The special exception does not apply to any modifications
* of the software.
*
* Not withstanding the above, under no circumstances may you combine
* this software in any way with any other Broadcom software provided
* under a license other than the GPL, without Broadcom's express prior
* written consent.
*
* :>
*
*****************************************************************************/
/**
* @file acc_term_fsm.c
* @brief Code to support the BAL access terminal FSM
*
* @addtogroup access_terminal
*/
/*@{*/
#define BAL_DBG_PRINT
/*--- project includes ---*/
#include <bcmos_system.h>
#include <acc_term_fsm.h>
#include <bal_msg.h>
#include <bal_api.h>
#include "bal_worker.h"
#include "bal_mac_util.h"
#include "bal_switch_util.h"
#include <bal_osmsg.h>
#include <fsm_common.h>
#include <rsc_mgr.h>
#include <bal_core.h>
#ifdef ENABLE_LOG
#include <bcm_dev_log.h>
/*
* @brief The logging device ids for the access-terminal and interface
*/
static dev_log_id log_id_access_terminal;
static dev_log_id log_id_interface;
#endif
/*--- local function declarations ---*/
static bcmos_errno acc_term_fsm_acc_term_admin_up_ok(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_acc_term_admin_dn_start(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_acc_term_admin_dn_ok(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_ignore_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_acc_term_admin_up_pending(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_acc_term_admin_dn_pending(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_adding_process_util_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_removing_process_util_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_process_util_auto_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_process_adding_timeout(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_process_removing_timeout(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno acc_term_fsm_acc_term_admin_up_start(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static bcmos_errno interface_admin_up_start(acc_term_interface *p_interface,
void *msg);
static bcmos_errno interface_admin_dn_start(acc_term_interface *p_interface,
void *msg);
static bcmos_timer_rc acc_term_fsm_timer_expiry(bcmos_timer *timer, long pUser);
static bcmos_errno access_terminal_fsm_exec(acc_term_inst *p_acc_term_inst, acc_term_fsm_event *p_event);
/**
* access-terminal FSM helper functions
*/
static bcmos_errno acc_term_fsm_state_err(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event);
static void initialize_access_terminal_instance_config(acc_term_inst *p_acc_term_inst);
static bcmos_errno sub_term_id_list_fill(uint32_t interface_index,
bcmbal_sub_id_list_u16 *sub_term_id_list);
static acc_term_inst *access_terminal_get(void);
static char *interface_type_str_get(bcmbal_intf_type intf_type);
static bcmos_errno interface_tm_sched_set(bcmbal_interface_cfg *p_interface_info);
static acc_term_interface * bcmbal_interface_get(bcmbal_interface_key key);
#define ACC_TERM_FSM_STATE_ADDING_TIMEOUT (45) /* Seconds */
/*
* @brief The definition of an access terminal FSM state processing function
*/
typedef bcmos_errno (* acc_term_fsm_state_processor)(acc_term_inst *, void *, acc_term_fsm_event *);
extern bcmbal_config_params bal_config_params;
/**
* @brief API to get oper status from admin state of an interface
*/
bcmbal_status bcmbal_get_intf_oper_status_from_admin_state (bcmbal_state intf_admin_state)
{
switch (intf_admin_state)
{
case BCMBAL_STATE_UP:
return BCMBAL_STATUS_UP;
break;
case BCMBAL_STATE_DOWN:
return BCMBAL_STATUS_DOWN;
break;
case BCMBAL_STATE_TESTING:
return BCMBAL_STATUS_TESTING;
break;
default:
return BCMBAL_STATUS_UP; /* default keep oper status as UP */
break;
}
return BCMBAL_STATUS_UP; /* default keep oper status as UP */
}
/**
* @brief API to convert port type and id from CLI/Mgmt interface to the internal
* index of interface array database.
*/
uint32_t bcmbal_port_type_and_id_to_interface_index (bcmbal_intf_type intf_type, bcmbal_intf_id intf_id)
{
switch (intf_type)
{
case BCMBAL_INTF_TYPE_PON:
if (intf_id < NUM_SUPPORTED_SUBSCRIBER_INTERFACES)
{
return intf_id; /* zero offset for the PON ports */
}
break;
case BCMBAL_INTF_TYPE_NNI:
if (intf_id < bal_config_params.num_nni_ports)
{
return (NUM_SUPPORTED_SUBSCRIBER_INTERFACES + intf_id); /* offset-ed for the NNI ports */
}
break;
default:
break;
}
return INVALID_INTERFACE_INDEX;
}
/*
* @brief The Access terminal FSM state processing array
*/
static acc_term_fsm_state_processor access_term_states[ACC_TERM_FSM_STATE__NUM_OF][ACC_TERM_FSM_EVENT_TYPE__NUM_OF] =
{
[ACC_TERM_FSM_STATE_NULL] =
{
/*
* Next state: ADDING
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_UP] = acc_term_fsm_acc_term_admin_up_start,
/*
* Next state: NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_DN] = acc_term_fsm_acc_term_admin_dn_ok,
/*
* Next state: NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_MSG] = acc_term_fsm_ignore_msg,
/*
* Next state: NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_AUTO_MSG] = acc_term_fsm_process_util_auto_msg,
},
[ACC_TERM_FSM_STATE_ADDING] =
{
/*
* Next state: ADDING
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_UP] = acc_term_fsm_acc_term_admin_up_pending,
/*
* Next state: ADDING | ADDED
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_MSG] = acc_term_fsm_adding_process_util_msg,
/*
* Next state: ADDING
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_AUTO_MSG] = acc_term_fsm_process_util_auto_msg,
/*
* Next state: NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_TIMEOUT] = acc_term_fsm_process_adding_timeout,
},
[ACC_TERM_FSM_STATE_ADDED] =
{
/*
* Next state: ADDED
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_UP] = acc_term_fsm_acc_term_admin_up_ok,
/*
* Next state: REMOVING
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_DN] = acc_term_fsm_acc_term_admin_dn_start,
/*
* Next state: ADDING | ADDED
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_MSG] = acc_term_fsm_ignore_msg,
/*
* Next state: ADDED
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_AUTO_MSG] = acc_term_fsm_process_util_auto_msg,
},
[ACC_TERM_FSM_STATE_REMOVING] =
{
/*
* Next state: REMOVING
*/
[ACC_TERM_FSM_EVENT_TYPE_ADMIN_DN] = acc_term_fsm_acc_term_admin_dn_pending,
/*
* Next state: REMOVING | NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_MSG] = acc_term_fsm_removing_process_util_msg,
/*
* Next state: REMOVING
*/
[ACC_TERM_FSM_EVENT_TYPE_UTIL_AUTO_MSG] = acc_term_fsm_process_util_auto_msg,
/*
* Next state: NULL
*/
[ACC_TERM_FSM_EVENT_TYPE_TIMEOUT] = acc_term_fsm_process_removing_timeout,
},
};
static char *state_name_str[] =
{
"ACC_TERM_NULL",
"ACC_TERM_ADDING",
"ACC_TERM_ADDED",
"ACC_TERM_REMOVING",
};
/* Ensure that the name array size matches the associated enum */
BAL_STATIC_ASSERT (ACC_TERM_FSM_STATE__LAST == (sizeof (state_name_str) / sizeof (char *)), acc_term_fsm_state);
static char *acc_term_state_name_get(acc_term_fsm_state state)
{
if(state < ACC_TERM_FSM_STATE__LAST)
{
return state_name_str[state];
}
else
{
return "ACC_TERM_UNKNOWN";
}
}
static char *event_name_str[] =
{
"ACC_TERM_FSM_ACC_TERM_ADMIN_UP_EVENT",
"ACC_TERM_FSM_ACC_TERM_ADMIN_DN_EVENT",
"ACC_TERM_FSM_INT_ADMIN_UP_EVENT",
"ACC_TERM_FSM_INT_ADMIN_DN_EVENT",
"ACC_TERM_FSM_UTIL_MSG_EVENT",
"ACC_TERM_FSM_UTIL_AUTO_MSG_EVENT",
"ACC_TERM_FSM_TIMEOUT_EVENT"
};
/* Ensure that the name array size matches the associated enum */
BAL_STATIC_ASSERT (ACC_TERM_FSM_EVENT_TYPE__LAST == (sizeof (event_name_str) / sizeof (char *)), acc_term_fsm_event_type);
static char *acc_term_event_name_get(acc_term_fsm_event_type event)
{
if(event < ACC_TERM_FSM_EVENT_TYPE__LAST)
{
return event_name_str[event];
}
else
{
return "ACC_TERM_EVT_UNKNOWN";
}
}
static acc_term_inst single_access_terminal_instance;
/*****************************************************************************/
/**
* @brief A function called to initialize the access-terminal FSM
* infrastructure.
*
* NOTE: This is called once on startup and NOT for each FSM instance.
*
* @returns void
*****************************************************************************/
void access_terminal_fsm_init(void)
{
#ifdef ENABLE_LOG
/* Register the log ids for this FSM */
log_id_access_terminal = bcm_dev_log_id_register("ACC_TERM", DEV_LOG_LEVEL_INFO, DEV_LOG_ID_TYPE_BOTH);
BUG_ON(log_id_access_terminal == DEV_LOG_INVALID_ID);
log_id_interface = bcm_dev_log_id_register("INTF", DEV_LOG_LEVEL_INFO, DEV_LOG_ID_TYPE_BOTH);
BUG_ON(log_id_interface == DEV_LOG_INVALID_ID);
#endif
/*
* Initialize the access terminal instance structures
*/
initialize_access_terminal_instance_config(&single_access_terminal_instance);
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing executive function
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno access_terminal_fsm_exec(acc_term_inst *p_acc_term_inst,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_fsm_state pre_state;
acc_term_fsm_state_processor acc_term_state_processor;
/* Parameter checks */
BUG_ON(NULL == p_acc_term_inst);
BUG_ON(NULL == p_event);
/* Record the present state before transitioning
*/
pre_state = p_acc_term_inst->fsm_state;
/*
* Get the state processing function
*/
acc_term_state_processor = access_term_states[p_acc_term_inst->fsm_state][p_event->event_type];
/*
* If there's a state processing function for this event and state, execute it.
* Otherwise, process a generic error.
*/
if (acc_term_state_processor)
{
ret = acc_term_state_processor(p_acc_term_inst, p_event->msg, p_event);
} else
{
acc_term_fsm_state_err(p_acc_term_inst, p_event->msg, p_event);
}
BCM_LOG(DEBUG, log_id_access_terminal, "*** FSM exec: Event %s, State: %s --> %s\n",
acc_term_event_name_get(p_event->event_type),
acc_term_state_name_get(pre_state),
acc_term_state_name_get(p_acc_term_inst->fsm_state));
return ret;
}
bcmos_errno process_access_terminal_util_msg(void *msg_payload)
{
acc_term_inst *p_access_terminal_inst;
BCM_LOG(INFO, log_id_access_terminal, "ACCESS_TERMINAL indication received from util\n");
/* Find the specified access terminal instance */
p_access_terminal_inst = access_terminal_get();
if (NULL != p_access_terminal_inst)
{
acc_term_fsm_event event;
event.event_type = ACC_TERM_FSM_EVENT_TYPE_UTIL_MSG;
event.msg = msg_payload;
access_terminal_fsm_exec(p_access_terminal_inst, &event);
}
else
{
BCM_LOG(ERROR, log_id_interface, "Could not find the ACTIVE access-terminal\n");
}
return BCM_ERR_OK;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing for an access-terminal
* admin-up command received from the BAL Public API when the specified
* access-terminal instance is in the admin-down state (i.e. when
* the access-terminal instance FSM is in the NULL state).
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_up_start(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_fsm_state old_state = p_acc_term_inst->fsm_state;
BCM_LOG(INFO, log_id_access_terminal,
"Received an admin UP request from BAL API - bringing access terminal up\n");
do
{
/* change access terminal state to ADDING */
p_acc_term_inst->fsm_state = ACC_TERM_FSM_STATE_ADDING;
/* start the timeout timer for the ADDING state */
fsm_timer_start(&p_acc_term_inst->timer_info,
p_acc_term_inst,
acc_term_fsm_timer_expiry,
TIMER_DURATION_IN_SEC(ACC_TERM_FSM_STATE_ADDING_TIMEOUT),
log_id_access_terminal);
/* Validate that the OLT SW version that the Bal was compiled against matches
* the SW version of the actual OLT that the Bal works with. We assume that
* Device Id 0 has the same version as all other OLT devices */
if (!bcmbal_is_mac_in_loopback() &&
(BCM_ERR_OK != (ret = mac_util_access_terminal_sw_version_validate((bcmolt_devid) 0))))
{
BCM_LOG(ERROR, log_id_access_terminal, "mac_util_access_terminal_sw_version_validate(() failed. rc=%s\n", bcmos_strerror(ret));
break;
}
/* Core calls Mac Utils to set the access-terminal parameters using the applicable SDK calls */
if(BCM_ERR_OK != (ret = mac_util_access_terminal_set(p_acc_term_inst, BAL_UTIL_OPER_ACC_TERM_CONNECT)))
{
BCM_LOG(ERROR, log_id_access_terminal, "mac_util_access_terminal_set(() failed. rc=%s\n", bcmos_strerror(ret));
break;
}
}while(0);
if(BCM_ERR_OK == ret)
{
/*
* The access-terminal object command has succeeded. The current object info
* becomes the commanded object info, except for the oper_status. This should
* be done atomically
*/
memcpy(&p_acc_term_inst->current_acc_term_obj_info,
&p_acc_term_inst->api_req_acc_term_obj_info,
sizeof(p_acc_term_inst->api_req_acc_term_obj_info));
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->current_acc_term_obj_info), BCMOS_TRUE);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
oper_status,
BCMBAL_STATUS_DOWN);
}
else
{
fsm_timer_stop(&p_acc_term_inst->timer_info);
p_acc_term_inst->fsm_state = old_state;
mgmt_msg_send_balapi_ind(ret, msg, log_id_access_terminal);
}
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing for an access-terminal
* admin-up command from the BAL Public API when the specified
* access-terminal is already admin-up (i.e. when the specified
* access-terminal instance FSM is in the ADDED state).
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_up_ok(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(DEBUG, log_id_access_terminal,
"Received an admin UP request from BAL API - returning OK to the API"
" - no further function\n");
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing for an access-terminal
* admin-down command received from the BAL Public API when the specified
* access-terminal is admin-up (i.e when the specified access-terminal
* instance FSM is in the ADDED state).
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_dn_start(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(DEBUG, log_id_access_terminal,
"Received an admin DOWN request from BAL API - removing the access terminal\n");
/*
* @todo - complete the DOWN implementation - until then, return an error
*/
ret = BCM_ERR_NOT_SUPPORTED;
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing for access-terminal
* admin-down command from the BAL Public API when the specified
* access-terminal is already admin-down.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_dn_ok(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(DEBUG, log_id_access_terminal,
"Received an admin DOWN request from BAL API - returning OK to the API"
" - no further function\n");
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to ignore a
* received message.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_ignore_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(DEBUG, log_id_access_terminal, "Ignoring message from BAL API \n");
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to process an
* access-terminal admin-up command from the BAL Public API when the
* specified access-terminal is in the REMOVING state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_up_pending(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(DEBUG, log_id_access_terminal,
" Received an admin UP request from BAL API - returning UP_PENDING to the API"
" - no further function\n");
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to process an
* access-terminal admin-down command from the BAL Public API when the
* specified access-terminal FSM is in the REMOVING state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_acc_term_admin_dn_pending(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_IN_PROGRESS;
BCM_LOG(DEBUG, log_id_access_terminal,
" Received an admin DOWN request from BAL API"
" - returning IN_PROGRESS to the API - no further function\n");
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to process a
* message from one of the BAL apps when the specified access-terminal
* instance FSM is in the ADDING state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from one of
* the BAL apps.
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_adding_process_util_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
flow_fsm_state next_state = ACC_TERM_FSM_STATE_NULL;
bcmos_errno ret;
bal_util_msg_ind *ind_msg;
/* Parameter checks */
BUG_ON(NULL == p_acc_term_inst);
BUG_ON(NULL == msg);
BUG_ON(NULL == p_event);
ind_msg = (bal_util_msg_ind *)msg;
ret = ind_msg->status;
/*
* NOTE: AUTO_IND messages are not processed in this function,
* so there is no need to consider them in this logic.
*/
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_access_terminal,
"Received an IND message from BAL UTIL (%s) during ADDING state with status %s\n",
subsystem_str[bcmbal_sender_get(msg)],
bcmos_strerror(ret)
);
}
/*
* Stop the indication timer
*/
fsm_timer_stop(&p_acc_term_inst->timer_info);
if(BCM_ERR_OK == ret)
{
/* Core calls Switch Utils to set the access-terminal parameters using the applicable SDK calls */
ret = sw_util_access_terminal_set(p_acc_term_inst, BAL_UTIL_OPER_ACC_TERM_CONNECT);
if (ret)
{
BCM_LOG(INFO, log_id_access_terminal,
"sw_util_access_terminal_set(() failed. rc=%s\n", bcmos_strerror(ret));
}
if(BCM_ERR_OK == ret)
{
uint32_t logical_pon;
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
oper_status,
BCMBAL_STATUS_UP);
/*
* Initialize the resource manager only if at least of the PONs on the device is a GPON/XGPON/XGS/NGPON2 PON
*/
BCM_TOPO_DEV_FOR_EACH_PON(0, logical_pon)
{
bcm_topo_pon_family pon_family = bcm_topo_pon_get_pon_family(logical_pon);
if (pon_family == BCM_TOPO_PON_FAMILY_GPON)
{
rsc_mgr_mac_init();
break;
}
}
/*
* Go to the ADDED state upon success
*/
next_state = ACC_TERM_FSM_STATE_ADDED;
}
else
{
/* Error */
BCM_LOG(ERROR, log_id_access_terminal,
" Failed in state %s;%s\n",
acc_term_state_name_get(p_acc_term_inst->fsm_state),
bcmos_strerror(ret));
/*
* Automatically return to the NULL state if an error occurs
*/
}
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->current_acc_term_obj_info), BCMOS_FALSE);
/*
* Send the indication back to the BAL public API here
*/
mgmt_msg_send_balapi_ind(ret,
(void *)&p_acc_term_inst->current_acc_term_obj_info.hdr,
log_id_access_terminal);
}
p_acc_term_inst->fsm_state = next_state;
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to process a
* message from one of the BAL apps received when the specified
* access-terminal instance FSM is in the REMOVING state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from one of
* the BAL apps.
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_removing_process_util_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret;
bal_util_msg_ind *ind_msg;
/* Parameter checks */
BUG_ON(NULL == p_acc_term_inst);
BUG_ON(NULL == msg);
BUG_ON(NULL == p_event);
ind_msg = (bal_util_msg_ind *)msg;
ret = ind_msg->status;
/*
* NOTE: AUTO_IND messages are not processed in this function,
* so there is no need to consider them in this logic.
*/
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_access_terminal,
" Received an IND message from BAL UTIL (%s) during REMOVING state\n",
subsystem_str[bcmbal_sender_get(msg)]);
}
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing function to process an
* AUTO IND message from one of the BAL apps.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from one of
* the BAL apps.
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_process_util_auto_msg(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
/* Parameter checks */
BUG_ON(NULL == p_acc_term_inst);
BUG_ON(NULL == msg);
BUG_ON(NULL == p_event);
BCM_LOG(INFO, log_id_access_terminal,
" Received an AUTO IND message from BAL UTIL ()\n");
return ret;
}
/*****************************************************************************/
/**
* @brief Interface admin-up command received from the BAL Public API when
* the specified interface instance is in the admin-up state.
*
* @note This handler gets called for both PON and NNI type interfaces
*
* @param p_interface_inst Pointer to an interface instance
* @param msg Pointer to a BAL message received from the BAL Public API
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno interface_admin_up_start(acc_term_interface *p_interface_inst,
void *msg)
{
bcmos_errno ret = BCM_ERR_OK;
bcmbal_interface_key *key = &(p_interface_inst->api_req_int_obj_info.key);
BCM_LOG(INFO, log_id_interface,
" Received an INTERFACE admin UP request from BAL API"
" - bringing interface (%s%d) UP \n",
interface_type_str_get(key->intf_type),
key->intf_id);
do
{
bcmbal_state old_admin_state = p_interface_inst->current_int_obj_info.data.admin_state;
/*
* Create a pointer to the interface instance specified by the user
*/
/*
* If the user has set the min_data_agg_port_id attribute for the interface, then program the resource manager
* with this value. It will also be sent to the MAC device for any required programming there.
*/
if ((BCMBAL_INTF_TYPE_PON == key->intf_type) &&
(BCMOS_TRUE == BCMBAL_CFG_PROP_IS_SET(&p_interface_inst->api_req_int_obj_info,
interface,
min_data_agg_port_id)) &&
(BCM_ERR_OK != rsc_mgr_access_int_base_alloc_id_set(key->intf_id,
p_interface_inst->api_req_int_obj_info.data.min_data_agg_port_id)))
{
BCM_LOG(ERROR, log_id_access_terminal, "Error while setting base agg_port_id (%d) in the resource manager\n",
p_interface_inst->api_req_int_obj_info.data.min_data_agg_port_id);
ret = BCM_ERR_INTERNAL;
break;
}
/* Change the interface admin state of the "current" interface object to up (this is for reporting) */
BCMBAL_CFG_PROP_SET(&p_interface_inst->current_int_obj_info,
interface,
admin_state,
BCMBAL_STATE_UP);
/* Core calls Mac Utils to set the interface parameters using the applicable SDK calls */
ret = mac_util_interface_set(p_interface_inst, BAL_UTIL_OPER_IF_UP);
if (BCM_ERR_OK != ret)
{
BCMBAL_CFG_PROP_SET(&p_interface_inst->current_int_obj_info,
interface,
admin_state,
old_admin_state);
BCM_LOG(ERROR, log_id_interface,
"Error detected by mac_util_interface_set (%s)\n",
bcmos_strerror(ret));
break;
}
} while (0);
if (BCM_ERR_OK != ret)
{
/* report this error to the API */
mgmt_msg_send_balapi_ind(ret,
msg,
log_id_interface);
}
else
{
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_interface_inst->current_int_obj_info), BCMOS_TRUE);
}
return ret;
}
/*****************************************************************************/
/**
* @brief Interface admin-up command received from the BAL Public API when
* the specified interface instance is in the admin-down state.
*
* @note This handler gets called for both PON and NNI type interfaces
*
* @param p_interface_inst Pointer to an interface instance
* @param msg Pointer to a BAL message received from the BAL Public API
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno interface_admin_dn_start(acc_term_interface *p_interface_inst,
void *msg)
{
bcmos_errno ret = BCM_ERR_OK;
bcmbal_interface_key *key = &(p_interface_inst->api_req_int_obj_info.key);
BCM_LOG(INFO, log_id_interface,
" Received an INTERFACE admin DOWN request from BAL API"
" - bringing interface (%s%d) DOWN \n",
interface_type_str_get(key->intf_type),
key->intf_id);
do
{
bcmbal_state old_admin_state = p_interface_inst->current_int_obj_info.data.admin_state;
/*
* Create a pointer to the interface instance specified by the user
*/
/* Core calls Mac Utils to set the interface parameters using the applicable SDK calls */
ret = mac_util_interface_set(p_interface_inst, BAL_UTIL_OPER_IF_DOWN);
if (BCM_ERR_OK != ret)
{
BCMBAL_CFG_PROP_SET(&p_interface_inst->current_int_obj_info,
interface,
admin_state,
old_admin_state);
BCM_LOG(ERROR, log_id_interface,
"Error detected by mac_util_interface_set (%s)\n",
bcmos_strerror(ret));
break;
}
} while (0);
/* Change the interface admin state of the current interface info to down */
BCMBAL_CFG_PROP_SET(&p_interface_inst->current_int_obj_info,
interface,
admin_state,
BCMBAL_STATE_DOWN);
/* Check for any error and send an indication immediately in that case */
if (BCM_ERR_OK != ret)
{
/* report this error to the API */
mgmt_msg_send_balapi_ind(ret,
msg,
log_id_interface);
}
else
{
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_interface_inst->current_int_obj_info), BCMOS_TRUE);
}
return ret;
}
/*****************************************************************************/
/**
* @brief The function to process a timer expiry for either the ADDING
* states. This function executes an
* ACC_TERM_FSM_TIMEOUT_EVENT in the FSM state machine.
*
* @param timer - A pointer to the timer instance
* @param pUser - An opaque pointer to an access terminal instance
*
* @returns bcmos_timer_rc == BCMOS_TIMER_OK
*/
static bcmos_timer_rc acc_term_fsm_timer_expiry(bcmos_timer *timer, long pUser)
{
acc_term_fsm_event acc_term_event;
/*
* Stop the indication timer
*/
fsm_timer_stop(timer);
BCM_LOG(INFO, log_id_access_terminal,
"timer expiry\n");
/*
* A message pointer is always passed inside the event structure. In this case, it is unused
*/
acc_term_event.msg = NULL;
acc_term_event.event_type = ACC_TERM_FSM_EVENT_TYPE_TIMEOUT;
/* Declare this no longer in-progress */
BCMBAL_OBJ_IN_PROGRESS_SET(&(((acc_term_inst *)pUser)->current_acc_term_obj_info), BCMOS_FALSE);
/*
* Run the access terminal FSM to process this event
*/
access_terminal_fsm_exec((acc_term_inst *)pUser, &acc_term_event);
return BCMOS_TIMER_OK;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing a timeout that occurs
* when the FSM is in the ADDING state. In this case, the FSM should
* just go back to the NULL state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_process_adding_timeout(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(ERROR, log_id_access_terminal,
"Error: Received a timeout while in the %s state.\n",
acc_term_state_name_get(p_acc_term_inst->fsm_state));
/*
* Send the indication back to the BAL public API here
*/
mgmt_msg_send_balapi_ind(BCM_ERR_TIMEOUT,
(void *)&(p_acc_term_inst->current_acc_term_obj_info.hdr.hdr),
log_id_access_terminal);
/*
* Go back to the previous state
*/
p_acc_term_inst->fsm_state = ACC_TERM_FSM_STATE_NULL;
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->current_acc_term_obj_info), BCMOS_FALSE);
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM state processing a timeout that occurs
* when the FSM is in the REMOVING state. In this case, the FSM should
* just go back to the ADDED state.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message received from the BAL Public API
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_process_removing_timeout(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_OK;
BCM_LOG(INFO, log_id_access_terminal,
"Received a timeout while in the %s state. Going back to the ADDED state\n",
acc_term_state_name_get(p_acc_term_inst->fsm_state));
/*
* Go back to the previous state
*/
p_acc_term_inst->fsm_state = ACC_TERM_FSM_STATE_ADDED;
return ret;
}
/*****************************************************************************/
/**
* @brief The function to process a
* message from one of the BAL apps for the specified interface
*
* @param msg Pointer to a BAL message received from one of
* the BAL apps.
*
* @returns bcmos_errno
*****************************************************************************/
bcmos_errno process_interface_util_msg(void *msg)
{
bcmos_errno ret = BCM_ERR_OK;
uint32_t interface_index = INVALID_INTERFACE_INDEX;
bal_util_msg_ind *ind_msg;
acc_term_interface *p_interface_inst;
/* Parameter checks */
BUG_ON(NULL == msg);
ind_msg = (bal_util_msg_ind *)msg;
/*
* NOTE: AUTO_IND messages are not processed in this function,
* so there is no need to consider them in this logic.
*/
BCM_LOG(DEBUG, log_id_access_terminal,
" Received an interface IND message from BAL UTIL (%s)\n",
subsystem_str[bcmbal_sender_get(msg)]);
if (BCM_ERR_OK == ind_msg->status)
{
/* first get the index to the interface array from port id/type */
interface_index = bcmbal_port_type_and_id_to_interface_index(ind_msg->obj_key.if_key.intf_type,
ind_msg->obj_key.if_key.intf_id);
if (interface_index >= INVALID_INTERFACE_INDEX)
{
BCM_LOG(ERROR, log_id_interface,
"INVALID port type/id (%s/%d) to interface index (%d)\n",
interface_type_str_get(ind_msg->obj_key.if_key.intf_type),
ind_msg->obj_key.if_key.intf_id,
interface_index);
ret = BCM_ERR_PARM;
}
p_interface_inst = &(access_terminal_get()->intf_info.interface[interface_index]);
if(BCM_ERR_OK == ret)
{
/* Core calls Switch Utils to set the interface parameters using the applicable SDK call
* If a PON port is being set, then the corresponding direct connect switch port is also
* set along with it
*/
ret = sw_util_interface_set(p_interface_inst,
(p_interface_inst->api_req_int_obj_info.data.admin_state == BCMBAL_STATE_DOWN ?
BAL_UTIL_OPER_IF_DOWN : BAL_UTIL_OPER_IF_UP));
if (ret)
{
BCM_LOG(ERROR, log_id_access_terminal,
"sw_util_interface_set(() failed. rc=%s\n", bcmos_strerror(ret));
}
}
else
{
/* Error */
BCM_LOG(ERROR, log_id_interface,
"Bad interface index: interface type/id (%s/%d) (status: %s)\n",
interface_type_str_get(ind_msg->obj_key.if_key.intf_type),
ind_msg->obj_key.if_key.intf_id,
bcmos_strerror(ind_msg->status));
}
if(BCM_ERR_OK == ret)
{
BCM_LOG(DEBUG, log_id_interface,
"Setting interface (%d) to %s\n",
interface_index,
(BCMBAL_STATE_UP == p_interface_inst->api_req_int_obj_info.data.admin_state) ?
"UP" : "DOWN");
/*
* Interface SET function succeeded, so copy the API request into the
* current interface object.
*/
bcmbal_interface_object_overlay_w_src_priority(&(p_interface_inst->current_int_obj_info),&(p_interface_inst->api_req_int_obj_info));
/* Set the status of the current interface that we just configured to the requested state (UP or DOWN) */
BCMBAL_CFG_PROP_SET(&p_interface_inst->current_int_obj_info,
interface,
oper_status,
bcmbal_get_intf_oper_status_from_admin_state(p_interface_inst->api_req_int_obj_info.data.admin_state));
}
else
{
/* Error */
BCM_LOG(ERROR, log_id_interface,
"Bad response from switch: Interface type/Id: %s/%d (status:%s) \n",
interface_type_str_get(ind_msg->obj_key.if_key.intf_type),
ind_msg->obj_key.if_key.intf_id,
bcmos_strerror(ind_msg->status));
}
}
else
{
/* Error */
BCM_LOG(ERROR, log_id_interface,
"Bad interface indication from MAC (status:%s)\n",
bcmos_strerror(ind_msg->status));
}
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_interface_inst->current_int_obj_info), BCMOS_FALSE);
/*
* Send the indication back to the BAL public API here
*/
mgmt_msg_send_balapi_ind(ret,
(void *)&(p_interface_inst->current_int_obj_info.hdr),
log_id_interface);
return ret;
}
/*****************************************************************************/
/**
* @brief The Access terminal FSM function which is executed when an error
* is encountered during FSM processing.
*
* @param p_acc_term_inst Pointer to an access terminal instance
* @param msg Pointer to a BAL message (MAY BE NULL!)
* @param p_event Pointer to an access terminal event structure
*
* @returns bcmos_errno
*****************************************************************************/
static bcmos_errno acc_term_fsm_state_err(acc_term_inst *p_acc_term_inst,
void *msg,
acc_term_fsm_event *p_event)
{
bcmos_errno ret = BCM_ERR_INVALID_OP;
BCM_LOG(ERROR, log_id_access_terminal,
"Error encountered processing FSM - BAD EVENT event:%s, state:%s\n",
acc_term_event_name_get(p_event->event_type),
acc_term_state_name_get(p_acc_term_inst->fsm_state));
return ret;
}
/*****************************************************************************/
/**
* @brief A function called by the core worker thread to process an
* access-terminal object message (SET, GET, CLEAR, STATS) received
* from the BAL Public API.
*
* @param msg_payload Pointer to a BAL message received from the
* BAL Public API.
*
* @returns bcmos_errno
*****************************************************************************/
bcmos_errno process_access_terminal_object(void *msg_payload)
{
bcmos_errno ret = BCM_ERR_OK, rsp_ret = BCM_ERR_OK;
acc_term_inst *p_access_terminal_inst;
acc_term_fsm_event acc_term_event;
bcmbal_obj_msg_type oper_type;
/* Parameter checks */
BUG_ON(NULL == msg_payload);
BCM_LOG(DEBUG, log_id_access_terminal,
"Processing an access-terminal object\n");
do
{
/*
* Find or create the specified access terminal instance
*/
p_access_terminal_inst = access_terminal_get();
oper_type = ((bcmbal_access_terminal_cfg *)msg_payload)->hdr.hdr.type;
/* If the state of the access-terminal is in flux, then reject the SET request */
if(BCMBAL_OBJ_MSG_TYPE_SET == oper_type &&
BCMOS_TRUE == BCMBAL_OBJ_IN_PROGRESS_GET(&(p_access_terminal_inst->current_acc_term_obj_info)))
{
BCM_LOG(ERROR, log_id_access_terminal,
"The access-terminal is in-progress, SETs are not allowed\n");
ret = BCM_ERR_IN_PROGRESS;
break;
}
/* Copy the object in the message into local storage */
memcpy(&p_access_terminal_inst->api_req_acc_term_obj_info,
msg_payload,
sizeof(p_access_terminal_inst->api_req_acc_term_obj_info));
BCM_LOG(DEBUG, log_id_access_terminal,
"access_terminal admin state is: %s\n",
(BCMBAL_STATE_UP == p_access_terminal_inst->api_req_acc_term_obj_info.data.admin_state) ?
"UP" : "DOWN");
/*
* A message pointer is always passed inside the event structure.
*/
acc_term_event.msg = msg_payload;
/* SET or GET or ...? */
switch (oper_type)
{
case (BCMBAL_OBJ_MSG_TYPE_SET):
{
BCM_LOG(DEBUG, log_id_access_terminal,
"Processing a access-terminal SET REQ mgmt message\n");
/*
* Check if the mandatory access-terminal attributes have been set
*/
do
{
/* The admin state attribute is mandatory */
if(BCMOS_FALSE == BCMBAL_CFG_PROP_IS_SET(&p_access_terminal_inst->api_req_acc_term_obj_info,
access_terminal,
admin_state))
{
ret = BCM_ERR_MANDATORY_PARM_IS_MISSING;
break;
}
/*set iwf_mode from the global config parameters*/
BCMBAL_CFG_PROP_SET(&p_access_terminal_inst->api_req_acc_term_obj_info,
access_terminal,
iwf_mode,
bcmbal_config_get()->iwf_mode);
/*
* Perform the validation check(s) that the utils require
*/
if(BCM_ERR_OK !=
(ret = mac_util_access_terminal_info_validate(&p_access_terminal_inst->api_req_acc_term_obj_info)))
{
break;
}
}
while(0);
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
rsp_ret = mgmt_msg_send_balapi_rsp(ret,
msg_payload,
oper_type,
log_id_access_terminal);
if(BCM_ERR_OK != rsp_ret || BCM_ERR_OK != ret)
{
/* the mgmt_msg_send_balapi_rsp function above logs any errors that occur there */
ret = (BCM_ERR_OK != rsp_ret) ? rsp_ret : ret;
break;
}
/* Reflect the admin state of the access-terminal according to the commanded admin state */
BCMBAL_CFG_PROP_SET(&p_access_terminal_inst->current_acc_term_obj_info,
access_terminal,
admin_state,
p_access_terminal_inst->api_req_acc_term_obj_info.data.admin_state);
if(BCMBAL_STATE_UP == p_access_terminal_inst->api_req_acc_term_obj_info.data.admin_state)
{
acc_term_event.event_type = ACC_TERM_FSM_EVENT_TYPE_ADMIN_UP;
}
else
{
acc_term_event.event_type = ACC_TERM_FSM_EVENT_TYPE_ADMIN_DN;
}
/*
* Run the access terminal FSM to process this event
*/
ret = access_terminal_fsm_exec(p_access_terminal_inst, &acc_term_event);
break;
}
case (BCMBAL_OBJ_MSG_TYPE_GET):
{
BCM_LOG(DEBUG, log_id_access_terminal,
"Processing a access-terminal GET REQ mgmt message\n");
p_access_terminal_inst->current_acc_term_obj_info.hdr.hdr.comm_hdr = ((bcmbal_obj *)msg_payload)->comm_hdr;
*((bcmbal_access_terminal_cfg *)msg_payload) = p_access_terminal_inst->current_acc_term_obj_info;
mgmt_msg_send_balapi_rsp(ret,
msg_payload,
oper_type,
log_id_access_terminal);
break;
}
default:
{
BCM_LOG(ERROR, log_id_access_terminal,
"Unsupported operation on access-terminal object (%d)\n",
bcmbal_msg_id_oper_get(msg_payload));
ret = BCM_ERR_NOT_SUPPORTED;
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_access_terminal);
break;
}
}
}while(0);
return ret;
}
/*****************************************************************************/
/**
* @brief A function to retrieve an access-terminal instance
*
* @returns acc_term_inst_t* A pointer to the found access-terminal instance,
* or NULL if one is not found.
*****************************************************************************/
static acc_term_inst *access_terminal_get(void)
{
acc_term_inst *p_acc_term = (acc_term_inst *)NULL;
p_acc_term = &single_access_terminal_instance;
return p_acc_term;
}
/*****************************************************************************/
/**
* @brief A function to retrieve the status of the access-terminal
*
*
* @returns bcmbal_status
*****************************************************************************/
bcmbal_status acc_term_status_get(void)
{
acc_term_inst *p_acc_term_inst;
p_acc_term_inst = access_terminal_get();
return p_acc_term_inst->current_acc_term_obj_info.data.oper_status;
}
static bcmos_errno interface_tm_sched_set(bcmbal_interface_cfg *p_interface_info)
{
bcmos_errno ret = BCM_ERR_OK;
tm_sched_inst *p_tm_sched_inst;
bcmbal_tm_sched_key tm_key;
switch(p_interface_info->key.intf_type)
{
case BCMBAL_INTF_TYPE_PON:
{
/*for active pon interface:
ds_tm should be define, - if it is set, validate sched exist and match direction (ds)
if not set - will create auto created tm */
if(BCMBAL_CFG_PROP_IS_SET(p_interface_info,interface,ds_tm))
{
tm_key.dir = BCMBAL_TM_SCHED_DIR_DS;
tm_key.id = p_interface_info->data.ds_tm;
p_tm_sched_inst = tm_sched_inst_get(tm_key, TM_SCHED_FLAG_ACTIVE);
if (NULL == p_tm_sched_inst)
{
BCM_LOG(ERROR, log_id_interface, "there is no ds tm sched with id %d", tm_key.id);
ret = BCM_ERR_NOENT;
break;
}
ret = bcmbal_tm_sched_set_interface_owner(p_interface_info->key, p_tm_sched_inst);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set interface %d as owner of tm sched %d",
p_interface_info->key.intf_id, tm_key.id);
break;
}
}
else /*auto created sched was removed and no other default sched was set*/
{
BCM_LOG(ERROR, log_id_interface, "default tm node must be set! ");
ret = BCM_ERR_MANDATORY_PARM_IS_MISSING;
break;
}
/* us_tm is optional - if it is set, validate sched exist and match direction (us)*/
if(BCMBAL_CFG_PROP_IS_SET(p_interface_info, interface, us_tm))
{
tm_key.dir = BCMBAL_TM_SCHED_DIR_US;
tm_key.id = p_interface_info->data.us_tm;
p_tm_sched_inst = tm_sched_inst_get(tm_key, TM_SCHED_FLAG_ACTIVE);
if (NULL == p_tm_sched_inst)
{
BCM_LOG(ERROR, log_id_interface, "there is no us tm sched with id %d", tm_key.id);
ret = BCM_ERR_NOENT;
break;
}
ret = bcmbal_tm_sched_set_interface_owner(p_interface_info->key, p_tm_sched_inst);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set interface %d as owner of tm sched %d",
p_interface_info->key.intf_id, tm_key.id);
break;
}
}
}
break;
case BCMBAL_INTF_TYPE_NNI:
{
/*for active nni interface:
us_tm should be define, -
if it is set, validate sched exist and match direction (us)
if not set - will create auto created tm
*/
if(BCMBAL_CFG_PROP_IS_SET(p_interface_info, interface, us_tm))
{
tm_key.dir = BCMBAL_TM_SCHED_DIR_US;
tm_key.id = p_interface_info->data.us_tm;
p_tm_sched_inst = tm_sched_inst_get(tm_key, TM_SCHED_FLAG_ACTIVE);
if (NULL == p_tm_sched_inst)
{
BCM_LOG(ERROR, log_id_interface, "there is no us tm sched with id %d", tm_key.id);
ret = BCM_ERR_NOENT;
break;
}
ret = bcmbal_tm_sched_set_interface_owner(p_interface_info->key, p_tm_sched_inst);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set interface %d as owner of tm sched %d",
p_interface_info->key.intf_id, tm_key.id);
break;
}
}
else /*auto created sched was removed and no other default sched was set*/
{
BCM_LOG(ERROR, log_id_interface, "default tm node must be set! ");
break;
}
/* ds_tm is optional - if it is set, validate sched exist and match direction (ds)*/
if(BCMBAL_CFG_PROP_IS_SET(p_interface_info, interface, ds_tm))
{
tm_key.dir = BCMBAL_TM_SCHED_DIR_DS;
tm_key.id = p_interface_info->data.ds_tm;
p_tm_sched_inst = tm_sched_inst_get(tm_key, TM_SCHED_FLAG_ACTIVE);
if (NULL == p_tm_sched_inst)
{
BCM_LOG(ERROR, log_id_interface, "there is no ds tm sched with id %d", tm_key.id);
ret = BCM_ERR_NOENT;
break;
}
ret = bcmbal_tm_sched_set_interface_owner(p_interface_info->key, p_tm_sched_inst);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set interface %d as owner of tm sched %d",
p_interface_info->key.intf_id, tm_key.id);
break;
}
}
}
break;
default:
BCM_LOG(ERROR, log_id_interface, "Invalid intf type (%d) in interface key\n",
p_interface_info->key.intf_type);
ret = BCM_ERR_PARM;
}
return ret;
}
bcmos_errno interface_tm_sched_unset(bcmbal_interface_key intf_key, bcmbal_tm_sched_key sched_key)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_interface *p_acc_term_interface = bcmbal_interface_get(intf_key);
do
{
if(NULL == p_acc_term_interface)
{
BCM_LOG(ERROR, log_id_interface, "no such interface (id = %d dir = %s ) \n",
intf_key.intf_id, interface_type_str_get(intf_key.intf_type));
ret = BCM_ERR_INTERNAL;
break;
}
if (BCMBAL_TM_SCHED_DIR_US == sched_key.dir)
{
BCMBAL_CFG_PROP_CLEAR(&(p_acc_term_interface->current_int_obj_info), interface, us_tm);
}
else
{
BCMBAL_CFG_PROP_CLEAR(&(p_acc_term_interface->current_int_obj_info), interface, ds_tm);
}
}while(0);
return ret;
}
/*****************************************************************************/
/**
* @brief A function to process an interface object message
* (SET, GET, CLEAR, STATS) received from the BAL Public API.
*
* @param msg_payload Pointer to a BAL message received from the
* BAL Public API.
*
* @returns bcmos_errno
*****************************************************************************/
bcmos_errno process_interface_object(void *msg_payload)
{
bcmos_errno ret = BCM_ERR_OK;
bcmbal_interface_cfg *p_intf_cfg = (bcmbal_interface_cfg *)msg_payload;
bcmbal_interface_key *p_intf_key;
acc_term_inst *p_access_terminal_inst;
bcmbal_interface_cfg *p_api_req_interface_info;
bcmbal_interface_cfg *p_current_interface_info;
uint32_t interface_index = INVALID_INTERFACE_INDEX;
bcmbal_obj_msg_type oper_type;
BCM_LOG(DEBUG, log_id_interface,
"Processing an interface object\n");
do
{
do
{
oper_type = p_intf_cfg->hdr.hdr.type;
/*
* See if the access terminal is active
*/
p_access_terminal_inst = access_terminal_get();
if(NULL == p_access_terminal_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,
"the access-terminal is not active\n");
ret = BCM_ERR_NOENT;
break;
}
/* If the state of the access-terminal is in flux, then reject the SET request */
if(BCMBAL_OBJ_MSG_TYPE_SET == oper_type &&
BCMOS_TRUE == BCMBAL_OBJ_IN_PROGRESS_GET(&(p_access_terminal_inst->current_acc_term_obj_info)))
{
BCM_LOG(ERROR, log_id_access_terminal,
"The access-terminal is in-progress, SETs to an interface are not allowed\n");
ret = BCM_ERR_IN_PROGRESS;
break;
}
/*
* Get the interface key from the message
*/
p_intf_key = &p_intf_cfg->key;
if (p_intf_key->intf_type == BCMBAL_INTF_TYPE_PON)
{
if(p_intf_key->intf_id > NUM_SUPPORTED_SUBSCRIBER_INTERFACES)
{
BCM_LOG(ERROR, log_id_interface,
"out of range value (%d) detected in interface key for PON\n", p_intf_key->intf_id);
ret = BCM_ERR_RANGE;
break;
}
}
/** @todo check the lower limit also */
else if (p_intf_key->intf_type == BCMBAL_INTF_TYPE_NNI)
{
if( BCMOS_FALSE == bcm_topo_nni_is_valid(p_intf_key->intf_id))
{
BCM_LOG(ERROR, log_id_interface,
"out of range value (%d) detected in interface key for NNI\n", p_intf_key->intf_id);
ret = BCM_ERR_RANGE;
break;
}
}
else
{
BCM_LOG(ERROR, log_id_interface,
"Invalid intf type (%d) in interface key\n", p_intf_key->intf_type);
ret = BCM_ERR_PARM;
break;
}
/*
* Don't accept interface object references when the associated access-terminal is down
*
* Interfaces are not even instantiated internally until the access-terminal object to which
* they belong is instantiated.
*/
if(BCMBAL_STATE_DOWN == p_access_terminal_inst->current_acc_term_obj_info.data.admin_state)
{
BCM_LOG(INFO, log_id_interface,
"access terminal admin-state is DOWN\n");
ret = BCM_ERR_INVALID_OP;
break;
}
/* Get the index to the interface array from port id/type */
interface_index = bcmbal_port_type_and_id_to_interface_index (p_intf_key->intf_type, p_intf_key->intf_id);
if (interface_index >= INVALID_INTERFACE_INDEX)
{
BCM_LOG(ERROR, log_id_access_terminal,
"INVALID port type/id (%s/%d) to interface index (%d) for access terminal\n",
interface_type_str_get(p_intf_key->intf_type), p_intf_key->intf_id, interface_index);
ret = BCM_ERR_PARM;
break;
}
/*
* This is a pointer to the "API interface" structure
*/
p_api_req_interface_info =
&(p_access_terminal_inst->intf_info.interface[interface_index].api_req_int_obj_info);
/*
* This is a pointer to the "current interface" structure
*/
p_current_interface_info =
&(p_access_terminal_inst->intf_info.interface[interface_index].current_int_obj_info);
/* If the state of the interface is in flux, then reject the SET request */
if(BCMBAL_OBJ_MSG_TYPE_SET == oper_type &&
(BCMOS_TRUE == BCMBAL_OBJ_IN_PROGRESS_GET(p_current_interface_info)))
{
BCM_LOG(ERROR, log_id_access_terminal,
"The interface is in-progress, SETs are not allowed\n");
ret = BCM_ERR_IN_PROGRESS;
break;
}
}while(0);
if(BCM_ERR_OK != ret)
{
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_interface);
break;
}
/*
* Fill in the interface info SET data structure
*/
*p_api_req_interface_info = *p_intf_cfg;
BCM_LOG(DEBUG, log_id_interface,
" interface object state from API message is: %d, intf_type: %s intf_id: %d\n",
p_api_req_interface_info->data.admin_state,
interface_type_str_get(p_api_req_interface_info->key.intf_type),
p_api_req_interface_info->key.intf_id);
/* SET or GET or ...? */
switch (oper_type)
{
case (BCMBAL_OBJ_MSG_TYPE_SET):
{
BCM_LOG(DEBUG, log_id_interface,
"Processing an interface SET REQ mgmt message\n");
/*if sched is already set, can not change sched setting using set command, should first delete current sched*/
if(BCMBAL_CFG_PROP_IS_SET(p_current_interface_info,interface,ds_tm)
&& BCMBAL_CFG_PROP_IS_SET(p_api_req_interface_info,interface,ds_tm))
{
BCM_LOG(ERROR, log_id_interface,
"ds_tm %d is already set at interface, it should be first cleared in order to be replaced \n",
p_current_interface_info->data.ds_tm);
ret = BCM_ERR_ALREADY;
break;
}
if(BCMBAL_CFG_PROP_IS_SET(p_current_interface_info,interface,us_tm)
&& BCMBAL_CFG_PROP_IS_SET(p_api_req_interface_info,interface,us_tm))
{
BCM_LOG(ERROR, log_id_interface,
"us_tm %d is already set at interface, it should be first cleared in order to be replaced \n",
p_current_interface_info->data.us_tm);
ret = BCM_ERR_ALREADY;
break;
}
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
ret = mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_interface);
if(BCM_ERR_OK != ret)
{
break;
}
/* If this interface is already up, then just return OK */
if(BCMBAL_STATE_UP == p_api_req_interface_info->data.admin_state)
{
if(BCMBAL_STATUS_UP == p_current_interface_info->data.oper_status)
{
BCM_LOG(DEBUG, log_id_interface,
"=====> Received an interface UP for an already UP interface, returning OK\n");
break;
}
/*validate and set the interface' tm sched*/
bcmbal_interface_object_overlay_w_dst_priority(p_api_req_interface_info,p_current_interface_info);
ret = interface_tm_sched_set(p_api_req_interface_info);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface,"Could not set the interface tm sched\n");
break;
}
interface_admin_up_start(&(p_access_terminal_inst->intf_info.interface[interface_index]),
msg_payload);
}
else
{
if(BCMBAL_STATUS_DOWN == p_current_interface_info->data.oper_status)
{
BCM_LOG(DEBUG, log_id_interface,
"=====> Received an interface DOWN for an already DOWN interface, returning OK\n");
break;
}
interface_admin_dn_start(&(p_access_terminal_inst->intf_info.interface[interface_index]),
msg_payload);
}
break;
}
case (BCMBAL_OBJ_MSG_TYPE_GET):
{
BCM_LOG(DEBUG, log_id_interface,
"Processing a interface GET REQ mgmt message\n");
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
p_current_interface_info->hdr.hdr.comm_hdr = ((bcmbal_obj *)msg_payload)->comm_hdr;
bcmbal_sub_id_list_u16 sub_term_id_list = {};
BCMBAL_CFG_PROP_CLEAR(p_current_interface_info,
interface,
sub_term_id_list);
/* If the user requested the list of sub_term_ids for this interface,
* and this is a PON interface, then return the list.
*/
if(BCMBAL_CFG_PROP_IS_SET(p_api_req_interface_info,
interface,
sub_term_id_list))
{
if(BCMBAL_INTF_TYPE_PON == p_current_interface_info->key.intf_type)
{
sub_term_id_list_fill(interface_index, &sub_term_id_list);
/* NOTE: The returned list may be empty */
BCMBAL_CFG_PROP_SET(p_current_interface_info,
interface,
sub_term_id_list,
sub_term_id_list);
}
}
*((bcmbal_interface_cfg *)msg_payload) = *p_current_interface_info;
mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_interface);
/* Free the temporary list if it was used */
if(sub_term_id_list.val)
{
bcmos_free(sub_term_id_list.val);
}
break;
}
default:
{
BCM_LOG(ERROR, log_id_interface,
"Unsupported operation on interface object (%d)\n",
bcmbal_msg_id_oper_get(msg_payload));
ret = BCM_ERR_NOT_SUPPORTED;
/* We respond to the BAL public API backend with a result. We always
* send a complete msg_payload back to the API, but the data portion
* of the object is only relevant when a GET or GET-STATS has been requested.
*/
mgmt_msg_send_balapi_rsp(ret, msg_payload, oper_type, log_id_interface);
break;
}
}
}while (0);
return ret;
}
/*****************************************************************************/
/**
* @brief A function called to initialize a single access-terminal instance.
* NOTE: This is called once on startup and NOT for each FSM instance.
*
* @param p_acc_term_inst Pointer to an access terminal instance
*
* @returns void
*****************************************************************************/
static void initialize_access_terminal_instance_config(acc_term_inst *p_acc_term_inst)
{
int ii;
int intf_id;
bcmos_errno ret;
BUG_ON(NULL == p_acc_term_inst);
p_acc_term_inst->current_acc_term_obj_info.key.access_term_id = 0;
BCMBAL_CFG_INIT(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
p_acc_term_inst->current_acc_term_obj_info.key);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
admin_state,
BCMBAL_STATE_DOWN);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
oper_status,
BCMBAL_STATUS_DOWN);
BCMBAL_PROP_SET_PRESENT(&p_acc_term_inst->current_acc_term_obj_info,
access_terminal,
_cfg,
iwf_mode);
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->current_acc_term_obj_info), BCMOS_FALSE);
{
bcmbal_interface_key key;
intf_id = 0; /* reset the port id to the starting id value for the PON interfaces */
key.intf_type = BCMBAL_INTF_TYPE_PON;
for(ii=0; ii<NUM_SUPPORTED_SUBSCRIBER_INTERFACES; ii++)
{
key.intf_id = intf_id;
p_acc_term_inst->intf_info.interface[ii].num_sub_terms_on_int = 0;
TAILQ_INIT(&p_acc_term_inst->intf_info.interface[ii].sub_term_id_list);
BCMBAL_CFG_INIT(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
key);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
admin_state,
BCMBAL_STATE_DOWN);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
oper_status,
BCMBAL_STATUS_DOWN);
ret = bcmbal_tm_sched_interface_tm_auto_create(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set an auto - create a tm sched for pon if %d", intf_id);
break;
}
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->intf_info.interface[ii].current_int_obj_info), BCMOS_FALSE);
intf_id++;
}
intf_id = 0; /* reset the port id to the starting id value for the NNI interfaces */
key.intf_type = BCMBAL_INTF_TYPE_NNI;
for(ii=NUM_SUPPORTED_SUBSCRIBER_INTERFACES; ii<(NUM_SUPPORTED_SUBSCRIBER_INTERFACES + bal_config_params.num_nni_ports); ii++)
{
key.intf_id = intf_id;
BCMBAL_CFG_INIT(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
key);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
admin_state,
BCMBAL_STATE_UP);
BCMBAL_CFG_PROP_SET(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info,
interface,
oper_status,
BCMBAL_STATUS_UP);
ret = bcmbal_tm_sched_interface_tm_auto_create(&p_acc_term_inst->intf_info.interface[ii].current_int_obj_info);
if(BCM_ERR_OK != ret)
{
BCM_LOG(ERROR, log_id_interface, "could not set an auto - create a tm sched for nni if %d", intf_id);
break;
}
BCMBAL_OBJ_IN_PROGRESS_SET(&(p_acc_term_inst->intf_info.interface[ii].current_int_obj_info), BCMOS_FALSE);
intf_id++;
}
}
}
bcmos_errno bcmbal_interface_sub_term_list_entry_add(bcmbal_subscriber_terminal_key sub_term_key)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_inst *p_access_terminal_inst;
sub_term_id_entry *current_entry;
acc_term_interface *p_interface;
p_access_terminal_inst = access_terminal_get();
do
{
/*
* If the specified access terminal is not active then it's interfaces are down.
*/
if(NULL == p_access_terminal_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,
"no such ACTIVE access terminal\n");
ret = BCM_ERR_STATE;
break;
}
p_interface = &p_access_terminal_inst->intf_info.interface[sub_term_key.intf_id];
/* Check if the id is already on the list before adding it */
TAILQ_FOREACH(current_entry,
&p_interface->sub_term_id_list,
next)
{
if(current_entry->sub_term_id == sub_term_key.sub_term_id)
{
return BCM_ERR_ALREADY;
}
}
/* Get a new entry and configure it */
current_entry = bcmos_calloc(sizeof(sub_term_id_entry));
if (NULL == current_entry)
{
BCM_LOG(ERROR, log_id_access_terminal,
"No memory available\n");
ret = BCM_ERR_NOMEM;
break;
}
current_entry->sub_term_id = sub_term_key.sub_term_id;
BCM_LOG(INFO, log_id_access_terminal,
"adding sub_term id %u to interface %u\n", sub_term_key.sub_term_id, sub_term_key.intf_id);
/* Save the entry on the list of subscriber-terminal ids on this interface */
TAILQ_INSERT_TAIL(&p_interface->sub_term_id_list,
current_entry, next);
(p_interface->num_sub_terms_on_int)++;
} while (0);
return ret;
}
bcmos_errno bcmbal_interface_sub_term_list_entry_remove(bcmbal_subscriber_terminal_key sub_term_key)
{
bcmos_errno ret = BCM_ERR_NOENT;
acc_term_inst *p_access_terminal_inst;
acc_term_interface *p_interface;
sub_term_id_entry *current_entry, *p_temp_entry;
do
{
p_access_terminal_inst = access_terminal_get();
/*
* If the specified access terminal is not active then it's interfaces are down.
*/
if(NULL == p_access_terminal_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,
"no such ACTIVE access terminal\n");
ret = BCM_ERR_STATE;
break;
}
p_interface = &p_access_terminal_inst->intf_info.interface[sub_term_key.intf_id];
/* Check if the id is on the list */
TAILQ_FOREACH_SAFE(current_entry,
&p_interface->sub_term_id_list,
next,
p_temp_entry)
{
if(current_entry->sub_term_id == sub_term_key.sub_term_id)
{
/* Remove it from the list of subscriber-terminal ids on this interface */
TAILQ_REMOVE(&p_interface->sub_term_id_list,
current_entry, next);
bcmos_free(current_entry);
(p_interface->num_sub_terms_on_int)--;
ret = BCM_ERR_OK;
break;
}
}
} while (0);
return ret;
}
static bcmos_errno sub_term_id_list_fill(uint32_t interface_index,
bcmbal_sub_id_list_u16 *sub_term_id_list)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_inst *p_acc_term_inst;
sub_term_id_entry *current_entry = NULL;
int ii = 0;
do
{
/*
* See if the access-terminal is active
*/
p_acc_term_inst = access_terminal_get();
/*
* If the specified access terminal is not active then it's interfaces are down.
*/
if(NULL == p_acc_term_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,
"no such ACTIVE access terminal\n");
ret = BCM_ERR_NOENT;
break;
}
/* Traverse the list of sub_term_ids recorded and fill in the list to be returned */
sub_term_id_list->len = p_acc_term_inst->intf_info.interface[interface_index].num_sub_terms_on_int;
sub_term_id_list->val = bcmos_calloc(sizeof(bcmbal_sub_id) * sub_term_id_list->len);
if (NULL == sub_term_id_list->val)
{
BCM_LOG(ERROR, log_id_access_terminal,
"No memory available\n");
ret = BCM_ERR_NOMEM;
break;
}
TAILQ_FOREACH(current_entry,
&p_acc_term_inst->intf_info.interface[interface_index].sub_term_id_list,
next)
{
BCM_LOG(DEBUG, log_id_access_terminal,
"adding sub_term_id %u to response at array location %u\n",
current_entry->sub_term_id,
ii);
sub_term_id_list->val[ii++] = current_entry->sub_term_id;
}
} while (0);
return ret;
}
bcmos_errno bcmbal_interface_tm_get(bcmbal_interface_key key, bcmbal_tm_sched_id *id)
{
bcmos_errno ret = BCM_ERR_OK;
acc_term_inst *p_acc_term_inst;
uint32_t interface_index = INVALID_INTERFACE_INDEX;
do
{
/* See if the access-terminal is active */
p_acc_term_inst = access_terminal_get();
/* If the specified access terminal is not active then it's interfaces are down. */
if(NULL == p_acc_term_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,"no such ACTIVE access terminal\n");
ret = BCM_ERR_NOT_CONNECTED;
break;
}
/* If the specified access terminal is down, then it's interfaces are down. */
if(BCMBAL_STATE_UP != p_acc_term_inst->current_acc_term_obj_info.data.admin_state)
{
ret = BCM_ERR_NOT_CONNECTED;
break;
}
/* first get the index to the interface array from port id/type */
interface_index = bcmbal_port_type_and_id_to_interface_index (key.intf_type, key.intf_id);
if (interface_index >= INVALID_INTERFACE_INDEX)
{
BCM_LOG(ERROR, log_id_access_terminal,"INVALID port type/id (%s/%d) to interface index (%d)\n",
interface_type_str_get(key.intf_type), key.intf_id, interface_index);
ret = BCM_ERR_INTERNAL;
break;
}
/* Retrieve the relevany default tm sched of the interface */
if (BCMBAL_INTF_TYPE_NNI == key.intf_type)
{
*id = p_acc_term_inst->intf_info.interface[interface_index].current_int_obj_info.data.us_tm;
}
else /*BCMBAL_INTF_TYPE_PON */
{
*id = p_acc_term_inst->intf_info.interface[interface_index].current_int_obj_info.data.ds_tm;
}
}while(0);
return ret;
}
/*****************************************************************************/
/**
* @brief A function that returns the status of the specified interface object
*
* @param key An interface instance key
*
* @returns bcmbal_state
*****************************************************************************/
bcmbal_status bcmbal_interface_status_get(bcmbal_interface_key key)
{
bcmbal_state intf_status = BCMBAL_STATUS_DOWN;
acc_term_interface *p_acc_term_interface = bcmbal_interface_get(key);
if(NULL == p_acc_term_interface)
{
BCM_LOG(ERROR, log_id_access_terminal,"no such interface\n");
}
else
{
intf_status = p_acc_term_interface->current_int_obj_info.data.oper_status;
}
return intf_status;
}
/*****************************************************************************/
/**
* @brief A function that returns the interface object
*
* @param key An interface instance key
*
* @returns acc_term_interface *p_acc_term_interface a pointer to the interface object
*****************************************************************************/
static acc_term_interface * bcmbal_interface_get(bcmbal_interface_key key)
{
acc_term_inst *p_acc_term_inst = NULL;
acc_term_interface *p_acc_term_interface = NULL;
uint32_t interface_index = INVALID_INTERFACE_INDEX;
do
{
/*
* See if the access-terminal is active
*/
p_acc_term_inst = access_terminal_get();
/*
* If the specified access terminal is not active then it's interfaces are down.
*/
if(NULL == p_acc_term_inst)
{
BCM_LOG(ERROR, log_id_access_terminal,
"no such ACTIVE access terminal\n");
break;
}
/*
* Retrieve the interface
*/
/* first get the index to the interface array from port id/type */
interface_index = bcmbal_port_type_and_id_to_interface_index (key.intf_type, key.intf_id);
if (interface_index >= INVALID_INTERFACE_INDEX)
{
BCM_LOG(ERROR, log_id_access_terminal,
"INVALID port type/id (%s/%d) to interface index (%d)\n",
interface_type_str_get(key.intf_type), key.intf_id, interface_index);
break;
}
p_acc_term_interface = &(p_acc_term_inst->intf_info.interface[interface_index]);
}while(0);
return p_acc_term_interface;
}
static char *interface_type_str_get(bcmbal_intf_type intf_type)
{
return intf_type == BCMBAL_INTF_TYPE_NNI ? "NNI" :
intf_type == BCMBAL_INTF_TYPE_PON ? "PON" : "UNKNOWN TYPE";
}
/*@}*/