/*!Copyright (c) 2024 TP-LINK Technologies CO.,LTD.
*All rights reserved.
*
*\file dalL2_port.c
*\brief dalL2_port.c source file
*
*\author liuchang
*\version 1.0.0
*\date 20/02/2025
*/
#include <stdio.h>
#include "fepTypes.h"
#include "fepDefs.h"
#include "tpDbg/tpdebug.h"
#include "common/dmpComDef.h"
#include "common/applError.h"
#include "midware/dal.h"
#include "midware/dalAdo.h"
#include "dalL2_port.h"
#include "l2/port/portPub.h"
#include "l2/port/dalPortPub.h"
#include "l2/port/errPort.h"
#include "userPort/up_spec.h"
#include "userPort/user_port.h"
#include "userPort/up_str.h"
#include "userPort/up_property.h"
static int _dalPortStateSet(user_port up, UINT8 state)
{
if(PORT_ENABLE == state)
{
}
else
{
}
return ERR_NO_ERROR;
}
static int _dalPortSpeedDuplexSet(user_port up, UINT32 spd, UINT32 dpx)
{
return ERR_NO_ERROR;
}
static int _dalPortConfigHandle(dal_ado_t *adoi, void *handler, char *key)
{
UINT32 speed = 0;
UINT32 duplex = 0;
UINT8 state = 0;
user_port up = {};
BOOL isSpeedDuplex = FALSE;
DAL_PORT_KEY_CFG_PARSE(key, up);
if(DAL_ADOI_ENTRY_KEY_EMPTY(handler))
{
}
else
{
DBG("key %s", key);
DAL_ADOI_ENTRY_FIELD_LOOP(handler, key)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(handler, DAL_PORT_K_CFG_F_SPEED_U32))
{
isSpeedDuplex = TRUE;
dalAdoiGetEntryUI32(adoi, DAL_PORT_K_CFG, &speed);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(handler, DAL_PORT_K_CFG_F_DUPLEX_U32))
{
isSpeedDuplex = TRUE;
dalAdoiGetEntryUI32(adoi, DAL_PORT_K_CFG, &duplex);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(handler, DAL_PORT_K_CFG_F_STATE_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_K_CFG, &state);
DBG("set state %hhu", state);
_dalPortStateSet(up, state);
}
}
if(isSpeedDuplex)
{
DBG("speed %d, duplex %d up %d", speed, duplex, UP_INDEX(up));
_dalPortSpeedDuplexSet(up, speed, duplex);
}
}
return ERR_NO_ERROR;
}
static int _dalPortHandler(dal_ado_t *adoi, dal_attr *attr)
{
void *handler = NULL;
if (NULL != (handler = DAL_ADOI_ENTRY(adoi, DAL_PORT_K_CFG)))
{
DAL_ADOI_ENTRY_LOOP(handler)
{
char *key = NULL;
if(NULL == (key = DAL_ADOI_ENTRY_KEY(handler)))
{
DBG_ERR("key is NULL");
continue;
}
/* KEY inner field&value loop */
if(DAL_ADOI_ENTRY_KEY_MATCH(handler, DAL_PORT_K_CFG_ALL))
{
_dalPortConfigHandle(adoi, handler, key);
}
}
}
else
{
}
return ERR_NO_ERROR;
}
static int _dalL2_portDataInit()
{
int ret = ERR_NO_ERROR;
dal_ado_t *adoi=NULL;
int index = 0;
user_port up = {};
valid_uplist valid_uplist = NULL;
if (NULL==(adoi = dalAdoiCreate(DMP_DEV_NAME_SWITCHMAC, DAL_MOD_PORT, DAL_CFG_TYPE_ENTRY | DAL_CFG_TYPE_NOPUB)))
{
return ERR_NO_MEMORY;
}
valid_uplist_init(&valid_uplist, 0);
valid_uplist_get(&valid_uplist, 0);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiEntryTableAppend(adoi, DAL_PORT_K_CFG), ERR_INIT);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiEntryOperAppend(adoi, DAL_PORT_K_CFG, DAL_OPER_CFG), ERR_INIT);
UP_ITER_VALID(valid_uplist, index, up)
{
/*DMP module APPDEMO ado init */
char key[PORT_KEY_LEN] = {};
DAL_PORT_KEY_CFG_CREATE_BY_UP(key, index);
DBG("inti port %d/%d/%d index %d is valid, UP_IS_VALID %d", UP_UNIT(up), UP_SLOT(up), UP_PORT(up), index, UP_IS_VALID(up));
PFM_IF_FAIL_DONE_RET(ret, dalAdoiAddEntryKey(adoi, DAL_PORT_K_CFG, key, UP_INDEX(up)), ERR_INIT);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiAddEntryUI8(adoi, DAL_PORT_K_CFG, DAL_PORT_K_CFG_F_STATE_U8, DAL_PORT_STATE_DEFAULT), ERR_INIT);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiAddEntryUI32(adoi, DAL_PORT_K_CFG, DAL_PORT_K_CFG_F_SPEED_U32, DAL_PORT_SPEED_DEFAULT), ERR_INIT);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiAddEntryUI32(adoi, DAL_PORT_K_CFG, DAL_PORT_K_CFG_F_DUPLEX_U32, DAL_PORT_DUPLEX_DEFAULT), ERR_INIT);
PFM_IF_FAIL_DONE_RET(ret, dalAdoiAddEntryUI8(adoi, DAL_PORT_K_CFG, DAL_PORT_K_CFG_F_FLOWCTRL_U8, DAL_PORT_FLOWCTRL_DEFAULT), ERR_INIT);
}
PFM_IF_FAIL_DONE_RET(ret, dalSet(adoi), ERR_INIT);
done:
if(NULL != valid_uplist)
{
valid_uplist_free(&valid_uplist);
}
if(NULL != adoi)
{
dalAdoiDestroy(adoi);
}
return ret;
}
int dalL2_portInit()
{
APPL_IF_ERR_RET(_dalL2_portDataInit());
PFM_IF_FAIL_RET_VAL(dalHandlerReg(DAL_MOD_PORT, _dalPortHandler), ERR_INIT);
return ERR_NO_ERROR;
}
/*!Copyright (c) 2010-2011 TP-LINK Technologies CO.,LTD.
*All rights reserved.
*
*\file dalL2_port.c
*\brief
*
*\author Yang jingjing
*\version
*\date 2025-03-27
*/
/**************************************************************************************************/
/* INCLUDE_FILES */
/**************************************************************************************************/
#include "fepTypes.h"
#include "fepDefs.h"
#include "fepPfm.h"
#include "tpDbg/tpdebug.h"
#include "common/applError.h"
#include "timer/timer.h"
#include "gr/gr_client.h"
#include "gr/gr_log.h"
#include "midware/dal.h"
#include "userPort/user_port.h"
#include "l2/port/dalPortPub.h"
#include "l2/port/portPub.h"
#include "l2/port/errPort.h"
#include "dal/dalL2_port.h"
#include "hi/hiL2_port.h"
#include "dmp/dmpPub.h"
/**************************************************************************************************/
/* DEFINES */
/**************************************************************************************************/
/**************************************************************************************************/
/* TYPES */
/**************************************************************************************************/
/**************************************************************************************************/
/* EXTERN_PROTOTYPES */
/**************************************************************************************************/
/**************************************************************************************************/
/* LOCAL_PROTOTYPES */
/**************************************************************************************************/
/**************************************************************************************************/
/* VARIABLES */
/**************************************************************************************************/
/**************************************************************************************************/
/* LOCAL_FUNCTIONS */
/**************************************************************************************************/
/*
* @brief 根据ASICDB中的数据 调用Hi层接口配置镜像功能. 根据mirrorPortIdx字段的值 判断clear后是否重新set
*
* @param[in]
*
* @return int
*
*/
static int _dalL2PortMirrorSet(MIRRORED_PORT_INFO *mirroredPortInfo, UINT8 entryNum)
{
DBG_ALZ("Enter _dalL2PortMirrorSet ......");
if (0 == mirroredPortInfo[0].mirrorPortIdx)
{
DBG_ALZ("mirror state off");
hiPortMirrorClearAll();
return ERR_NO_ERROR;
}
UINT32 mirrorMode;
char mirroredPortStr[200];
mirroredPortStr[0] = '\0';
for (int i = 0; i < entryNum; i++)
{
if (MIRROR_INGRESS == mirroredPortInfo[i].mirrorMode)
{
sprintf(mirroredPortStr + strlen(mirroredPortStr), "%d ", mirroredPortInfo[i].mirroredPortIdx - 1);
}
else if (MIRROR_EGRESS == mirroredPortInfo[i].mirrorMode)
{
sprintf(mirroredPortStr + strlen(mirroredPortStr), "%dt ", mirroredPortInfo[i].mirroredPortIdx - 1);
}
else if (MIRROR_BOTH == mirroredPortInfo[i].mirrorMode)
{
sprintf(mirroredPortStr + strlen(mirroredPortStr), "%d %dt ", mirroredPortInfo[i].mirroredPortIdx - 1, mirroredPortInfo[i].mirroredPortIdx - 1);
}
else
{
DBG_ERR("mirror mode error! ");
return ERR_BAD_PARAM;
}
}
DBG_ALZ("mirrorPort[%u], mirroredPortsStr[%s]", mirroredPortInfo[0].mirrorPortIdx - 1, mirroredPortStr);
hiPortMirrorClearAll();
hiPortMirrorSet(mirroredPortInfo[0].mirrorPortIdx, mirroredPortStr);
return ERR_NO_ERROR;
}
static int _dalL2PortMirrorDataGet(MIRRORED_PORT_INFO *mirroredPortInfo, UINT8 *entryNum)
{
DBG_ALZ("Enter _dalL2PortMirrorDataGet ......");
int ret = ERR_NO_ERROR;
void *tblHandler = NULL;
char *key = NULL;
dal_ado_t *adoi = dalAdoiCreate(DMP_DEV_NAME_DEMO, DAL_MOD_PORT, DAL_CFG_TYPE_ENTRY);
DMP_NULL_DONE_RETVAL(adoi, ret, ERR_NO_MEMORY);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiEntryTableAppend(adoi, DAL_PORT_E_K_MONITOR_PORT), ret, ERR_BAD_PARAM);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiEntryOperAppend(adoi, DAL_PORT_E_K_MONITOR_PORT, DAL_OPER_GET_RANGE), ret, ERR_BAD_PARAM);
dalAdoiEntryRangeArgsAppend(adoi, DAL_PORT_E_K_MONITOR_PORT, TRUE, 0, -1);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalGet(adoi), ret, ERR_BAD_PARAM);
DAL_ADOI_DBG_DISP(adoi);
DAL_ADOI_ENTRY_ITER_ALL(adoi, tblHandler)
{
DBG_ALZ("loop of entry table name[%s]", DAL_ENTRY_TBL_NAME(tblHandler));
DAL_ADOI_ENTRY_LOOP(tblHandler)
{
if (NULL == (key = DAL_ADOI_ENTRY_KEY(tblHandler)) || !DAL_ADOI_ENTRY_KEY_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_ALL))
{
DBG_ERR("Invalid key %s !", key);
continue;
}
if (DAL_ADOI_ENTRY_KEY_EMPTY(tblHandler))
{
DBG_ALZ("dal operation [delete] mirror port");
}
else
{
DAL_PORT_KEY_MONITOR_PORT_PARSE(key, mirroredPortInfo[*entryNum].mirroredPortIdx);
DBG_ALZ("key[%s], mirroredUpIdx[%u]", key, mirroredPortInfo[*entryNum].mirroredPortIdx);
DAL_ADOI_ENTRY_FIELD_LOOP(tblHandler, key)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_F_MODE_U32))
{
dalAdoiGetEntryUI32(adoi, DAL_PORT_E_K_MONITOR_PORT, &mirroredPortInfo[*entryNum].mirrorMode);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_F_SESSION_ID_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_E_K_MONITOR_PORT, &mirroredPortInfo[*entryNum].mirrorPortIdx);
}
}
}
(*entryNum)++;
}
}
done:
DMP_FREE_TPDAL(adoi);
return ret == PFM_ERR_C_OK ? ERR_NO_ERROR : ret;
}
static int _dalL2PortFlowCtrlGet(user_port up, UINT8 *flowCtrl)
{
int ret = ERR_NO_ERROR;
dal_ado_t *adoi = NULL;
UINT32 upIdx = 0;
char key[PORT_KEY_LEN] = {};
CHAR *keyStr = NULL;
void *handler = NULL;
UP_TO_IDX(up, upIdx);
DAL_PORT_KEY_CFG_CREATE_BY_UP(key, upIdx);
adoi = dalAdoiCreate(DMP_DEV_NAME_SWITCHMAC, DAL_MOD_PORT, DAL_CFG_TYPE_ENTRY);
DMP_NULL_DONE_RETVAL(adoi, ret, ERR_NO_MEMORY);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiEntryTableAppend(adoi, DAL_PORT_K_CFG), ret, ERR_PORT_EXEC_TPDAL);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiEntryOperAppend(adoi, DAL_PORT_K_CFG, DAL_OPER_GET_F), ret, ERR_PORT_EXEC_TPDAL);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiAddEntryKey(adoi, DAL_PORT_K_CFG, key, upIdx), ret, ERR_PORT_EXEC_TPDATA);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalAdoiAddEntryField(adoi, DAL_PORT_K_CFG, DAL_PORT_K_CFG_F_FLOWCTRL_U8), ret, ERR_PORT_EXEC_TPDATA);
DMP_NOTEQUAL_DONE_RETVAL(PFM_ERR_C_OK, dalGet(adoi), ret, ERR_PORT_EXEC_TPDATA);
if (NULL != (handler = DAL_ADOI_ENTRY(adoi, DAL_PORT_K_CFG)))
{
DAL_ADOI_ENTRY_LOOP(handler)
{
if (NULL== (keyStr = DAL_ADOI_ENTRY_KEY(handler)) || !DAL_ADOI_ENTRY_KEY_MATCH(handler, DAL_PORT_K_CFG_ALL))
{
continue;
}
if (DAL_ADOI_ENTRY_KEY_EMPTY(handler))
{
DBG_ALZ("key with no fields");
}
else
{
DAL_ADOI_ENTRY_FIELD_LOOP(handler, keyStr)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(handler, DAL_PORT_K_CFG_F_FLOWCTRL_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_K_CFG, flowCtrl);
}
}
}
}
}
done:
DMP_FREE_TPDAL(adoi);
return ret;
}
static int _setNgmodeStr(IN UINT32 duplex, IN UINT32 speed, OUT char *str)
{
int ret = ERR_NO_ERROR;
APPL_ENSURE_RET(UP_SPEED_TYPE_IS_VALID(speed) && UP_DUPLEX_TYPE_IS_VALID(duplex));
int speedValArr[UP_ABILITY_SPEED_END] = PORT_SPEED_VALUE;
UINT32 speedVal = 0;
switch (duplex)
{
case PORT_DUPLEX_AUTO:
if (PORT_SPEED_AUTO == speed)
{
snprintf(str, SWLIB_SET_STR_LEN, "auto");
goto done;
}
else
{
GR_PRINT_ERROR("Bad Param. speed[%u] duplex[%u]", speed, duplex);
ret = ERR_BAD_PARAM;
goto done;
}
break;
case PORT_HALF:
speedVal = speedValArr[speed];
snprintf(str, SWLIB_SET_STR_LEN, "%uMH", speedVal);
break;
case PORT_FULL:
speedVal = speedValArr[speed];
snprintf(str, SWLIB_SET_STR_LEN, "%uMF", speedVal);
break;
default:
ret = ERR_BAD_PARAM;
goto done;
}
done:
return ret;
}
static int _dalL2PortSpeedDuplexSet(user_port up, UINT32 spd, UINT32 dpx, UINT8 flowCtrl)
{
int ret = ERR_NO_ERROR;
char ngModeStr[SWLIB_SET_STR_LEN] = {};
char flowCtrlStr[SWLIB_SET_STR_LEN] = {};
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, _setNgmodeStr(dpx, spd, ngModeStr), ret, ERR_BAD_PARAM);
switch (flowCtrl)
{
case PORT_FLOWCTRL_DISABLE:
snprintf(flowCtrlStr, SWLIB_SET_STR_LEN, "off");
break;
case PORT_FLOWCTRL_ENABLE:
snprintf(flowCtrlStr, SWLIB_SET_STR_LEN, "on");
break;
default:
ret = ERR_BAD_PARAM;
DBG_ERR("Bad Param. upIdx[%u] flowCtrl[%hhu]", UP_INDEX(up), flowCtrl);
goto done;
}
DBG_ALZ("ngModeStr[%s] flowCtrlStr[%s]", ngModeStr, flowCtrlStr);
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, hiPortSpeedDuplexSet(UP_INDEX(up), ngModeStr, flowCtrlStr), ret, ERR_BAD_PARAM);
done:
return ret;
}
static int _dalPortConfigHandle(dal_ado_t *adoi, void *tblHandler, char *key)
{
int ret = ERR_NO_ERROR;
UINT32 speed = 0;
UINT32 duplex = 0;
UINT8 state = 0;
UINT8 flowCtrl = 0, cfgFlowCtrl = 0;
BOOL isSpeedDuplex = FALSE;
user_port up = {};
DAL_PORT_KEY_CFG_PARSE(key, up);
APPL_ENSURE_RET(!UP_IS_USB_PORT(up));
if (DAL_ADOI_ENTRY_KEY_EMPTY(tblHandler))
{
DBG_ALZ("dal operation [delete] port. key[%s]", key);
}
else
{
DAL_ADOI_ENTRY_FIELD_LOOP(tblHandler, key)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_K_CFG_F_SPEED_U32))
{
isSpeedDuplex = TRUE;
dalAdoiGetEntryUI32(adoi, DAL_PORT_K_CFG, &speed);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_K_CFG_F_DUPLEX_U32))
{
isSpeedDuplex = TRUE;
dalAdoiGetEntryUI32(adoi, DAL_PORT_K_CFG, &duplex);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_K_CFG_F_STATE_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_K_CFG, &state);
// 设置端口状态
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, hiPortStateSet(UP_INDEX(up), state), ret, ERR_NOT_SET);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_K_CFG_F_FLOWCTRL_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_K_CFG, &flowCtrl);
// 设置端口流控状态 可以单独下发on或off
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, hiPortFlowCtrlSet(UP_INDEX(up), flowCtrl), ret, ERR_NOT_SET);
}
}
}
if(isSpeedDuplex)
{
DBG_ALZ("upIdx[%d] speed[%u] duplex[%u]", UP_INDEX(up), speed, duplex);
// 配置端口速率和双工模式 流控 swconfig dev switch0 port 9 set port-para "off 10MF" 设置时需要获取流控状态 一起下发
// 从asicDB中获取up的流控状态
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, _dalL2PortFlowCtrlGet(up, &cfgFlowCtrl), ret, ERR_NOT_SET);
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, _dalL2PortSpeedDuplexSet(up, speed, duplex, cfgFlowCtrl), ret, ERR_NOT_SET);
}
done:
return ret;
}
static int _dalL2PortHandle(dal_ado_t *adoi, dal_attr *attr)
{
// D("L2 port handle");
void *tblHandler = NULL;
DBG_ALZ("Enter _dalL2PortHandle ......");
int ret = ERR_NO_ERROR;
DAL_ADOI_DBG_DISP(adoi);
// DAL_PORT_PORTCFG_TBL
if (NULL != (tblHandler = DAL_ADOI_ENTRY(adoi, DAL_PORT_K_CFG)))
{
DAL_ADOI_ENTRY_LOOP(tblHandler)
{
char *key = NULL;
if (NULL == (key = DAL_ADOI_ENTRY_KEY(tblHandler)) || !DAL_ADOI_ENTRY_KEY_MATCH(tblHandler, DAL_PORT_K_CFG_ALL))
{
DBG_ERR("Invalid key %s !", key);
continue;
}
DMP_NOTEQUAL_DONE_RETVAL(ERR_NO_ERROR, _dalPortConfigHandle(adoi, tblHandler, key), ret, ERR_NOT_SET);
}
}
// mirror port handle
if (NULL != (tblHandler = DAL_ADOI_ENTRY(adoi, DAL_PORT_E_K_MONITOR)))
{
// DBG_ALZ("mirror port entry cfg");
DAL_ADOI_ENTRY_LOOP(tblHandler)
{
char *key = NULL;
UINT32 dstUpIdx = 0;
UINT16 dst_rspan_vlan_id = UINT16_MAX;
UINT16 src_rspan_vlan_id = UINT16_MAX;
if (NULL == (key = DAL_ADOI_ENTRY_KEY(tblHandler)) || !DAL_ADOI_ENTRY_KEY_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_ALL))
{
DBG_ERR("Invalid key %s !", key);
continue;
}
// DBG_ALZ("key [%s]", key);
if (DAL_ADOI_ENTRY_KEY_EMPTY(tblHandler))
{
DBG_ALZ("dal operation delete mirror port. key[%s]", key);
/* @STUB_BEGIN [l2] [yangjingjing] [2025-04-16] */
/* 打桩原因:FEP提供的L2 port功能不支持删除监控口 删除对应key的dalSet暂未适配 */
//note 具体操作: clear监控口操作暂未实现 (操作: 清空监控口配置)
/* @STUB_END */
}
else
{
DBG_ALZ("dal operation [cfg] mirror port. key[%s]", key);
/* KEY inner field&value loop */
DAL_ADOI_ENTRY_FIELD_LOOP(tblHandler, key)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_F_DST_UPIDX_U32))
{
dalAdoiGetEntryUI32(adoi, DAL_PORT_E_K_MONITOR, &dstUpIdx);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_F_DST_REMOTE_VLAN_ID_U16))
{
dalAdoiGetEntryUI16(adoi, DAL_PORT_E_K_MONITOR, &dst_rspan_vlan_id);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_F_SRC_REMOTE_VLAN_ID_U16))
{
dalAdoiGetEntryUI16(adoi, DAL_PORT_E_K_MONITOR, &src_rspan_vlan_id);
}
}
DBG_ALZ("dstUpIdx: %u, dst_rspan_vlan_id: %hu, src_rspan_vlan_id: %hu", dstUpIdx, dst_rspan_vlan_id, src_rspan_vlan_id);
}
}
}
// mirrored Ports handle
if (NULL != (tblHandler = DAL_ADOI_ENTRY(adoi, DAL_PORT_E_K_MONITOR_PORT)))
{
char *key = NULL;
UINT32 mirroredUpIdx = 0;
UINT32 mirrorMode = 0;
UINT8 sessionId = 0;
MIRRORED_PORT_INFO mirroredPorts[INNER_UP_PORT_MAX];
UINT8 entryNum = 0;
DAL_ADOI_ENTRY_LOOP(tblHandler)
{
if (NULL == (key = DAL_ADOI_ENTRY_KEY(tblHandler)) || !DAL_ADOI_ENTRY_KEY_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_ALL))
{
DBG_ERR("Invalid key %s !", key);
continue;
}
DAL_PORT_KEY_MONITOR_PORT_PARSE(key, mirroredUpIdx);
// DBG_ALZ("key [%s], mirroredUpIdx [%u]", key, mirroredUpIdx);
if (DAL_ADOI_ENTRY_KEY_EMPTY(tblHandler))
{
/* DAL operation is DAL_OPER_CLR */
DBG_ALZ("dal operation [delete] mirrored ports. key[%s]", key);
}
else
{
DBG_ALZ("dal operation [cfg] mirrored ports. key[%s]", key);
DAL_ADOI_ENTRY_FIELD_LOOP(tblHandler, key)
{
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_F_MODE_U32))
{
dalAdoiGetEntryUI32(adoi, DAL_PORT_E_K_MONITOR_PORT, &mirrorMode);
}
if (DAL_ADOI_ENTRY_FIELD_MATCH(tblHandler, DAL_PORT_E_K_MONITOR_PORT_F_SESSION_ID_U8))
{
dalAdoiGetEntryUI8(adoi, DAL_PORT_E_K_MONITOR_PORT, &sessionId);
}
}
DBG_ALZ("mirroredUpIdx [%u], mirrorMode [%u], sessionId [%hhu]", mirroredUpIdx, mirrorMode, sessionId);
// 被监控口配置下发 从asicDB中获取所有被监控口条目 并clear旧配置 set新配置
_dalL2PortMirrorDataGet(mirroredPorts, &entryNum);
// for (int i = 0; i < entryNum; i++)
// {
// DBG_ALZ("i[%d], mirroredPort[%u], mode[%u], mirrorPort[%hhu]", i, mirroredPorts[i].mirroredPortIdx, mirroredPorts[i].mirrorMode, mirroredPorts[i].mirrorPortIdx);
// }
_dalL2PortMirrorSet(mirroredPorts, entryNum);
}
}
}
// mib clear handle
DAL_ADOI_ACTION_LOOP(adoi)
{
char *key = NULL;
char *field = NULL;
UINT64 upIdx = UINT64_MAX;
DBG_ALZ("_dalL2PortHandle: [mibclear action]");
if (NULL == (key = DAL_ADOI_ACTION_KEY(adoi)))
{
break;
}
DBG_ALZ("key: %s", key);
if (STR_EQUAL(key, DAL_PORT_A_K_MIBCLR))
{
if (DAL_ADOI_ACTION_FIELD_MATCH(adoi, DAL_PORT_A_K_MIBCLR_F_UPNUM_U64))
{
dalAdoiGetActionUI64(adoi, &upIdx);
}
else
{
DBG_ERR("Invalid field %s !", field);
}
}
DBG_ALZ("upIdx:%llu", upIdx);
if (0 == upIdx)
{
hiPortMibCountClearAll(upIdx);
}
}
done:
return ret;
}
/**************************************************************************************************/
/* PUBLIC_FUNCTIONS */
/**************************************************************************************************/
int dalL2_portInit()
{
PFM_IF_FAIL_RET_VAL(dalHandlerReg(DAL_MOD_PORT, _dalL2PortHandle), ERR_INIT);
return ERR_NO_ERROR;
}
int dalL2PortTimerStart()
{
static TIMER_ID portMibTimer;
static TIMER_ID portStateTimer;
struct timespec tm_mib = {.tv_sec = 5, .tv_nsec = 0};
struct timespec tm_state = {.tv_sec = 2, .tv_nsec = 0};
TIMER_ID_INIT(portMibTimer);
portMibTimer = add_timer(PORT_MIB_TIMER_NAME, &tm_mib, portMibTimerHandle, NULL, 0, EXECUTE_FOREVER);
if (!TIMER_ID_IS_VALID(portMibTimer))
{
GR_PRINT_ERROR("Failed to add portMibTimer.");
return ERR_INIT;
}
TIMER_ID_INIT(portStateTimer);
portStateTimer = add_timer(PORT_STATE_TIMER_NAME, &tm_state, portStateTimerHandle, NULL, 0, EXECUTE_FOREVER);
if (!TIMER_ID_IS_VALID(portStateTimer))
{
GR_PRINT_ERROR("Failed to add portMibTimer.");
return ERR_INIT;
}
return ERR_NO_ERROR;
}
这两个代码有什么关系吗