Gitiles
Code Review Sign In
gerrit.opencord.org / voltha-bal / 2f7f9be8941af148780a5b9a653ea1fa527070b3 / . / bal_release / src / core / util / switch / bal_switch_acc_term.c
blob: fb1be7bd3915d489d3a11ceba9e8dba8518fc59c [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.
*
* :>
*
*****************************************************************************/
#include <bal_common.h>
#include <bcm_dev_log.h>
#include <bal_msg.h>
#include "bal_switch_util.h"
#include "bal_switch_acc_term.h"
#include "bal_switch_flow.h"
#include <bal_worker.h>
/* declare ENV so that the bcm/rx.h in the bal_dpp_acc_term.h can create the correct bcm_pkt_t structure */
#ifdef ESW_SWITCH
#define BCM_ESW_SUPPORT 1
#else
#define BCM_DNX_SUPPORT 1
#endif
#include "esw/bal_esw_acc_term.h"
#include "dpp/bal_dpp_acc_term.h"
/* Below local functions are used for real logic only */
#ifndef TEST_SW_UTIL_LOOPBACK
#include <arpa/inet.h>
#include <bcm/init.h>
#include <bcm/types.h>
#include <bcm/port.h>
#include <appl/diag/shell.h> /* for .soc loading */
extern int socdiag_main(int argc, char *argv[]);
/**
* @file bal_switch_acc_term.c
* @brief BAL Switch util functions that handle access terminal requests
* @addtogroup sw_util
*
*/
/*@{*/
/* forward declaration */
static void sw_util_bcm_rx_cb (int unit, int port, int reason, unsigned char *p_payload, int payload_len);
/* define a customized dpp packetIn receive registration function.
* This function will be called when the HW trap a CPU bound packet
*/
static bcm_rx_t dpp_rx_cb_register(int unit, bcm_pkt_t *pkt, void *cookie)
{
int src_port, reason_code, payload_len;
unsigned char *p_payload;
/* extract trap code, ingress port and payload info */
src_port = pkt->src_port & 0xff;
reason_code = pkt->rx_trap_data;
p_payload = pkt->_pkt_data.data + (pkt->tot_len - pkt->pkt_len);
payload_len = pkt->pkt_len;
/* call sw_util_bcm_rx_cb to send packet to the BAL client */
sw_util_bcm_rx_cb(unit, src_port, reason_code, p_payload, payload_len);
return BCM_RX_HANDLED;
}
/* The default switch device the switch app is managed */
#ifdef CONFIG_SWITCH_RPC
static uint32_t g_dft_dev_id = 2;
#else
static uint32_t g_dft_dev_id = 0;
#endif
static uint32_t g_iwf_mode = 0;
static uint32_t g_l2_age_time = 300;
/* flag to determine if we need RPC for switch communication */
#ifdef CONFIG_SWITCH_RPC
static uint32_t g_use_rpc = 1;
#else
static uint32_t g_use_rpc = 0;
#endif
/* Socket to be connected to the switch driver msg receiving UDP port */
bcmos_bool g_pkt_send_is_initialized = BCMOS_FALSE;
static trap_target s_target_device;
/* Index to determine which interface mapping table should be used.
* The mapping table is HW specific and depend on how physical wires are lay out
* Any customized board may need a different table entry to reflect the connections
*/
static bal_swapp_port_map_indx g_intf_maptable = BAL_SWAPP_PORT_MAP_GPON;
/* the logical interface to KT2 port mapping table
the tables is index by technology then logical interface number that used in the BAL CLI
the data is the switch port-bit-map number and device number
*/
/* table with gpon technology
based on KT2 port config option 4 - see page 22 on KT2 data sheet */
/* gpon network interface mapping -
* KT2 is for Broadcom experiment purpose - not all function will work */
bal_swapp_port net_inf_map_gpon[] = {
{ 27, /* xe0 */ 0},
{ 28, /* xe1 */ 0},
{ 30, /* xe2 */ 0},
{ 33, /* xe3 */ 0},
{ 40, /* ge24 */ 0},
{ -1, /* end */ 0}
};
/* ARAD temp mapping xe128 - xe131 as nni ports */
/* ARAD is for Broadcom experiment purpose - not all function will work */
bal_swapp_port net_inf_map_exp[] = {
{ 128, /* xe128 */ 0},
{ 129, /* xe129 */ 0},
{ 130, /* xe130 */ 0},
{ 131, /* xe131 */ 0},
{ -1, /* end */ 0}
};
/* QAX temp mapping xe128-132 as nni ports 0-4 */
bal_swapp_port net_inf_map_exp2[] = {
{ 128, /* xe128 */ 0},
{ 129, /* xe129 */ 0},
{ 130, /* xe130 */ 0},
{ 131, /* xe131 */ 0},
{ 132, /* xe132 */ 0},
{ -1, /* end */ 0}
};
/* svk4 mapping xe128-133 as nni ports 0-5 */
bal_swapp_port net_inf_map_svk4[] = {
{ 128, /* xe128 */ 0},
{ 129, /* xe129 */ 0},
{ 130, /* xe130 */ 0},
{ 131, /* xe131 */ 0},
{ 132, /* xe132 */ 0},
{ 133, /* xe133 */ 0},
{ -1, /* end */ 0}
};
/* epon 10g-capable mapping xe128-135 as nni ports 0-7 (best guess - needs to be tested) */
bal_swapp_port net_inf_map_epon_tdma_10g[] = {
{ 128, /* xe128 */ 0},
{ 129, /* xe129 */ 0},
{ 130, /* xe130 */ 0},
{ 131, /* xe131 */ 0},
{ 132, /* xe132 */ 0},
{ 133, /* xe133 */ 0},
{ 134, /* xe134 */ 0},
{ 135, /* xe135 */ 0},
{ -1, /* end */ 0}
};
/* epon 1g only mapping - copied from gpon KT2 example above (best guess - needs to be tested) */
bal_swapp_port net_inf_map_epon_1g[] = {
{ 27, /* xe0 */ 0},
{ 28, /* xe1 */ 0},
{ 30, /* xe2 */ 0},
{ 33, /* xe3 */ 0},
{ 40, /* ge24 */ 0},
{ -1, /* end */ 0}
};
/* gpon pon interface mapping */
bal_swapp_port pon_inf_map_gpon[] = {
{ 5, /* ge4 */ 0},
{ 6, /* ge5 */ 0},
{ 2, /* ge1 */ 0},
{ 1, /* ge0 */ 0},
{ 8, /* ge7 */ 0},
{ 7, /* ge6 */ 0},
{ 4, /* ge3 */ 0},
{ 3, /* ge2 */ 0},
{ 12, /* ge11 */ 0},
{ 19, /* ge18 */ 0},
{ 10, /* ge9 */ 0},
{ 15, /* ge14 */ 0},
{ 11, /* ge10 */ 0},
{ 17, /* ge16 */ 0},
{ 9, /* ge8 */ 0},
{ 13, /* ge12 */ 0},
{ -1, /* end */ 0}
};
bal_swapp_port pon_inf_map_gpon_v3[] = {
{ 8, /* ge7 */ 0},
{ 7, /* ge6 */ 0},
{ 4, /* ge3 */ 0},
{ 3, /* ge2 */ 0},
{ 6, /* ge5 */ 0},
{ 5, /* ge4 */ 0},
{ 2, /* ge1 */ 0},
{ 1, /* ge0 */ 0},
{ 15, /* ge14 */ 0},
{ 16, /* ge15 */ 0},
{ 11, /* ge10 */ 0},
{ 12, /* ge11 */ 0},
{ 13, /* ge12 */ 0},
{ 14, /* ge13 */ 0},
{ 9, /* ge8 */ 0},
{ 10, /* ge9 */ 0},
{ -1, /* end */ 0}
};
/* ARAD temp mapping xe0 - xe3 as PON ports */
bal_swapp_port pon_inf_map_exp[] = {
{ 0, /* xe0 */ 0},
{ 1, /* xe1 */ 0},
{ 2, /* xe2 */ 0},
{ 3, /* xe3 */ 0},
{ -1, /* end */ 0}
};
/* QAX temp mapping xe1-6, as PON ports 0-5 */
bal_swapp_port pon_inf_map_exp2[] = {
{ 1, /* xe1 */ 0},
{ 2, /* xe2 */ 0},
{ 3, /* xe3 */ 0},
{ 4, /* xe4 */ 0},
{ 5, /* xe5 */ 0},
{ 6, /* xe6 */ 0},
{ -1, /* end */ 0}
};
/* svk4 mapping xe1-4, as PON ports 0-3 */
bal_swapp_port pon_inf_map_svk4[] = {
{ 1, /* xe1 */ 0},
{ 2, /* xe2 */ 0},
{ 3, /* xe3 */ 0},
{ 4, /* xe4 */ 0},
{ -1, /* end */ 0}
};
/* epon 10g-capable mapping xe1-8, as PON ports 0-7 (best guess - untested) */
bal_swapp_port pon_inf_map_epon_tdma_10g[] = {
{ 1, /* xe1 */ 0},
{ 2, /* xe2 */ 0},
{ 3, /* xe3 */ 0},
{ 4, /* xe4 */ 0},
{ 5, /* xe5 */ 0},
{ 6, /* xe6 */ 0},
{ 7, /* xe7 */ 0},
{ 8, /* xe8 */ 0},
{ -1, /* end */ 0}
};
/* epon 1g mapping xe1-16, as PON ports 0-15 (best guess - untested) */
bal_swapp_port pon_inf_map_epon_1g[] = {
{ 1, /* xe1 */ 0},
{ 2, /* xe2 */ 0},
{ 3, /* xe3 */ 0},
{ 4, /* xe4 */ 0},
{ 5, /* xe5 */ 0},
{ 6, /* xe6 */ 0},
{ 7, /* xe7 */ 0},
{ 8, /* xe8 */ 0},
{ 9, /* xe9 */ 0},
{ 10, /* xe10 */ 0},
{ 11, /* xe11 */ 0},
{ 12, /* xe12 */ 0},
{ 13, /* xe13 */ 0},
{ 14, /* xe14 */ 0},
{ 15, /* xe15 */ 0},
{ 16, /* xe16 */ 0},
{ -1, /* end */ 0}
};
/* network interface mapping table */
bal_swapp_port *g_net_inf_map_table[BAL_SWAPP_PORT_MAP__NUM_OF] = {
net_inf_map_gpon, /* BAL_SWAPP_PORT_MAP_GPON */
net_inf_map_gpon, /* BAL_SWAPP_PORT_MAP_GPON_V3 */
net_inf_map_exp, /* BAL_SWAPP_PORT_MAP_EXP */
net_inf_map_exp2, /* BAL_SWAPP_PORT_MAP_EXP2 */
net_inf_map_svk4, /* BAL_SWAPP_PORT_MAP_SVK4 */
net_inf_map_epon_tdma_10g, /* BAL_SWAPP_PORT_MAP_EPON_TDMA */
net_inf_map_epon_1g, /* BAL_SWAPP_PORT_MAP_EPON_1G */
net_inf_map_epon_tdma_10g, /* BAL_SWAPP_PORT_MAP_EPON_10G */
};
/* pon interface mapping table */
bal_swapp_port *g_pon_inf_map_table[BAL_SWAPP_PORT_MAP__NUM_OF] = {
pon_inf_map_gpon, /* BAL_SWAPP_PORT_MAP_GPON */
pon_inf_map_gpon_v3, /* BAL_SWAPP_PORT_MAP_GPON_V3 */
pon_inf_map_exp, /* BAL_SWAPP_PORT_MAP_EXP */
pon_inf_map_exp2, /* BAL_SWAPP_PORT_MAP_EXP2 */
pon_inf_map_svk4, /* BAL_SWAPP_PORT_MAP_SVK4 */
pon_inf_map_epon_tdma_10g, /* BAL_SWAPP_PORT_MAP_EPON_TDMA */
pon_inf_map_epon_1g, /* BAL_SWAPP_PORT_MAP_EPON_1G */
pon_inf_map_epon_tdma_10g, /* BAL_SWAPP_PORT_MAP_EPON_10G */
};
/* network interface mapping table size */
int g_net_inf_map_table_size[BAL_SWAPP_PORT_MAP__NUM_OF] = {
sizeof(net_inf_map_gpon)/sizeof(net_inf_map_gpon[0]), /* BAL_SWAPP_PORT_MAP_GPON */
sizeof(net_inf_map_gpon)/sizeof(net_inf_map_gpon[0]), /* BAL_SWAPP_PORT_MAP_GPON_V3 */
sizeof(net_inf_map_exp)/sizeof(net_inf_map_exp[0]), /* BAL_SWAPP_PORT_MAP_EXP */
sizeof(net_inf_map_exp2)/sizeof(net_inf_map_exp2[0]), /* BAL_SWAPP_PORT_MAP_EXP2 */
sizeof(net_inf_map_svk4)/sizeof(net_inf_map_svk4[0]), /* BAL_SWAPP_PORT_MAP_SVK4 */
sizeof(net_inf_map_epon_tdma_10g)/sizeof(net_inf_map_epon_tdma_10g[0]), /* BAL_SWAPP_PORT_MAP_EPON_TDMA */
sizeof(net_inf_map_epon_1g)/sizeof(net_inf_map_epon_1g[0]), /* BAL_SWAPP_PORT_MAP_EPON_1G */
sizeof(net_inf_map_epon_tdma_10g)/sizeof(net_inf_map_epon_tdma_10g[0]), /* BAL_SWAPP_PORT_MAP_EPON_10G */
};
/* pon interface mapping table size */
int g_pon_inf_map_table_size[BAL_SWAPP_PORT_MAP__NUM_OF] = {
sizeof(pon_inf_map_gpon)/sizeof(pon_inf_map_gpon[0]), /* BAL_SWAPP_PORT_MAP_GPON */
sizeof(pon_inf_map_gpon_v3)/sizeof(pon_inf_map_gpon_v3[0]), /* BAL_SWAPP_PORT_MAP_GPON_V3 */
sizeof(pon_inf_map_exp)/sizeof(pon_inf_map_exp[0]), /* BAL_SWAPP_PORT_MAP_EXP */
sizeof(pon_inf_map_exp2)/sizeof(pon_inf_map_exp2[0]), /* BAL_SWAPP_PORT_MAP_EXP2 */
sizeof(pon_inf_map_svk4)/sizeof(pon_inf_map_svk4[0]), /* BAL_SWAPP_PORT_MAP_SVK4 */
sizeof(pon_inf_map_epon_tdma_10g)/sizeof(pon_inf_map_epon_tdma_10g[0]), /* BAL_SWAPP_PORT_MAP_EPON_TDMA */
sizeof(pon_inf_map_epon_1g)/sizeof(pon_inf_map_epon_1g[0]), /* BAL_SWAPP_PORT_MAP_EPON_1G */
sizeof(pon_inf_map_epon_tdma_10g)/sizeof(pon_inf_map_epon_tdma_10g[0]), /* BAL_SWAPP_PORT_MAP_EPON_10G */
};
/**
* @brief get the number of valid network interface
* @return num_nni number of nni interfaces
*/
int bal_bcm_net_inf_map_size_get()
{
return g_net_inf_map_table_size[g_intf_maptable];
};
/**
* @brief get the number of valid pon interface
* @return num_nni number of pon interfaces
*/
int bal_bcm_pon_inf_map_size_get()
{
return g_pon_inf_map_table_size[g_intf_maptable];
};
/**
* @brief get KT2 PBM of a network interface from current mapping table
*
* @param net_inf_id logical nni interface number from CLI
*
* @return pbm PortBitMap that will be used in bcm api calls
*/
uint32_t bal_bcm_net_inf_pbm_get(uint32_t net_inf_id)
{
bal_swapp_port *port = (g_net_inf_map_table[g_intf_maptable] + net_inf_id);
return port->pbm_id;
};
/**
* @brief get bal nni port number (index of the mapping table) of a physical nni interface
*
* @param nni_id physical nni interface in the switch
*
* @return index index to PortBitMap that contains the physical interface number
*/
int bal_bcm_net_inf_idx_get(uint32_t nni_id)
{
int indx;
bal_swapp_port *port = g_net_inf_map_table[g_intf_maptable];
for( indx = 0; port->pbm_id != -1; indx++)
{
if (port->pbm_id == nni_id)
{
break;
}
port++;
}
if (port->pbm_id == -1)
{
return -1;
}
else
{
return indx;
}
}
/**
* @brief get KT2 device id of a network interface from current mapping table
*
* @param net_inf_id logical nni interface number from CLI
*
* @return pbm device number that will be used in bcm api calls
*/
int bal_bcm_net_inf_dev_get(uint32_t net_inf_id)
{
if(net_inf_id > sizeof(g_net_inf_map_table))
{
return bal_bcm_dft_dev_get();
}
else
{
bal_swapp_port *port = (g_net_inf_map_table[g_intf_maptable] + net_inf_id);
return port->device_id;
}
};
/**
* @brief get KT2 PBM of a pon interface from current mapping table
*
* @param pon_inf_id logical pon interface number from CLI
*
* @return pbm PortBitMap that will be used in bcm api calls
*/
uint32_t bal_bcm_pon_inf_pbm_get(uint32_t pon_inf_id)
{
bal_swapp_port *port = (g_pon_inf_map_table[g_intf_maptable] + pon_inf_id);
return port->pbm_id;
};
/**
* @brief get bal pon port number (index of the mapping table) of a physical pon interface
*
* @param pon_id physical pon interface in the switch
*
* @return index index to PortBitMap that contains the physical interface number
*/
int bal_bcm_pon_inf_idx_get(uint32_t pon_id)
{
int indx;
bal_swapp_port *port = g_pon_inf_map_table[g_intf_maptable];
for( indx = 0; port->pbm_id != -1; indx++)
{
if (port->pbm_id == pon_id)
{
break;
}
port++;
}
if (port->pbm_id == -1)
{
return -1;
}
else
{
return indx;
}
}
/**
* @brief get KT2 device number of a pon interface from current mapping table
*
* @param pon_inf_id logical pon interface number from CLI
*
* @return pbm device number that will be used in bcm api calls
*/
int bal_bcm_pon_inf_dev_get(uint32_t pon_inf_id)
{
if(pon_inf_id > sizeof(g_pon_inf_map_table))
{
return bal_bcm_dft_dev_get();
}
else
{
bal_swapp_port *port = (g_pon_inf_map_table[g_intf_maptable] + pon_inf_id);
return port->device_id;
}
};
/**
* @brief setting the local default device id
*/
void bal_bcm_dft_dev_set(uint32_t id)
{
g_dft_dev_id = (int)id;
}
/**
* @brief getting the local default device id
*/
uint32_t bal_bcm_dft_dev_get()
{
return g_dft_dev_id;
}
/**
* @brief setting the L2 table aging time (seconds)
*/
void bal_bcm_l2_age_time_set(uint32_t age_time)
{
g_l2_age_time = age_time;
}
/**
* @brief getting current L2 table aging time value
*/
uint32_t bal_bcm_l2_age_time_get()
{
return g_l2_age_time;
}
/**
* @brief getting the device type
*/
uint32_t bal_bcm_dev_type_get(uint32_t id)
{
int rc;
bcm_info_t dev_info;
rc = bcm_info_get(id, &dev_info);
if (rc)
{
return 0;
}
return dev_info.device;
}
/**
* @brief getting the iwf mode of an access terminal
*/
uint32_t bal_bcm_iwf_mode_get()
{
/* currently only support one access terminal */
BCM_LOG(DEBUG, log_id_sw_util, " Get iwf mode for acc_term\n");
return g_iwf_mode;
}
/**
* @brief setting the use of RPC (remote) or not (local)
*/
void bal_bcm_use_rpc_set(uint32_t use_rpc)
{
g_use_rpc = (int)use_rpc;
}
/**
* @brief getting the use of RPC (remote) or not (local)
*/
bcmos_bool bal_bcm_use_rpc_get(void)
{
if (g_use_rpc)
{
return BCMOS_TRUE;
}
else
{
return BCMOS_FALSE;
}
}
static void sw_util_bcm_rx_cb (int unit, int port, int reason, unsigned char *p_payload, int payload_len)
{
int i, len, obj_len;
unsigned char *payload;
char bytestr[32];
char *p_bytestr = bytestr;
BCM_LOG(INFO, log_id_sw_util, "BAL: Captured packet from datapath (len: %d bytes)\n", payload_len);
BCM_LOG(DEBUG, log_id_sw_util, " ingress port %d\n", port);
BCM_LOG(DEBUG, log_id_sw_util, " rcv reason 0x%x\n", reason);
len = (payload_len > 64)? 64 : payload_len;
/* dump out the captured packet */
payload = p_payload;
BCM_LOG(DEBUG, log_id_sw_util, " payload: (first %d bytes shown)", len);
for(i=0; i<len; i++)
{
if ( i%8 == 0)
{
sprintf(p_bytestr, "\n");
BCM_LOG(DEBUG, log_id_sw_util, "%s", bytestr);
p_bytestr = bytestr;
}
sprintf(p_bytestr, " %02x", *payload++);
p_bytestr += 3;
}
/* Log the string being crafted when the loop terminated */
sprintf(p_bytestr, "\n");
BCM_LOG(DEBUG, log_id_sw_util, "%s", bytestr);
/* Send Auto Indication */
if ( p_bal_core_to_api_ind_queue )
{
bcmbal_packet_cfg *p_ind_msg = NULL;
bcmbal_packet_key key;
bal_sw_flow *p_flow_elm;
int tmp_port;
/* find the flow info corresponding to this trap REASON */
p_flow_elm = bal_sw_util_flow_list_get_by_trap_code(reason);
if(p_flow_elm == NULL)
{
BCM_LOG(WARNING, log_id_sw_util, " TrapCallBack: Can't match trap code 0x%x to element in flow list\n", reason);
return;
}
/* The packet indication object contains the bcmbal_packet_cfg structure plus the captured packet
* content
*/
obj_len = payload_len + sizeof(bcmbal_packet_cfg);
p_ind_msg = bcmbal_msg_calloc(obj_len);
if(p_ind_msg == NULL)
{
BCM_LOG(ERROR, log_id_sw_util, " TrapCallBack: No memory to send indication\n");
return;
}
key.packet_send_dest.type = BCMBAL_DEST_TYPE_HOST;
BCMBAL_CFG_INIT(p_ind_msg, packet, key);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, flow_id, p_flow_elm->id);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, svc_port, p_flow_elm->svc_port);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, flow_cookie, p_flow_elm->flow_cookie);
/* first search the PON table */
tmp_port = bal_bcm_pon_inf_idx_get(port);
if( tmp_port != -1)
{
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, flow_type, BCMBAL_FLOW_TYPE_UPSTREAM);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, intf_id, tmp_port);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, intf_type, BCMBAL_INTF_TYPE_PON);
}
else /* if failed, search for NNI table */
{
tmp_port = bal_bcm_net_inf_idx_get(port);
if( tmp_port != -1)
{
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, flow_type, BCMBAL_FLOW_TYPE_DOWNSTREAM);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, intf_id, tmp_port);
BCMBAL_CFG_PROP_SET(p_ind_msg, packet, intf_type, BCMBAL_INTF_TYPE_NNI);
}
}
/* if both failed, return */
if(tmp_port == -1)
{
/* something went wrong, free up the message */
bcmbal_msg_free(p_ind_msg);
BCM_LOG(ERROR, log_id_sw_util, " TrapCallBack: can't match ingress port to bal port tables\n");
return;
}
((bcmbal_obj *)p_ind_msg)->status = BCM_ERR_OK;
((bcmbal_obj *)p_ind_msg)->obj_type = BCMBAL_OBJ_ID_PACKET;
((bcmbal_obj *)p_ind_msg)->group = BCMBAL_MGT_GROUP_AUTO;
/* now copy the contents of the packet */
p_ind_msg->data.pkt.val = (uint8_t *)(p_ind_msg + 1);
memcpy(p_ind_msg->data.pkt.val, p_payload, payload_len);
/* and record the length of the captured packet */
p_ind_msg->data.pkt.len = payload_len;
BCMBAL_PROP_SET_PRESENT(p_ind_msg, packet, _cfg, pkt);
BCM_LOG(INFO, log_id_sw_util, " TrapCallBack: Flow id = %d, type=%d, Interface id = %d, type=%d, svc_port=%d\n",
p_ind_msg->data.flow_id, p_ind_msg->data.flow_type,
p_ind_msg->data.intf_id, p_ind_msg->data.intf_type,
p_ind_msg->data.svc_port);
/* Send this indication straight to the API client
*/
bcmbal_msg_hdr_set(p_ind_msg,
BCMBAL_MGMT_API_IND_MSG,
BAL_MSG_TYPE_AUTO_IND,
BAL_SUBSYSTEM_CORE,
BCMBAL_OBJ_ID_PACKET,
0, /* operation code */
0); /* exchange id */
if(BCM_ERR_OK != bcmbal_msg_send(p_bal_core_to_api_ind_queue,
p_ind_msg,
BCMOS_MSG_SEND_AUTO_FREE))
{
BCM_LOG(ERROR, log_id_sw_util, " TrapCallBack: send auto indication failed\n");
}
else
{
BCM_LOG(DEBUG, log_id_sw_util, " TrapCallBack: auto indication sent\n");
}
}
else
{
BCM_LOG(ERROR, log_id_sw_util, " TrapCallBack: no auto indication queue\n");
}
return;
}
/**
* @brief Connect access terminal
*
* This routine is called by acc_term_fsm in the BAL core
* Upon receiving the request from the core, this function
* assign the device number that each logical nni or pon interface belong
* and restrict the egress ports of each interface. This mapping is highly
* topology dependent and should be customized according to the actual hardware
* layout.
* @param p_acc_term Pointer to access terminal instance
*
* @return bcmos_errno
*/
static bcmos_errno sw_util_access_terminal_connect(acc_term_inst *p_acc_term)
{
bcmos_errno ret = BCM_ERR_INTERNAL;
int rc;
bal_swapp_port *port;
char *argv[] = { "socdiag", NULL };
uint32_t dev_type;
BCM_LOG(INFO, log_id_sw_util, " Got a access terminal SET\n");
/* make sure the abstraction layer is initialized - no harm to initialize multiple time */
bcmos_init();
/* Initialize SDK */
rc = socdiag_main(1, argv);
if (rc)
{
BCM_LOG(ERROR, log_id_sw_util, " Init BCM SDK failed - %d\n", rc);
return BCM_ERR_INTERNAL;
}
BCM_LOG(INFO, log_id_sw_util, " %s RPC\n", (1 == g_use_rpc) ? "Using" : "Not using" );
/* use a soc script to establish rpc connection if switch is remotely located */
if (bal_bcm_use_rpc_get())
{
sleep(3); /* allow remote device to settle */
BCM_LOG(INFO, log_id_sw_util, " starting RPC connection\n");
rc = sh_rcload_file(-1, NULL, "rpc.soc", 0);
if (rc)
{
BCM_LOG(ERROR, log_id_sw_util, " start RPC connection failed\n");
return BCM_ERR_INTERNAL;
}
}
BCM_LOG(INFO, log_id_sw_util, " Using interface table: %d Device: %d\n", g_intf_maptable, g_dft_dev_id );
/* setup the device ID - This is very hardware specific */
port = g_net_inf_map_table[g_intf_maptable];
/* -1 indicate end of table */
while(port->pbm_id != -1)
{
port->device_id = g_dft_dev_id;
port++;
}
port = g_pon_inf_map_table[g_intf_maptable];
while(port->pbm_id != -1)
{
port->device_id = g_dft_dev_id;
port++;
}
/* get the switch model from the chip */
dev_type = bal_bcm_dev_type_get(g_dft_dev_id);
if (dev_type == 0)
{
BCM_LOG(ERROR, log_id_sw_util, " Error retrieving device type on access-terminal connect: 0x%x\n", dev_type);
return BCM_ERR_INTERNAL;
}
/* set up the valid egress ports for net/pon facing ports */
if (dev_type == BCM_DEVICE_KT2)
{
ret = sw_util_esw_acc_term_connect(g_net_inf_map_table[g_intf_maptable], g_pon_inf_map_table[g_intf_maptable]);
}
else if (dev_type == BCM_DEVICE_ARAD || dev_type == BCM_DEVICE_ARAD_PLUS || dev_type == BCM_DEVICE_QAX)
{
/* for rpc case, dpp use a special api to register rx callback.
for non-rpc use case, use bcm_rx_register() to register the rx callback
*/
if (bal_bcm_use_rpc_get())
{
/* if the trap receive udp port in bal_config.ini is not zero, start a receiving thread */
if(bal_bcm_trap_rcv_port_get())
{
sw_util_dpp_rx_cb_register(bal_bcm_dft_dev_get(), sw_util_bcm_rx_cb);
}
else
{
BCM_LOG(ERROR, log_id_sw_util, "Missing UDP port number for RPC packet In receiver \n");
return BCM_ERR_INTERNAL;
}
}
else
{
bcm_rx_register(bal_bcm_dft_dev_get(), "Bal Cpu Traps", dpp_rx_cb_register, 50, NULL, BCM_RCO_F_ALL_COS);
}
ret = sw_util_dpp_acc_term_connect(g_net_inf_map_table[g_intf_maptable], g_pon_inf_map_table[g_intf_maptable]);
}
BCM_LOG(INFO, log_id_sw_util, " Return access terminal connect request with %d on device 0x%x\n", ret, dev_type );
/* for now, only support one iwf */
g_iwf_mode = (uint32_t)p_acc_term->api_req_acc_term_obj_info.data.iwf_mode;
return ret;
}
/**
* @brief getting the interface mapping table that applied to the HW connections
*/
bal_swapp_port_map_indx bal_bcm_intf_maptable_get()
{
return g_intf_maptable;
}
/**
* @brief SWITCH module: internal packet_send function
*
* This routine distribute the SEND function to supported switch family
*
* @param dst_port_id Switch port id the packet is going to be sent out
* @param reason REASON_SEND_TO_NNI or REASON_SEND_TO_PON
* @param payload pointer to the data
* @param payload_len the length of the data
* @param tunnel_id pon port tunnel id if REASON_SEND_TO_PON
*
* @return bcmos_errno
*/
static bcmos_errno sw_util_pkt_send_intl(int dst_port_id,
int reason,
unsigned char *payload,
int payload_len,
int tunnel_id)
{
uint32_t dev_type;
bcmos_errno ret = BCM_ERR_OK;
/* get the switch chip type from default device id
TBD - in the future, the device id should be obtained from port mapping table */
dev_type = bal_bcm_dev_type_get(g_dft_dev_id);
if (dev_type == 0)
{
BCM_LOG(ERROR, log_id_sw_util, " Error retrieving device type on pkt send: 0x%x\n", dev_type);
return BCM_ERR_INTERNAL;
}
/* set up the valid egress ports for net/pon facing ports */
if (dev_type == BCM_DEVICE_KT2)
{
return BCM_ERR_NOT_SUPPORTED;
}
else if (dev_type == BCM_DEVICE_ARAD || dev_type == BCM_DEVICE_ARAD_PLUS || dev_type == BCM_DEVICE_QAX)
{
ret = sw_util_dpp_pkt_send(dst_port_id, reason, payload, payload_len, s_target_device, tunnel_id);
}
else
{
ret = BCM_ERR_NOT_SUPPORTED;
}
BCM_LOG(INFO, log_id_sw_util, " Return access terminal connect request with %d on device 0x%x\n", ret, dev_type );
return ret;
}
#endif /* #ifndef TEST_SW_UTIL_LOOPBACK */
/* the listening UDP port that the switch will send the trapped messages */
static uint32_t g_trap_rcv_port = 0;
/**
* @brief set the receiving UDP port for trap packets - from config file
*/
uint32_t bal_bcm_trap_rcv_port_set(uint32_t udp_port)
{
g_trap_rcv_port = udp_port;
return 0;
}
/**
* @brief getting the receiving UDP port for trap packets
*/
uint32_t bal_bcm_trap_rcv_port_get()
{
return g_trap_rcv_port;
}
/* the global portChannel DownStream Max rate scheduling mode */
static uint32_t g_ds_sched_mode = 0; /* default to strict priority */
/**
* @brief set the DS max rate scheduling mode - from config file
*/
uint32_t bal_bcm_ds_sched_mode_set(uint32_t sched_mode)
{
g_ds_sched_mode = sched_mode;
return 0;
}
/**
* @brief getting the DS max rate scheduling mode
*/
uint32_t bal_bcm_ds_sched_mode_get()
{
return g_ds_sched_mode;
}
/**
* @brief SWITCH module: access terminal SET handler
*
* This routine is called by acc_term_fsm in the BAL core upon
* SET request for acc_terminal object.
*
* @param p_acc_term Pointer to access terminal instance
* @param opt_type Operation type on access terminal instance
*
* @return bcmos_errno
*/
bcmos_errno sw_util_access_terminal_set(acc_term_inst *p_acc_term,
bal_util_oper_acc_term opt_type)
{
bcmos_errno ret = BCM_ERR_OK;
if (opt_type != BAL_UTIL_OPER_ACC_TERM_CONNECT)
{
BCM_LOG(ERROR, log_id_sw_util, " Access terminal currently supports only CONNECT request\n");
return BCM_ERR_NOT_SUPPORTED;
}
#ifndef TEST_SW_UTIL_LOOPBACK
ret = sw_util_access_terminal_connect(p_acc_term);
#else
BCM_LOG(INFO, log_id_sw_util, " dummy SUCCESS\n");
#endif
return ret;
}
/**
* @brief setting the interface mapping table that applied to the HW connections
*/
int bal_bcm_intf_maptable_set(uint32_t intf_maptable)
{
int ret = 0;
#ifndef TEST_SW_UTIL_LOOPBACK
switch(intf_maptable)
{
case 0:
g_intf_maptable = BAL_SWAPP_PORT_MAP_GPON;
break;
case 1:
g_intf_maptable = BAL_SWAPP_PORT_MAP_GPON_V3;
break;
case 2:
g_intf_maptable = BAL_SWAPP_PORT_MAP_EXP;
break;
case 3:
g_intf_maptable = BAL_SWAPP_PORT_MAP_EXP2;
break;
case 4:
g_intf_maptable = BAL_SWAPP_PORT_MAP_SVK4;
break;
case 5:
g_intf_maptable = BAL_SWAPP_PORT_MAP_EPON_TDMA;
break;
case 6:
g_intf_maptable = BAL_SWAPP_PORT_MAP_EPON_1G;
break;
case 7:
g_intf_maptable = BAL_SWAPP_PORT_MAP_EPON_10G;
break;
default:
BCM_LOG(ERROR, log_id_sw_util, " Mapping Table Id %d is not supported\n", intf_maptable);
ret = BCM_ERR_NOT_SUPPORTED;
break;
}
#endif
return ret;
}
/**
* @brief SWITCH module: packet_send
*
* This routine is called by work thread in the BAL core upon
* user request to send a raw packet out of a switch port.
*
* @param dst_port_id Switch port id the packet is going to be sent out
* @param reason REASON_SEND_TO_NNI or REASON_SEND_TO_PON
* @param payload pointer to the data
* @param payload_len the length of the data
* @param tunnel_id pon tunnel_id
*
* @return bcmos_errno
*/
bcmos_errno sw_util_pkt_send(int dst_port_id,
int reason,
unsigned char *payload,
int payload_len,
int tunnel_id)
{
bcmos_errno ret = BCM_ERR_OK;
if ( reason != REASON_SEND_TO_NNI && reason != REASON_SEND_TO_PON)
{
BCM_LOG(ERROR, log_id_sw_util, " pkt_send currently does not support reason %d\n", reason);
return BCM_ERR_NOT_SUPPORTED;
}
if ( reason == REASON_SEND_TO_NNI && BCMOS_FALSE == bcm_topo_nni_is_valid(dst_port_id))
{
BCM_LOG(ERROR, log_id_sw_util, " pkt_send to invalid nni port %d\n", dst_port_id);
return BCM_ERR_PARM;
}
#ifndef TEST_SW_UTIL_LOOPBACK
ret = sw_util_pkt_send_intl(dst_port_id, reason, payload, payload_len, tunnel_id);
#else
BCM_LOG(INFO, log_id_sw_util, " dummy SUCCESS\n");
#endif
return ret;
}
/*
* Called from bal_core to set up the packet out server IP:port (i.e. the bcm_user process location)
* when Switch is on the same board where the core is run, there is no RPC and this init function should not be called
*/
bcmos_errno sw_util_pkt_send_init(const char *pkt_send_server_ip, uint16_t pkt_send_server_listen_port)
{
bcmos_errno ret = BCM_ERR_OK;
#ifndef TEST_SW_UTIL_LOOPBACK
do
{
/* If the packet_out interface has already been initialized, just return OK */
if(g_pkt_send_is_initialized == BCMOS_FALSE)
{
#ifdef CONFIG_SWITCH_RPC
/*
* Set up the socket to be used for sending "packet send" messages
* to the bcm.user server
*/
if((s_target_device.socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
{
ret = BCM_ERR_NORES;
break;
}
s_target_device.addr.sin_family = AF_INET;
inet_pton(s_target_device.addr.sin_family, pkt_send_server_ip, &s_target_device.addr.sin_addr.s_addr);
s_target_device.addr.sin_port = htons(pkt_send_server_listen_port);
#endif /* CONFIG_SWITCH_RPC */
g_pkt_send_is_initialized = BCMOS_TRUE;
}
}
while(0);
#endif /*TEST_SW_UTIL_LOOPBACK*/
return ret;
}
/*@}*/