XiaQingMiao/datalink_nc_mode
1
0
Fork 0
forked from gatsby/datalink_repo
Code Pull Requests Activity

enhance coherence.

Browse Source
This commit is contained in:
Gatsby Van
2023-12-22 10:40:55 +08:00
parent c5730a7fd5
commit 6aa2f271f5
12 changed files with 807 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files
datalink814_ge/src/common.h
+1 -1
View File
@@ -35,7 +35,7 @@
/* Stringify */
#define STR(x) #x
#define _814_DEBUG_LEVEL 3
// #define _814_DEBUG_LEVEL 3
#if _814_DEBUG_LEVEL > 0
#define DBG_PRINT(...) printf(__VA_ARGS__)
datalink814_ge/src/linklayer/linklayer814.c
+32 -32
View File
@@ -620,25 +620,25 @@ int32_t Linklayer_Init(L2_INST** instPtr, const L2_CONFIG *config) {
}
// Mpc buff Init
(*instPtr)->mgmtMsgRecvBuff0 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->mgmtMsgRecvBuff0 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->mgmtMsgRecvBuff0 == NULL) {
DBG_ERROR("Allocate memory for mgmtMsgRecvBuff0 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->svcMsgRecvBuff0 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->svcMsgRecvBuff0 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->svcMsgRecvBuff0 == NULL) {
DBG_ERROR("Allocate memory for svcMsgRecvBuff0 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->mgmtMsgRecvBuff1 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->mgmtMsgRecvBuff1 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->mgmtMsgRecvBuff1 == NULL) {
DBG_ERROR("Allocate memory for mgmtMsgRecvBuff1 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->svcMsgRecvBuff1 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->svcMsgRecvBuff1 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->svcMsgRecvBuff1 == NULL) {
DBG_ERROR("Allocate memory for svcMsgRecvBuff1 failed.\n");
Status = EALLOC;
@@ -667,8 +667,8 @@ int32_t Linklayer_Init(L2_INST** instPtr, const L2_CONFIG *config) {
(*instPtr)->tor.next = L2_TOR_SUSPEND;
(*instPtr)->rtneConfig.rtneTable = initTable;
(*instPtr)->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
(*instPtr)->mainState = INIT_STATE;
(*instPtr)->nextState = INIT_STATE;
(*instPtr)->mainState = L2_INIT_STATE;
(*instPtr)->nextState = L2_INIT_STATE;
(*instPtr)->myInfo.nodeId = config->myId;
(*instPtr)->myInfo.clustId = config->clustId;
(*instPtr)->myInfo.headId = config->headId;
@@ -761,8 +761,8 @@ int32_t Linklayer_Reconfig(L2_INST* instPtr, const L2_CONFIG *config) {
instPtr->tor.next = L2_TOR_SUSPEND;
instPtr->rtneConfig.rtneTable = initTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
instPtr->mainState = INIT_STATE;
instPtr->nextState = INIT_STATE;
instPtr->mainState = L2_INIT_STATE;
instPtr->nextState = L2_INIT_STATE;
instPtr->myInfo.nodeId = config->myId;
instPtr->myInfo.clustId = config->clustId;
instPtr->myInfo.headId = config->headId;
@@ -863,11 +863,11 @@ int32_t Linklayer_EventHandler(L2_INST* instPtr, const L2_EVENT* l2Event) {
}
case L2_EV_NET_SETUP_DONE: {
DBG_INFO("Event L2_EV_NETSETUP_DONE asserted....\n");
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
instPtr->cxn2Net = true;
}
else{ // Head node
UpdateMainSate(instPtr, NORMAL_STATE);
UpdateMainSate(instPtr, L2_NORMAL_STATE);
}
break;
}
@@ -895,26 +895,26 @@ int32_t Linklayer_EventHandler(L2_INST* instPtr, const L2_EVENT* l2Event) {
}
case L2_ROUTINE_FINISH: {
DBG_INFO("Event L2_ROUTINE_FINISH asserted....\n");
if(instPtr->nextState == INIT_STATE){
if(instPtr->nextState == L2_INIT_STATE){
// Reset scan net FMS for next scan process.
ScanNet_Reset(instPtr->scanNetFSM);
UpdateMainSate(instPtr, NORMAL_STATE);
UpdateMainSate(instPtr, L2_NORMAL_STATE);
instPtr->rtneConfig.rtneTable = normalTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable);
}
else if(instPtr->nextState == NORMAL_STATE){
else if(instPtr->nextState == L2_NORMAL_STATE){
instPtr->rtneConfig.rtneTable = normalTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable);
}
else if(instPtr->nextState == SEEK_STATE){
else if(instPtr->nextState == L2_SEEK_STATE){
instPtr->rtneConfig.rtneTable = seekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(seekTable);
}
else if(instPtr->nextState == INTRA_SEEK_STATE){
else if(instPtr->nextState == L2_INTRA_SEEK_STATE){
instPtr->rtneConfig.rtneTable = intraSeekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(intraSeekTable);
}
else if(instPtr->nextState == INTER_SEEK_STATE){
else if(instPtr->nextState == L2_INTER_SEEK_STATE){
instPtr->rtneConfig.rtneTable = interSeekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(interSeekTable);
}
@@ -1047,27 +1047,27 @@ static int32_t Linklayer_Routine (L2_INST* instPtr) {
DBG_INFO("## Routine: %u-%u, Routine period: %u.\n", tableIndx, entryIndx, instPtr->rtneConfig.rtnePrd);
switch (rtneEntry.slotType) {
case SLOT_IDLE:
case L2_SLOT_IDLE:
// Skip a 5ms slot.
Status = SUCCESS;
DBG_INFO("Skipping idle slot (5ms)...\n");
break;
case SLOT_INTER_SCAN_ACQ:
case SLOT_INTRA_SCAN_ACQ:
case SLOT_INTER_SCAN_BM:
case SLOT_INTRA_SCAN_BM:
case SLOT_INTER_SCAN_2W:
case SLOT_INTRA_SCAN_2W:
case L2_SLOT_INTER_SCAN_ACQ:
case L2_SLOT_INTRA_SCAN_ACQ:
case L2_SLOT_INTER_SCAN_BM:
case L2_SLOT_INTRA_SCAN_BM:
case L2_SLOT_INTER_SCAN_2W:
case L2_SLOT_INTRA_SCAN_2W:
Status = ScanNet_Routine(instPtr, &rtneEntry);
break;
case SLOT_INTER_SVC:
case SLOT_INTRA_SVC:
case L2_SLOT_INTER_SVC:
case L2_SLOT_INTRA_SVC:
Status = ServiceNet_Routine(instPtr, &rtneEntry);
break;
case SLOT_INTER_MGMT:
case SLOT_INTRA_MGMT:
case SLOT_INTER_TSYNC:
case SLOT_INTRA_TSYNC:
case L2_SLOT_INTER_MGMT:
case L2_SLOT_INTRA_MGMT:
case L2_SLOT_INTER_TSYNC:
case L2_SLOT_INTRA_TSYNC:
Status = MgmtNet_Routine(instPtr, &rtneEntry);
break;
default:
@@ -1082,7 +1082,7 @@ static int32_t Linklayer_Routine (L2_INST* instPtr) {
}
// FIXME: Increase TTL counter
if (instPtr->mainState != INIT_STATE)
if (instPtr->mainState != L2_INIT_STATE)
{
// if ( L2_isNodeInList (instPtr->nodeList, rtneEntry.src0) )
// {
@@ -1123,11 +1123,11 @@ int32_t Linklayer_Proc(L2_INST* instPtr) {
}
// Run Link layer routine, setup next slot procedure.
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
Status = Linklayer_Routine(instPtr);
}
else { //MEMBER_NODE
else { //L2_NODE_MEMBER
if (L2_isCxn2Net(instPtr)) {
Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
Status = Linklayer_Routine(instPtr);
datalink814_ge/src/linklayer/linklayer814_types.h
+46 -46
View File
@@ -24,11 +24,11 @@
#include "../phy_ctrl/phy_ctrl.h"
/************************** Constant Definitions *****************************/
// Common node ID definition
#define BROADCAST_ID 0x1F
#define NONE_ID 0
#define L2_BROADCAST_ID 0x1F
#define L2_NONE_ID 0
// for MPC Configure
#define MSG_STROAGE_BUFF_MAX 16384 // 16K Bytes
#define L2_MSG_STROAGE_BUFF_MAX 16384 // 16K Bytes
// Routine configure
#define L2_INIT_RTNE_PERIOD 24
@@ -45,11 +45,11 @@
#define L2_SLOTS_PER_FRAME 200
#define L2_SLOTS_PER_SUBFRAME 20
#define NUM_SLOTS_NONE UINT32_MAX
#define NUM_SLOTS_20MS 4
#define NUM_SLOTS_10MS 2
#define NUM_SLOTS_5MS 1
#define NUM_SLOTS_SKIP 0
#define L2_NUM_SLOTS_NONE UINT32_MAX
#define L2_NUM_SLOTS_20MS 4
#define L2_NUM_SLOTS_10MS 2
#define L2_NUM_SLOTS_5MS 1
#define L2_NUM_SLOTS_SKIP 0
/**************************** Type Definitions *******************************/
@@ -70,21 +70,21 @@ typedef enum {
/** @name Prior information type definition
*/
typedef enum {
NONE_TYPE = 0,
HEAD_NODE = 1,
MEMBER_NODE = 2,
BACKUP_HEAD = 3
L2_NODE_NONE = 0,
L2_NODE_HEAD = 1,
L2_NODE_MEMBER = 2,
L2_NODE_BACKUP = 3
} L2_NODE_TYPE;
/** @name Node state type definition
*/
typedef enum {
NONE_STATE = 0,
INIT_STATE = 1,
NORMAL_STATE = 2,
INTRA_SEEK_STATE = 3,
INTER_SEEK_STATE = 4,
SEEK_STATE = 5
L2_NONE_STATE = 0,
L2_INIT_STATE = 1,
L2_NORMAL_STATE = 2,
L2_INTRA_SEEK_STATE = 3,
L2_INTER_SEEK_STATE = 4,
L2_SEEK_STATE = 5
} L2_NODE_STATE;
typedef struct {
@@ -129,20 +129,20 @@ typedef struct {
* A definition of different slots.
*/
typedef enum {
SLOT_NONE = 0,
SLOT_IDLE = 1,
SLOT_INTER_SCAN_ACQ = 2,
SLOT_INTRA_SCAN_ACQ = 3,
SLOT_INTER_SCAN_BM = 4,
SLOT_INTRA_SCAN_BM = 5,
SLOT_INTER_SCAN_2W = 6,
SLOT_INTRA_SCAN_2W = 7,
SLOT_INTER_SVC = 8,
SLOT_INTRA_SVC = 9,
SLOT_INTER_MGMT = 10,
SLOT_INTRA_MGMT = 11,
SLOT_INTER_TSYNC = 12,
SLOT_INTRA_TSYNC = 13,
L2_SLOT_NONE = 0,
L2_SLOT_IDLE = 1,
L2_SLOT_INTER_SCAN_ACQ = 2,
L2_SLOT_INTRA_SCAN_ACQ = 3,
L2_SLOT_INTER_SCAN_BM = 4,
L2_SLOT_INTRA_SCAN_BM = 5,
L2_SLOT_INTER_SCAN_2W = 6,
L2_SLOT_INTRA_SCAN_2W = 7,
L2_SLOT_INTER_SVC = 8,
L2_SLOT_INTRA_SVC = 9,
L2_SLOT_INTER_MGMT = 10,
L2_SLOT_INTRA_MGMT = 11,
L2_SLOT_INTER_TSYNC = 12,
L2_SLOT_INTRA_TSYNC = 13,
} L2_SLOT_TYPE;
/** @name Frame types
@@ -214,17 +214,17 @@ typedef struct {
} L2_W2ACQ_LOG;
typedef enum {
NONE_STAGE = 0,
INIT_SCAN_STAGE = 1,
BM_ADVT_STAGE = 2, // Benchmark advertisement
WAY2_ACQ_STAGE = 3
L2_SCAN_NONE_STAGE = 0,
L2_SCAN_INIT_STAGE = 1,
L2_SCAN_BMADVT_STAGE = 2, // Benchmark advertisement
L2_SCANT_2WAYACQ_STAGE = 3
} SCAN_STAGE;
typedef enum {
NONE_MODE = 0,
INTRA_CLUSTER_MODE = 1,
INTER_CLUSTER_MODE = 2
} SCAN_MODE;
L2_SCAN_NONE_MODE = 0,
L2_SCAN_INTRA_MODE = 1,
L2_SCAN_INTER_MODE = 2
} L2_SCAN_MODE;
typedef struct {
bool isLocked; // init acq done.
@@ -234,7 +234,7 @@ typedef struct {
uint32_t bmTimeout;
uint32_t w2acqTimeout;
SCAN_STAGE scanStage; // only for member node
SCAN_MODE scanMode; // inter sanc or intra scan
L2_SCAN_MODE scanMode; // inter sanc or intra scan
L2_BM_LOG BMrcvLog;
L2_W2ACQ_LOG W2ACQrcvLog;
} L2_SCAN_FSM;
@@ -264,7 +264,7 @@ typedef struct {
uint32_t Longitude ;
uint32_t Latitude ;
bool isValid;
} MGMT_MSG_RECORD;
} L2_MGMT_MSG_RECORD;
typedef struct {
uint16_t wordTag;
@@ -276,15 +276,15 @@ typedef struct {
uint32_t timeWordL;
uint32_t timeWordH;
int32_t doppler;
} RTT_MSG_RECORD;
} L2_RTT_MSG_RECORD;
typedef struct {
bool isBisarProc;
bool isPendTimeAlloc;
bool isPendSlotAlloc;
MGMT_MSG_RECORD mgmtMsgLog;
RTT_MSG_RECORD rttMsgRspLog;
RTT_MSG_RECORD rttMsgReqLog;
L2_MGMT_MSG_RECORD mgmtMsgLog;
L2_RTT_MSG_RECORD rttMsgRspLog;
L2_RTT_MSG_RECORD rttMsgReqLog;
} L2_MGMT_FSM;
typedef struct{
datalink814_ge/src/linklayer/linklayer_routine.c
+600 -602
View File
File diff suppressed because it is too large Load Diff
datalink814_ge/src/linklayer/net_mgmt.c
+36 -36
View File
@@ -106,21 +106,21 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, TK_MSG_INI_OFFSET, TK_MSG_INI_LEN, dataChunk);
// Next net stage
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
switch (instPtr->nextState) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = NET_INTRA_SEEK_STAGE;
break;
case INTER_SEEK_STATE:
case L2_INTER_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_SEEK_STAGE;
break;
default:
@@ -405,7 +405,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
// // Quit object
// dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
// FrameInsertChunk(bitarr, NQT_MSG_OBJ_OFFSET, NQT_MSG_OBJ_LEN, dataChunk);
// L2_NODE_STATE newState = INIT_STATE;
// L2_NODE_STATE newState = L2_INIT_STATE;
// L2_EVENT stateEvent = {
// .event = L2_EV_MAIN_STATE_UPDATE,
// .msg = &newState
@@ -451,7 +451,7 @@ static int32_t MgmtPkt_Packing(L2_INST* instPtr, MGMTPKT_TYPE pktType) {
BIT_ARRAY* mgmtPkt = bit_array_create(L2_MSG_MAX);
if (mgmtPkt == NULL) {
DBG_ERROR("Failed to allocate memory for scanMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
switch (pktType) {
case MGMTPKT_INTRA_MGMT:
@@ -551,7 +551,7 @@ void MgmtNet_Reset(L2_MGMT_FSM* mgmtFSM) {
mgmtFSM->isPendSlotAlloc = false;
mgmtFSM->isPendTimeAlloc = false;
mgmtFSM->mgmtMsgLog.nextNetState = NONE_STATE;
mgmtFSM->mgmtMsgLog.nextNetState = L2_NONE_STATE;
mgmtFSM->mgmtMsgLog.isValid = false;
mgmtFSM->mgmtMsgLog.quitCtrlWord = 0;
mgmtFSM->mgmtMsgLog.quitNodeId = 0;
@@ -569,8 +569,8 @@ void MgmtNet_Reset(L2_MGMT_FSM* mgmtFSM) {
mgmtFSM->mgmtMsgLog.Latitude = 0 ;
// clear buffer.
memset(&(mgmtFSM->rttMsgRspLog), 0x00, sizeof(RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgReqLog), 0x00, sizeof(RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgRspLog), 0x00, sizeof(L2_RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgReqLog), 0x00, sizeof(L2_RTT_MSG_RECORD));
}
@@ -603,9 +603,9 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
int32_t Status;
uint32_t filedSize = 0;
uint64_t dataChunk = 0;
MGMT_MSG_RECORD *mgmtMsgLog = &(instPtr->mgmtNetFSM->mgmtMsgLog);
RTT_MSG_RECORD *rttMsgRspLog = &(instPtr->mgmtNetFSM->rttMsgRspLog);
RTT_MSG_RECORD *rttMsgReqLog = &(instPtr->mgmtNetFSM->rttMsgReqLog);
L2_MGMT_MSG_RECORD *mgmtMsgLog = &(instPtr->mgmtNetFSM->mgmtMsgLog);
L2_RTT_MSG_RECORD *rttMsgRspLog = &(instPtr->mgmtNetFSM->rttMsgRspLog);
L2_RTT_MSG_RECORD *rttMsgReqLog = &(instPtr->mgmtNetFSM->rttMsgReqLog);
BIT_ARRAY* mgmtMsg = bit_array_create(L2_MSG_MAX);
if (mgmtMsg == NULL) {
@@ -702,24 +702,24 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
}
}
// Member Node update state with received message
if(L2_GetNodeId(instPtr) != HEAD_NODE && mgmtMsgLog->isValid == true ){
L2_NODE_STATE newState = NONE_STATE;
if(L2_GetNodeId(instPtr) != L2_NODE_HEAD && mgmtMsgLog->isValid == true ){
L2_NODE_STATE newState = L2_NONE_STATE;
// FIXME :
switch (mgmtMsgLog->nextNetState) {
case NET_INI_STAGE:
newState = INIT_STATE;
newState = L2_INIT_STATE;
break;
case NET_NORMAL_STAGE:
newState = NORMAL_STATE;
newState = L2_NORMAL_STATE;
break;
case NET_INTRA_SEEK_STAGE:
newState = INTRA_SEEK_STATE;
newState = L2_INTRA_SEEK_STATE;
break;
case NET_INTER_SEEK_STAGE:
newState = INTER_SEEK_STATE;
newState = L2_INTER_SEEK_STATE;
break;
case NET_SEEK_STAGE:
newState = SEEK_STATE;
newState = L2_SEEK_STATE;
break;
default:
DBG_WARNING("Unknown Head node state [%d].\n", mgmtMsgLog->nextNetState);
@@ -742,7 +742,7 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
}
case L2_INTER_TSYNC_FRAME:
case L2_INTRA_TSYNC_FRAME: {
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
for (int i = 0; i < ARRAY_SIZE(rttReqFrameMsgs); i++) {
memcpy(mgmtMsg->words,
instPtr->recvPktData + (size_t) (i * (RTT_MSG_LEN / 8)),
@@ -919,7 +919,7 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
if (L2_GetLastFrameType(instPtr) == L2_INTRA_TSYNC_FRAME && L2_GetLastTor(instPtr) == L2_TOR_RX) {
RTT_FsmUpdate(instPtr, L2_TOR_RX);
}
if (rtneEntry->slotType == SLOT_INTRA_TSYNC) {
if (rtneEntry->slotType == L2_SLOT_INTRA_TSYNC) {
if(torState == L2_TOR_TX) {
RTT_FsmUpdate(instPtr, L2_TOR_TX);
}
@@ -934,11 +934,11 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
}
switch (rtneEntry->slotType) {
case SLOT_INTER_MGMT:
case L2_SLOT_INTER_MGMT:
// TODO:
L2_SetupNextSlot(instPtr, torState, L2_INTER_MGMT_FRAME);
break;
case SLOT_INTRA_MGMT:
case L2_SLOT_INTRA_MGMT:
memset(instPtr->sendPktData, 0xAA, INTRA_MGMT_FRAME_LENGTH_MAX);
if (torState == L2_TOR_TX) {
if(MgmtPkt_Packing(instPtr, MGMTPKT_INTRA_MGMT) != SUCCESS) {
@@ -948,14 +948,14 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
}
L2_SetupNextSlot(instPtr, torState, L2_INTRA_MGMT_FRAME);
break;
case SLOT_INTER_TSYNC:
case L2_SLOT_INTER_TSYNC:
// TODO:
L2_SetupNextSlot(instPtr, torState, L2_INTER_TSYNC_FRAME);
break;
case SLOT_INTRA_TSYNC:
case L2_SLOT_INTRA_TSYNC:
if (torState == L2_TOR_TX) {
memset(instPtr->sendPktData, 0xAA, INTRA_RTT_FRAME_LENGTH_MAX);
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
if(MgmtPkt_Packing(instPtr, MGMTPKT_INTRA_RTTREQ) != SUCCESS) {
Status = FAILURE;
goto routine_err;
@@ -978,26 +978,26 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
/*************************************************/
// Update link layer state...
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
L2_NODE_STATE newState = NONE_STATE;
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
L2_NODE_STATE newState = L2_NONE_STATE;
L2_EVENT stateEvent = {
.event = L2_EV_MAIN_STATE_UPDATE,
.msg = &newState
};
if (L2_GetNodeListLen(instPtr->nodeList) < instPtr->config.netScale
&& L2_GetMainState(instPtr) != INTRA_SEEK_STATE) {
newState = INTRA_SEEK_STATE;
&& L2_GetMainState(instPtr) != L2_INTRA_SEEK_STATE) {
newState = L2_INTRA_SEEK_STATE;
AssertL2Event(instPtr, &stateEvent);
}
else if(L2_GetNodeListLen(instPtr->nodeList) >= instPtr->config.netScale &&
L2_GetMainState(instPtr) != NORMAL_STATE){
newState = NORMAL_STATE;
L2_GetMainState(instPtr) != L2_NORMAL_STATE){
newState = L2_NORMAL_STATE;
AssertL2Event(instPtr, &stateEvent);
}
}
else{ // MEMBER_NODE or BACKUP_HEAD
else{ // L2_NODE_MEMBER or BACKUP_HEAD
if(L2_isNodeInList(instPtr->nodeList, L2_GetHeadId(instPtr)) == false){
L2_NODE_STATE newState = INIT_STATE;
L2_NODE_STATE newState = L2_INIT_STATE;
L2_EVENT stateEvent = {
.event = L2_EV_MAIN_STATE_UPDATE,
.msg = &newState
datalink814_ge/src/linklayer/net_scan.c
+66 -66
View File
@@ -225,7 +225,7 @@ static int32_t ScanMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
/* message type */
dataChunk = (L2_GetNodeId(instPtr) == HEAD_NODE) ? 0 : 1;
dataChunk = (L2_GetNodeId(instPtr) == L2_NODE_HEAD) ? 0 : 1;
FrameInsertChunk(bitarr, NS_MSG_INI_TYPE_OFFSET, NS_MSG_INI_TYPE_LEN, dataChunk);
/* source node id */
@@ -234,20 +234,20 @@ static int32_t ScanMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, NS_MSG_INI_SRC_ADDR_OFFSET, NS_MSG_INI_SRC_ADDR_LEN, dataChunk);
/* destination node id */
dataChunk = (L2_GetNodeId(instPtr) == HEAD_NODE) ?
(BROADCAST_ID | (BROADCAST_ID << 5))
dataChunk = (L2_GetNodeId(instPtr) == L2_NODE_HEAD) ?
(L2_BROADCAST_ID | (L2_BROADCAST_ID << 5))
: (L2_GetHeadId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
/* current net stage */
switch (instPtr->mainState) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
default:
@@ -373,7 +373,7 @@ static int32_t ScanPkt_Packing(L2_INST* instPtr, SCANPKT_TYPE pktType){
BIT_ARRAY* scanPkt = bit_array_create(L2_MSG_MAX);
if (scanPkt == NULL) {
DBG_ERROR("Failed to allocate memory for scanMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
switch (pktType) {
case SCANPKT_INTRA_BM:
@@ -426,24 +426,24 @@ static int32_t Scan_InitScanHandler(L2_INST* instPtr) {
L2_SCAN_FSM* scanFsmPtr = instPtr->scanNetFSM;
DBG_INFO("** Netsetup - InitScan Procedure (Attempts: %u)**\n", scanFsmPtr->scanCnt);
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
if (scanFsmPtr->isLocked == true) {
StageUpdate(scanFsmPtr, BM_ADVT_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_BMADVT_STAGE);
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_BM_FRAME);
} /* Otherwise remain INIT_SCAN_STAGE */
} /* Otherwise remain L2_SCAN_INIT_STAGE */
else {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_SCAN_FRAME);
scanFsmPtr->scanCnt++;
}
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
if (scanFsmPtr->isLocked == true) {
StageUpdate(scanFsmPtr, BM_ADVT_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_BMADVT_STAGE);
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_BM_FRAME);
} /* Otherwise remain INIT_SCAN_STAGE */
} /* Otherwise remain L2_SCAN_INIT_STAGE */
else {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_SCAN_FRAME);
@@ -452,9 +452,9 @@ static int32_t Scan_InitScanHandler(L2_INST* instPtr) {
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
return (NUM_SLOTS_SKIP);
return SUCCESS;
}
/*****************************************************************************/
@@ -477,45 +477,45 @@ static int32_t Scan_BmAdvtHandler(L2_INST* instPtr) {
scanFsmPtr->bmTimeout = 0; /* reset listen counter. */
DBG_INFO("Received Bm frame, skipping 10ms for turn around...\n");
// TODO: check functionality.
StageUpdate(scanFsmPtr, WAY2_ACQ_STAGE);
return NUM_SLOTS_10MS;
StageUpdate(scanFsmPtr, L2_SCANT_2WAYACQ_STAGE);
return SUCCESS;
}
// no valid bm frame was received.
else {
/* if time out reached, go back to init scan stage. */
if (scanFsmPtr->bmTimeout > BM_LSTEN_TIMEOUT) {
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_SCAN_FRAME);
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_SCAN_FRAME);
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
DBG_WARNING("BM timeout, restart net scan from INIT_SCAN_STAGE.\n");
DBG_WARNING("BM timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
scanFsmPtr->bmTimeout = 0; /* reset listen counter. */
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
}
else {
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_BM_FRAME);
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_BM_FRAME);
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
scanFsmPtr->bmTimeout++;
}
return NUM_SLOTS_SKIP;
return SUCCESS;
}
}
@@ -533,10 +533,10 @@ static int32_t Scan_2WAcqHandler (L2_INST* instPtr){
DBG_INFO("** Netsetup - 2WAcq Procedure (Timeout: %u) **\n", scanFsmPtr->w2acqTimeout);
L2_FRAME_TYPE frameType = L2_NONE_FRAME;
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
frameType = L2_INTRA_W2_ACQ_FRAME;
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
frameType = L2_INTER_W2_ACQ_FRAME;
}
else{
@@ -546,9 +546,9 @@ static int32_t Scan_2WAcqHandler (L2_INST* instPtr){
// 2 way acq failed, back to init stage.
if (scanFsmPtr->w2acqTimeout >= WAY2_ACQ_SLOT_MAX) {
DBG_WARNING("2WAcq timeout, restart net scan from INIT_SCAN_STAGE.\n");
DBG_WARNING("2WAcq timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
scanFsmPtr->w2acqTimeout = 0; // reset counter for next scan.
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
}
else {
scanFsmPtr->w2acqTimeout++; // increase counter.
@@ -631,11 +631,11 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
goto failed;
}
}
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
NODE_ENTRY* nodeEntry = L2_GetNodeById(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId);
if(nodeEntry == NULL) {
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId, HEAD_NODE);
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId, L2_NODE_HEAD);
// TODO: Insert other node information.
}
else {
@@ -671,22 +671,22 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
FrameGetChunk(scanMsg, NS_MSG_INI_NET_STAGE_OFFSET, NS_MSG_INI_NET_STAGE_LEN, &dataChunk);
switch (dataChunk) {
case NET_INI_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INIT_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INIT_STATE;
break;
case NET_NORMAL_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = NORMAL_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_NORMAL_STATE;
break;
case NET_INTRA_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INTRA_SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INTRA_SEEK_STATE;
break;
case NET_INTER_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INTER_SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INTER_SEEK_STATE;
break;
case NET_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_SEEK_STATE;
break;
default:
scanFsmPtr->W2ACQrcvLog.NetStage = NONE_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_NONE_STATE;
DBG_WARNING("UNEXPECTED head node state.");
break;
}
@@ -728,14 +728,14 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
NODE_ENTRY* nodeEntry = L2_GetNodeById(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId);
if(nodeEntry == NULL) {
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId, MEMBER_NODE);
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId, L2_NODE_MEMBER);
// TODO: Insert other node information.
}
else {
// TODO: Update node information.
}
if(L2_GetNodeType(instPtr) != HEAD_NODE && scanFsmPtr->W2ACQrcvLog.NetStage != NONE_STATE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD && scanFsmPtr->W2ACQrcvLog.NetStage != L2_NONE_STATE){
// Update net start time
instPtr->netStartTime = scanFsmPtr->W2ACQrcvLog.NetScanTime;
// sync state with head node
@@ -747,18 +747,18 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
AssertL2Event(instPtr, &stateUpEvent);
// check if net setup finished.
if(L2_GetMainState(instPtr) == INIT_STATE && L2_isCxn2Net(instPtr) == false){
if(L2_GetMainState(instPtr) == L2_INIT_STATE && L2_isCxn2Net(instPtr) == false){
L2_RTNE_CONFIG newRtneConfig = {0};
L2_EVENT rtneUpEvent = {
.event = L2_ROUTINE_UPDATE,
.msg = &newRtneConfig
};
if(scanFsmPtr->W2ACQrcvLog.NetStage == INIT_STATE){
if(scanFsmPtr->W2ACQrcvLog.NetStage == L2_INIT_STATE){
newRtneConfig.rtneTable = initTable;
newRtneConfig.rtnePrd = ARRAY_SIZE(initTable);
AssertL2Event(instPtr, &rtneUpEvent);
}
else if(scanFsmPtr->W2ACQrcvLog.NetStage == INTRA_SEEK_STATE){
else if(scanFsmPtr->W2ACQrcvLog.NetStage == L2_INTRA_SEEK_STATE){
newRtneConfig.rtneTable = intraSeekTable;
newRtneConfig.rtnePrd = ARRAY_SIZE(intraSeekTable);
AssertL2Event(instPtr, &rtneUpEvent);
@@ -823,8 +823,8 @@ void ScanNet_Reset(L2_SCAN_FSM* scanFSMPtr) {
scanFSMPtr->scanCnt = 0;
scanFSMPtr->bmTimeout = 0;
scanFSMPtr->w2acqTimeout = 0;
scanFSMPtr->scanStage = NONE_STAGE;
scanFSMPtr->scanMode = INTRA_CLUSTER_MODE;
scanFSMPtr->scanStage = L2_SCAN_NONE_STAGE;
scanFSMPtr->scanMode = L2_SCAN_INTRA_MODE;
// FIXME: Only for test
scanFSMPtr->BMrcvLog.Height = 0;
scanFSMPtr->BMrcvLog.Latitude = 0;
@@ -840,7 +840,7 @@ void ScanNet_Reset(L2_SCAN_FSM* scanFSMPtr) {
scanFSMPtr->W2ACQrcvLog.EastSpeed = 0;
scanFSMPtr->W2ACQrcvLog.NorthSpeed = 0;
scanFSMPtr->W2ACQrcvLog.UpperSpeed = 0;
scanFSMPtr->W2ACQrcvLog.NetStage = NONE_STATE;
scanFSMPtr->W2ACQrcvLog.NetStage = L2_NONE_STATE;
scanFSMPtr->W2ACQrcvLog.NetScanTime = 0;
}
@@ -868,25 +868,25 @@ void ScanNet_Destroy(L2_SCAN_FSM* scanFSMPtr) {
******************************************************************************/
int32_t ScanNet_Proc(L2_INST* instPtr) {
L2_SCAN_FSM* scanFsmPtr = instPtr->scanNetFSM;
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
DBG_ERROR("Only member node needs to execute ScanNet_Proc. \n");
return NUM_SLOTS_NONE;
return FAILURE;
}
int32_t Status;
DBG_INFO("-------- ScanNet Process --------\n");
switch (scanFsmPtr->scanStage) {
case NONE_STAGE:
case L2_SCAN_NONE_STAGE:
/* Start Scan. */
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
Status = Scan_InitScanHandler(instPtr);
break;
case INIT_SCAN_STAGE:
case L2_SCAN_INIT_STAGE:
Status = Scan_InitScanHandler(instPtr);
break;
case BM_ADVT_STAGE:
case L2_SCAN_BMADVT_STAGE:
Status = Scan_BmAdvtHandler(instPtr);
break;
case WAY2_ACQ_STAGE:
case L2_SCANT_2WAYACQ_STAGE:
Status = Scan_2WAcqHandler(instPtr);
break;
default:
@@ -918,11 +918,11 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
return SQUENCE_SCAN_SLOTS;
}
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if (rtneEntry->dst0 == L2_GetNodeId(instPtr) || rtneEntry->dst0 == BROADCAST_ID){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
if (rtneEntry->dst0 == L2_GetNodeId(instPtr) || rtneEntry->dst0 == L2_BROADCAST_ID){
torState = L2_TOR_RX;
}
else if (rtneEntry->src0 == L2_GetNodeId(instPtr) || rtneEntry->src0 == BROADCAST_ID){
else if (rtneEntry->src0 == L2_GetNodeId(instPtr) || rtneEntry->src0 == L2_BROADCAST_ID){
torState = L2_TOR_TX;
}
else {
@@ -942,13 +942,13 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
}
switch (rtneEntry->slotType) {
case SLOT_INTER_SCAN_ACQ:
case L2_SLOT_INTER_SCAN_ACQ:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_SCAN_FRAME);
break;
case SLOT_INTRA_SCAN_ACQ:
if (L2_GetNodeType(instPtr) != HEAD_NODE && torState == L2_TOR_TX) {
case L2_SLOT_INTRA_SCAN_ACQ:
if (L2_GetNodeType(instPtr) != L2_NODE_HEAD && torState == L2_TOR_TX) {
DBG_ERROR("Only head node can send init-scan Frame.\n");
Status = FAILURE;
goto routine_err;
@@ -956,14 +956,14 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
L2_SetupNextSlot(instPtr, torState, L2_INTRA_SCAN_FRAME);
break;
case SLOT_INTER_SCAN_BM:
case L2_SLOT_INTER_SCAN_BM:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_BM_FRAME);
break;
case SLOT_INTRA_SCAN_BM:
case L2_SLOT_INTRA_SCAN_BM:
if (torState == L2_TOR_TX) {
if (L2_GetNodeType(instPtr) != HEAD_NODE) {
if (L2_GetNodeType(instPtr) != L2_NODE_HEAD) {
DBG_ERROR("Only head node can send BM Frame.\n");
Status = FAILURE;
goto routine_err;
@@ -977,13 +977,13 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_TX, L2_INTRA_BM_FRAME);
break;
case SLOT_INTER_SCAN_2W:
case L2_SLOT_INTER_SCAN_2W:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_W2_ACQ_FRAME);
break;
case SLOT_INTRA_SCAN_2W:
case L2_SLOT_INTRA_SCAN_2W:
if (torState == L2_TOR_TX) {
if(L2_GetNodeType(instPtr) != HEAD_NODE && L2_isDataAvail(instPtr) == false) {
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD && L2_isDataAvail(instPtr) == false) {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTRA_W2_ACQ_FRAME);
break;
datalink814_ge/src/linklayer/net_service.c
+4 -4
View File
@@ -187,7 +187,7 @@ int32_t ServiceNet_Init(L2_SVC_FSM** serviceFSM) {
void ServiceNet_Reset(L2_SVC_FSM* serviceFSM) {
serviceFSM->isBisar = false;
serviceFSM->isBisarEven = false;
serviceFSM->bisarDst = NONE_ID;
serviceFSM->bisarDst = L2_NONE_ID;
}
void ServiceNet_Destroy(L2_SVC_FSM* serviceFSM){
@@ -242,14 +242,14 @@ int32_t ServiceNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntr
BIT_ARRAY* svcMsg = bit_array_create(L2_MSG_MAX);
if(svcMsg == NULL){
DBG_ERROR("Failed to allocate memory for svcMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
memset(instPtr->sendPktData, 0xCC, (size_t)(INTRA_SVC_FRAME_LENGTH_MAX));
switch(rtneEntry->slotType){
case SLOT_INTER_SVC:
case L2_SLOT_INTER_SVC:
L2_SetupNextSlot(instPtr, torState, L2_INTER_SVC_FRAME);
break;
case SLOT_INTRA_SVC:
case L2_SLOT_INTRA_SVC:
if(torState == L2_TOR_TX){
//TODO:
memset(instPtr->sendPktData, 0xAA, INTRA_SVC_FRAME_LENGTH_MAX);
datalink814_ge/src/linklayer/time_sync.c
+1 -1
View File
@@ -248,7 +248,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
DBG_INFO("-------- RTT FSM Update --------\n");
// Stage trans
// For Head Node: Tx->Rx->Tx->Rx
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
switch(rttFsmPtr->rttStage) {
case RTT_REQ1 :
if(torType == L2_TOR_TX){
datalink814_ge/src/main.c
+1 -1
View File
@@ -39,7 +39,7 @@
/************************** Constant Definitions *****************************/
L2_CONFIG l2Config = {
.myType = MEMBER_NODE,
.myType = L2_NODE_MEMBER,
.isInterHead = false,
.myId = 2,
.clustId = 1,
datalink814_ge/src/mpc/mpc_ctrl.c
+6 -6
View File
@@ -206,11 +206,11 @@ int MPC_MsgHandler(MPC_INST* instPtr){
MPC_GetChunk(mpcRxMsgBuff, TEST_MODE_SET_OFFSET, TEST_MODE_SET_LEN, &dataChunk);
// FIXME
if((uint8_t)dataChunk == TEST_MODE_HEAD){
l2Config.myType = HEAD_NODE;
l2Config.myType = L2_NODE_HEAD;
l2Config.myId = 1;
}
else{
l2Config.myType = MEMBER_NODE;
l2Config.myType = L2_NODE_MEMBER;
l2Config.myId = 2;
}
MPC_InsertChunk(mpcTxMsgBuff, TEST_REQ_FPGA_ST_OFFSET, TEST_REQ_FPGA_ST_LEN, 0x01);
@@ -313,7 +313,7 @@ int MPC_SendMsg(MPC_INST* instPtr, MPC_MSG_TYPE type, uint8_t* buffer, uint32_t
*
******************************************************************************/
int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgCnt ,
uint8_t* svcBuffer , uint32_t svcMsgCnt , MGMT_MSG_RECORD* mgmtMsg){
uint8_t* svcBuffer , uint32_t svcMsgCnt , L2_MGMT_MSG_RECORD* mgmtMsg){
ASSERT(instPtr != NULL);
int32_t Status = SUCCESS;
uint64_t dataChunk = 0;
@@ -323,13 +323,13 @@ int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgC
// Stage
switch (linkInstPtr->mainState) {
case INIT_STATE :
case L2_INIT_STATE :
dataChunk = STATE_STAGE_SETUP;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = STATE_STAGE_RTNE;
break;
case NORMAL_STATE :
case L2_NORMAL_STATE :
dataChunk = STATE_STAGE_SVC;
break;
default:
datalink814_ge/src/mpc/mpc_ctrl.h
+1 -1
View File
@@ -98,7 +98,7 @@ extern MPC_INST* mpcInstPtr;
int MPC_Init(MPC_INST** instPtr, MPC_CONFIG* configPtr);
int MPC_MsgHandler(MPC_INST* instPtr);
int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgCnt
, uint8_t* svcBuffer , uint32_t svcMsgCnt , MGMT_MSG_RECORD* mgmtmsg);
, uint8_t* svcBuffer , uint32_t svcMsgCnt , L2_MGMT_MSG_RECORD* mgmtmsg);
int MPC_SendMsg(MPC_INST* instPtr, MPC_MSG_TYPE type, uint8_t* buffer, uint32_t dlen);
#endif //_MPC_PCIE
datalink814_ge/unit_test/linklayer_emulate_unit_test.c
+13 -13
View File
@@ -170,7 +170,7 @@ uint8_t svcTemplate[INTRA_SVC_FRAME_LENGTH_MAX] __attribute__ ((aligned (8))) =
L2_CONFIG l2Config = {
.myType = HEAD_NODE,
.myType = L2_NODE_HEAD,
.isInterHead = false,
.myId = 1,
.clustId = 1,
@@ -264,7 +264,7 @@ void forge_w2acq_frame(uint8_t* buff, L2_NODE_TYPE nodeType, uint16_t srcId, uin
uint64_t dataChunk;
/* message type */
dataChunk = (nodeType == HEAD_NODE) ? 0 : 1;
dataChunk = (nodeType == L2_NODE_HEAD) ? 0 : 1;
FrameInsertChunk(&bitarr, NS_MSG_INI_TYPE_OFFSET, NS_MSG_INI_TYPE_LEN, dataChunk);
/* source node id */
@@ -276,13 +276,13 @@ void forge_w2acq_frame(uint8_t* buff, L2_NODE_TYPE nodeType, uint16_t srcId, uin
FrameInsertChunk(&bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
/* current net stage */
switch (state) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
default:
@@ -310,19 +310,19 @@ void forge_mgmt_frame(uint8_t* buff, L2_NODE_STATE state) {
uint64_t dataChunk;
switch (state) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = NET_INTRA_SEEK_STAGE;
break;
case INTER_SEEK_STATE:
case L2_INTER_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_SEEK_STAGE;
break;
default:
@@ -353,21 +353,21 @@ TEST(linklayer_master_routine) {
if (L2_GetLastTor(linkInstPtr) == L2_TOR_RX && rand() < (RAND_MAX*0.8))
{
if(L2_GetLastFrameType(linkInstPtr) == L2_INTRA_W2_ACQ_FRAME) {
forge_w2acq_frame((uint8_t*)phyInstPtr->recvDataAddr, MEMBER_NODE, 2, 1, 1, -1, INIT_STATE);
forge_w2acq_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NODE_MEMBER, 2, 1, 1, -1, L2_INIT_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_W2ACQ_FRAME_LENGTH_MAX);
}
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_MGMT_FRAME)
{
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, NORMAL_STATE);
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NORMAL_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_MGMT_FRAME_LENGTH_MAX);
}
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_SVC_FRAME)
{
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, NORMAL_STATE);
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NORMAL_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_MGMT_FRAME_LENGTH_MAX);
}