cloudFPGA (cF) API  1.0
The documentation of the source code of cloudFPGA (cF)
udp_app_flash.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2016 -- 2021 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 
47 #include "udp_app_flash.hpp"
48 
49 using namespace hls;
50 using namespace std;
51 
52 
56 #ifndef __SYNTHESIS__
57  extern bool gTraceEvent;
58 #endif
59 
60 #define THIS_NAME "UAF" // UdpApplicationFlash
61 
62 #define TRACE_OFF 0x0000
63 #define TRACE_ESF 1 << 1
64 #define TRACE_RXP 1 << 2
65 #define TRACE_TXP 1 << 3
66 #define TRACE_ALL 0xFFFF
67 #define DEBUG_LEVEL (TRACE_OFF)
68 
69 
70 
87 void pUdpEchoStoreAndForward(
88  CmdBit *piSHL_Enable,
89  stream<UdpAppData> &siRXp_Data,
90  stream<UdpAppMeta> &siRXp_Meta,
91  stream<UdpAppDLen> &siRXp_DLen,
92  stream<UdpAppData> &soTXp_Data,
93  stream<UdpAppMeta> &soTXp_Meta,
94  stream<UdpAppDLen> &soTXp_DLen)
95 {
96  //-- DIRECTIVES FOR THIS PROCESS ------------------------------------------
97  #pragma HLS INLINE off
98  #pragma HLS PIPELINE II=1 enable_flush
99 
100  const char *myName = concat3(THIS_NAME, "/", "ESf");
101 
102  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
103  static enum FsmStates { ESF_META=0, ESF_STREAM } \
104  esf_fsmState = ESF_META;
105  #pragma HLS reset variable=esf_fsmState
106  static UdpAppDLen esf_byteCnt;
107  #pragma HLS reset variable=esf_byteCnt
108 
109  if (*piSHL_Enable != 1) {
110  return;
111  }
112 
113  //=====================================================
114  //== PROCESS DATA FORWARDING
115  //=====================================================
116  if ( !siRXp_Data.empty() and !soTXp_Data.full() ) {
117  UdpAppData appData = siRXp_Data.read();
118  soTXp_Data.write(appData);
119  esf_byteCnt += appData.getLen();
120  if (appData.getTLast()) {
121  esf_byteCnt = 0;
122  }
123  }
124 
125  //=====================================================
126  //== PROCESS META FORWARDING
127  //=====================================================
128  if ( !siRXp_Meta.empty() and !soTXp_Meta.full() and
129  !siRXp_DLen.empty() and !soTXp_DLen.full() ) {
130  UdpAppMeta appMeta = siRXp_Meta.read();
131  UdpAppDLen appDLen = siRXp_DLen.read();
132  soTXp_Meta.write(appMeta);
133  soTXp_DLen.write(appDLen);
134  }
135 } // End-of: pEchoStoreAndForward()
136 
137 
168 void pUdpTxPath(
169  CmdBit *piSHL_Mmio_Enable,
170  //[NOT_USED} ap_uint<2> piSHL_Mmio_EchoCtrl,
171  stream<UdpAppData> &siEPt_Data,
172  stream<UdpAppMeta> &siEPt_Meta,
173  stream<UdpAppDLen> &siEPt_DLen,
174  stream<UdpAppData> &siESf_Data,
175  stream<UdpAppMeta> &siESf_Meta,
176  stream<UdpAppDLen> &siESf_DLen,
177  stream<UdpAppData> &soUSIF_Data,
178  stream<UdpAppMeta> &soUSIF_Meta,
179  stream<UdpAppDLen> &soUSIF_DLen)
180 {
181  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
182  #pragma HLS INLINE off
183  #pragma HLS PIPELINE II=1 enable_flush
184 
185  const char *myName = concat3(THIS_NAME, "/", "TXp");
186 
187  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
188  static enum FsmStates { TXP_IDLE=0, TXP_META,
189  TXP_DATA_EPT, TXP_DATA_ESF, TXP_DRAIN_INPUT_FIFOS } \
190  txp_fsmState = TXP_IDLE;
191  #pragma HLS reset variable=txp_fsmState
192  static enum DgmMode { STRM_MODE=0, DGRM_MODE } \
193  txp_fwdMode = DGRM_MODE;
194  #pragma HLS reset variable=txp_fwdMode
195 
196  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
197  static ap_int<17> txp_lenCnt;
198  static UdpAppMeta txp_appMeta;
199  static UdpAppDLen txp_appDLen;
200  static enum EchoMode { EPT_MODE=0, ESF_MODE } \
201  txp_echoMode = EPT_MODE;
202 
203  //-- DYNAMIC VARIABLES -----------------------------------------------------
204  UdpAppData appData;
205 
206  switch (txp_fsmState) {
207  case TXP_IDLE:
208  if (*piSHL_Mmio_Enable == CMD_DISABLE) {
209  txp_fsmState = TXP_DRAIN_INPUT_FIFOS;
210  }
211  else if (!siEPt_Meta.empty() and !siEPt_DLen.empty()) {
212  txp_appMeta = siEPt_Meta.read();
213  txp_appDLen = siEPt_DLen.read();
214  txp_echoMode = EPT_MODE;
215  txp_fsmState = TXP_META;
216  }
217  else if (!siESf_Meta.empty() and !siESf_DLen.empty()) {
218  txp_appMeta = siESf_Meta.read();
219  txp_appDLen = siESf_DLen.read();
220  txp_echoMode = ESF_MODE;
221  txp_fsmState = TXP_META;
222  }
223  if (txp_appDLen == 0) {
224  txp_fwdMode = STRM_MODE;
225  txp_lenCnt = 0;
226  }
227  else {
228  txp_fwdMode = DGRM_MODE;
229  txp_lenCnt = txp_appDLen;
230  }
231  break;
232  case TXP_META:
233  if (!soUSIF_Meta.full() and !soUSIF_DLen.full()) {
234  // Swap IP_SA/IP_DA as well as UPD_SP/UDP_DP
235  UdpAppMeta udpMeta(txp_appMeta.ip4DstAddr, txp_appMeta.udpDstPort,
236  txp_appMeta.ip4SrcAddr, txp_appMeta.udpSrcPort);
237  soUSIF_Meta.write(udpMeta);
238  soUSIF_DLen.write(txp_appDLen);
239  if (txp_echoMode == EPT_MODE) {
240  txp_fsmState = TXP_DATA_EPT;
241  }
242  else {
243  txp_fsmState = TXP_DATA_ESF;
244  }
245  }
246  break;
247  case TXP_DATA_EPT:
248  if (!siEPt_Data.empty() and !soUSIF_Data.full()) {
249  appData = siEPt_Data.read();
250  if (txp_fwdMode == STRM_MODE) {
251  txp_lenCnt = txp_lenCnt + appData.getLen(); // Just for tracing
252  if (appData.getTLast()) {
253  txp_fsmState = TXP_IDLE;
254  if (DEBUG_LEVEL & TRACE_TXP) {
255  printInfo(myName, "ECHO_PATH_THRU + STREAM MODE - Finished forwarding %d bytes.\n", txp_lenCnt.to_uint());
256  }
257  }
258  }
259  else {
260  txp_lenCnt = txp_lenCnt - appData.getLen();
261  if ((txp_lenCnt <= 0) or (appData.getTLast())) {
262  txp_fsmState = TXP_IDLE;
263  if (DEBUG_LEVEL & TRACE_TXP) {
264  printInfo(myName, "ECHO_PATH_THRU + DATAGRAM MODE - Finished datagram forwarding.\n");
265  }
266  }
267  else {
268  appData.setTLast(0);
269  }
270  }
271  soUSIF_Data.write(appData);
272  }
273  break;
274  case TXP_DATA_ESF:
275  if (!siESf_Data.empty() and !soUSIF_Data.full()) {
276  appData = siESf_Data.read();
277  if (txp_fwdMode == STRM_MODE) {
278  txp_lenCnt = txp_lenCnt + appData.getLen(); // Just for tracing
279  if (appData.getTLast()) {
280  txp_fsmState = TXP_IDLE;
281  if (DEBUG_LEVEL & TRACE_TXP) {
282  printInfo(myName, "ECHO_STORE_FWD + STREAM MODE - Finished forwarding %d bytes.\n", txp_lenCnt.to_uint());
283  }
284  }
285  }
286  else {
287  txp_lenCnt = txp_lenCnt - appData.getLen();
288  if ((txp_lenCnt <= 0) or (appData.getTLast())) {
289  txp_fsmState = TXP_IDLE;
290  if (DEBUG_LEVEL & TRACE_TXP) {
291  printInfo(myName, "ECHO_STORE_FWD + DATAGRAM MODE - Finished datagram forwarding.\n");
292  }
293  }
294  else {
295  appData.setTLast(0);
296  }
297  }
298  soUSIF_Data.write(appData);
299  }
300  break;
301  case TXP_DRAIN_INPUT_FIFOS:
302  // Drain all the incoming FIFOs as long as MMIO control signal is disabled
303  if(!siEPt_Data.empty()) {
304  siEPt_Data.read();
305  }
306  else if(!siEPt_Meta.empty()) {
307  siEPt_Meta.read();
308  }
309  else if(!siEPt_DLen.empty()) {
310  siEPt_Meta.read();
311  }
312  else if(!siESf_Data.empty()) {
313  siEPt_Data.read();
314  }
315  else if(!siESf_Meta.empty()) {
316  siEPt_Meta.read();
317  }
318  else if(!siESf_DLen.empty()) {
319  siEPt_Meta.read();
320  }
321  else {
322  txp_fsmState = TXP_IDLE;
323  }
324  break;
325  } // End-of: switch (txp_fsmState) {
326 
327 } // End-of: pTxPath()
328 
329 
351 void pUdpRxPath(
352  CmdBit *piSHL_Mmio_Enable,
353  //[NOT_USED] ap_uint<2> piSHL_Mmio_EchoCtrl,
354  stream<UdpAppData> &siUSIF_Data,
355  stream<UdpAppMeta> &siUSIF_Meta,
356  stream<UdpAppDLen> &siUSIF_DLen,
357  stream<UdpAppData> &soEPt_Data,
358  stream<UdpAppMeta> &soEPt_Meta,
359  stream<UdpAppDLen> &soEPt_DLen,
360  stream<UdpAppData> &soESf_Data,
361  stream<UdpAppMeta> &soESf_Meta,
362  stream<UdpAppDLen> &soESf_DLen)
363 {
364  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
365  #pragma HLS INLINE off
366  #pragma HLS PIPELINE II=1 enable_flush
367 
368  const char *myName = concat3(THIS_NAME, "/", "RXp");
369 
370  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
371  static enum FsmStates { RXP_IDLE=0, RXP_META_EPT, RXP_META_ESF,
372  RXP_DATA_EPT, RXP_DATA_ESF,
373  RXP_DLEN_EPT, RXP_DLEN_ESF,
374  RXP_DRAIN_INPUT_FIFOS } \
375  rxp_fsmState = RXP_IDLE;
376  #pragma HLS reset variable=rxp_fsmState
377 
378  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
379  static UdpAppMeta rxp_appMeta;
380  static UdpAppDLen rxp_appDLen;
381  static UdpAppDLen rxp_byteCnt;
382 
383  //-- DYNAMIC VARIABLES -----------------------------------------------------
384  UdpAppData appData;
385 
386  switch (rxp_fsmState) {
387  case RXP_IDLE:
388  if (*piSHL_Mmio_Enable == CMD_DISABLE) {
389  rxp_fsmState = RXP_DRAIN_INPUT_FIFOS;
390  }
391  else if (!siUSIF_Meta.empty() and !siUSIF_DLen.empty()) {
392  siUSIF_Meta.read(rxp_appMeta);
393  siUSIF_DLen.read(rxp_appDLen);
394  rxp_byteCnt = 0;
395  switch (rxp_appMeta.udpDstPort) {
396  case ECHO_PATH_THRU_PORT:
397  // (DstPort == 8803) Echo this traffic in path-through mode
398  if (DEBUG_LEVEL & TRACE_RXP) { printInfo(myName, "Entering Rx path-through mode (DstPort=%4.4d)\n", rxp_appMeta.udpDstPort.to_uint()); }
399  rxp_fsmState = RXP_META_EPT;
400  break;
401  default:
402  // (DstPort != 8803) Echo this traffic in store-and-forward mode
403  if (DEBUG_LEVEL & TRACE_RXP) { printInfo(myName, "Entering Rx store-and-forward mode (DstPort=%4.4d)\n", rxp_appMeta.udpDstPort.to_uint()); }
404  rxp_fsmState = RXP_META_ESF;
405  break;
406  }
407  }
408  break;
409  case RXP_DRAIN_INPUT_FIFOS:
410  // Drain all the incoming FIFOs as long as MMIO control signal is disabled
411  if(!siUSIF_Data.empty()) {
412  siUSIF_Data.read();
413  }
414  else if(!siUSIF_Meta.empty()) {
415  siUSIF_Meta.read();
416  }
417  else if(!siUSIF_DLen.empty()) {
418  siUSIF_DLen.read();
419  }
420  else {
421  rxp_fsmState = RXP_IDLE;
422  }
423  break;
424  case RXP_META_EPT:
425  if (!soEPt_Meta.full()) {
426  //-- Forward incoming metadata to pEchoPathThrough
427  soEPt_Meta.write(rxp_appMeta);
428  rxp_fsmState = RXP_DATA_EPT;
429  }
430  break;
431  case RXP_META_ESF:
432  if (!soESf_Meta.full()) {
433  //-- Forward incoming metadata to pEchoStoreAndForward
434  soESf_Meta.write(rxp_appMeta);
435  rxp_fsmState = RXP_DATA_ESF;
436  }
437  break;
438  case RXP_DATA_EPT:
439  if (!siUSIF_Data.empty() and !soEPt_Data.full()) {
440  //-- Read incoming data and forward to pEchoPathThrough
441  siUSIF_Data.read(appData);
442  soEPt_Data.write(appData);
443  rxp_byteCnt = rxp_byteCnt + appData.getLen();
444  if (appData.getTLast()) {
445  rxp_fsmState = RXP_DLEN_EPT;
446  }
447  }
448  break;
449  case RXP_DATA_ESF:
450  if (!siUSIF_Data.empty() and !soESf_Data.full()) {
451  //-- Read incoming data and forward to pEchoStoreAndForward
452  siUSIF_Data.read(appData);
453  soESf_Data.write(appData);
454  rxp_byteCnt = rxp_byteCnt + appData.getLen();
455  if (appData.getTLast()) {
456  rxp_fsmState = RXP_DLEN_ESF;
457  }
458  }
459  break;
460  case RXP_DLEN_EPT:
461  if (!soEPt_DLen.full()) {
462  //-- Forward the computed data length to pEchoPathThrough
463  if (rxp_byteCnt != rxp_appDLen) {
464  printFatal(myName, "Received number of bytes (%d) differs from the advertised data length (%d)\n", rxp_byteCnt.to_uint(), rxp_appDLen.to_uint());
465  }
466  soEPt_DLen.write(rxp_byteCnt);
467  rxp_fsmState = RXP_IDLE;
468  }
469  break;
470  case RXP_DLEN_ESF:
471  if (!soESf_DLen.full()) {
472  //-- Forward the computed data length to pEchoPathThrough
473  if (rxp_byteCnt != rxp_appDLen) {
474  printFatal(myName, "Received number of bytes (%d) differs from the advertised data length (%d)\n", rxp_byteCnt.to_uint(), rxp_appDLen.to_uint());
475  }
476  soESf_DLen.write(rxp_byteCnt);
477  rxp_fsmState = RXP_IDLE;
478  }
479  break;
480  } // End-of: switch (rxp_fsmState) {
481 
482 } // End-of: pRxPath()
483 
484 
506 void udp_app_flash(
507 
508  //------------------------------------------------------
509  //-- SHELL / Mmio Interfaces
510  //------------------------------------------------------
511  CmdBit *piSHL_Mmio_En,
512  //[NOT_USED] ap_uint<2> piSHL_Mmio_EchoCtrl,
513  //[NOT_USED] ap_uint<1> piSHL_Mmio_PostPktEn,
514  //[NOT_USED] ap_uint<1> piSHL_Mmio_CaptPktEn,
515 
516  //------------------------------------------------------
517  //-- USIF / Rx Data Interfaces
518  //------------------------------------------------------
519  stream<UdpAppData> &siUSIF_Data,
520  stream<UdpAppMeta> &siUSIF_Meta,
521  stream<UdpAppDLen> &siUSIF_DLen,
522 
523  //------------------------------------------------------
524  //-- USIF / Tx Data Interfaces
525  //------------------------------------------------------
526  stream<UdpAppData> &soUSIF_Data,
527  stream<UdpAppMeta> &soUSIF_Meta,
528  stream<UdpAppDLen> &soUSIF_DLen)
529 {
530  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
531  #pragma HLS DATAFLOW
532  #pragma HLS INLINE off
533 
534  //--------------------------------------------------------------------------
535  //-- LOCAL STREAMS (Sorted by the name of the modules which generate them)
536  //--------------------------------------------------------------------------
537 
538  //-- Rx Path (RXp) ---------------------------------------------------------
539  static stream<UdpAppData> ssRXpToTXp_Data ("ssRXpToTXp_Data");
540  #pragma HLS STREAM variable=ssRXpToTXp_Data depth=2048
541  static stream<UdpAppMeta> ssRXpToTXp_Meta ("ssRXpToTXp_Meta");
542  #pragma HLS STREAM variable=ssRXpToTXp_Meta depth=64
543  static stream<UdpAppDLen> ssRXpToTXp_DLen ("ssRXpToTXp_DLen");
544  #pragma HLS STREAM variable=ssRXpToTXp_DLen depth=64
545 
546  static stream<UdpAppData> ssRXpToESf_Data ("ssRXpToESf_Data");
547  #pragma HLS STREAM variable=ssRXpToESf_Data depth=1024
548  static stream<UdpAppMeta> ssRXpToESf_Meta ("ssRXpToESf_Meta");
549  #pragma HLS STREAM variable=ssRXpToESf_Meta depth=32
550  static stream<UdpAppDLen> ssRXpToESf_DLen ("ssRXpToESf_DLen");
551  #pragma HLS STREAM variable=ssRXpToESf_DLen depth=32
552 
553  //-- Echo Store and Forward (ESf) ------------------------------------------
554  static stream<UdpAppData> ssESfToTXp_Data ("ssESfToTXp_Data");
555  #pragma HLS STREAM variable=ssESfToTXp_Data depth=1024
556  static stream<UdpAppMeta> ssESfToTXp_Meta ("ssESfToTXp_Meta");
557  #pragma HLS STREAM variable=ssESfToTXp_Meta depth=32
558  static stream<UdpAppDLen> ssESfToTXp_DLen ("ssESfToTXp_DLen");
559  #pragma HLS STREAM variable=ssESfToTXp_DLen depth=32
560 
561  //-- PROCESS FUNCTIONS ----------------------------------------------------
562  //
563  //
564  // +----------+
565  // +-------->| pESf |----------+
566  // | +----------+ |
567  // | --------+ |
568  // | +--------> sEPt |---------+ |
569  // | | --------+ | |
570  // +--+--+--+--+ +--+--+--+--+
571  // | pRXp | | pTXp |
572  // +------+----+ +-----+-----+
573  // /|\ |
574  // | |
575  // | |
576  // | \|/
577  //
578  //-------------------------------------------------------------------------
579  pUdpRxPath(
580  piSHL_Mmio_En,
581  //[NOT_USED] piSHL_Mmio_EchoCtrl,
582  siUSIF_Data,
583  siUSIF_Meta,
584  siUSIF_DLen,
585  ssRXpToTXp_Data,
586  ssRXpToTXp_Meta,
587  ssRXpToTXp_DLen,
588  ssRXpToESf_Data,
589  ssRXpToESf_Meta,
590  ssRXpToESf_DLen);
591 
592  pUdpEchoStoreAndForward(
593  piSHL_Mmio_En,
594  ssRXpToESf_Data,
595  ssRXpToESf_Meta,
596  ssRXpToESf_DLen,
597  ssESfToTXp_Data,
598  ssESfToTXp_Meta,
599  ssESfToTXp_DLen);
600 
601  pUdpTxPath(
602  piSHL_Mmio_En,
603  //[NOT_USED] piSHL_Mmio_EchoCtrl,
604  ssRXpToTXp_Data,
605  ssRXpToTXp_Meta,
606  ssRXpToTXp_DLen,
607  ssESfToTXp_Data,
608  ssESfToTXp_Meta,
609  ssESfToTXp_DLen,
610  soUSIF_Data,
611  soUSIF_Meta,
612  soUSIF_DLen);
613 
614 }
615 
AxisRaw::setTLast
void setTLast(tLast last)
Definition: AxisRaw.hpp:246
AxisRaw::getTLast
tLast getTLast() const
Definition: AxisRaw.hpp:219
AxisRaw::getLen
int getLen() const
Definition: AxisRaw.hpp:411
UdpAppMeta::udpDstPort
Ly4Port udpDstPort
Definition: nts.hpp:229
UdpAppMeta::udpSrcPort
Ly4Port udpSrcPort
Definition: nts.hpp:227
UdpAppMeta::ip4SrcAddr
Ip4Addr ip4SrcAddr
Definition: nts.hpp:226
UdpAppMeta::ip4DstAddr
Ip4Addr ip4DstAddr
Definition: nts.hpp:228
UdpAppDLen
UdpLen UdpAppDLen
Definition: nal.hpp:255
CMD_DISABLE
#define CMD_DISABLE
Definition: nts_types.hpp:64
printInfo
#define printInfo(callerName, format,...)
A macro to print an information message.
Definition: nts_utils.hpp:169
CmdBit
ap_uint< 1 > CmdBit
Definition: nts_types.hpp:108
concat3
#define concat3(firstCharConst, secondCharConst, thirdCharConst)
Definition: nts_utils.hpp:161
printFatal
#define printFatal(callerName, format,...)
A macro to print a fatal error message and exit.
Definition: nts_utils.hpp:208
ECHO_PATH_THRU_PORT
#define ECHO_PATH_THRU_PORT
Definition: tcp_app_flash.hpp:73
TRACE_RXP
#define TRACE_RXP
Definition: udp_app_flash.cpp:64
pUdpTxPath
void pUdpTxPath(CmdBit *piSHL_Mmio_Enable, stream< UdpAppData > &siEPt_Data, stream< UdpAppMeta > &siEPt_Meta, stream< UdpAppDLen > &siEPt_DLen, stream< UdpAppData > &siESf_Data, stream< UdpAppMeta > &siESf_Meta, stream< UdpAppDLen > &siESf_DLen, stream< UdpAppData > &soUSIF_Data, stream< UdpAppMeta > &soUSIF_Meta, stream< UdpAppDLen > &soUSIF_DLen)
Transmit Path - From THIS to USIF.
Definition: udp_app_flash.cpp:168
TRACE_TXP
#define TRACE_TXP
Definition: udp_app_flash.cpp:65
gTraceEvent
bool gTraceEvent
Definition: tb_nal.cpp:151
THIS_NAME
#define THIS_NAME
Definition: udp_app_flash.cpp:60
pUdpRxPath
void pUdpRxPath(CmdBit *piSHL_Mmio_Enable, stream< UdpAppData > &siUSIF_Data, stream< UdpAppMeta > &siUSIF_Meta, stream< UdpAppDLen > &siUSIF_DLen, stream< UdpAppData > &soEPt_Data, stream< UdpAppMeta > &soEPt_Meta, stream< UdpAppDLen > &soEPt_DLen, stream< UdpAppData > &soESf_Data, stream< UdpAppMeta > &soESf_Meta, stream< UdpAppDLen > &soESf_DLen)
UDP Receive Path (RXp) - From SHELL->ROLE/USIF to THIS.
Definition: udp_app_flash.cpp:351
udp_app_flash
void udp_app_flash(CmdBit *piSHL_Mmio_En, stream< UdpAppData > &siUSIF_Data, stream< UdpAppMeta > &siUSIF_Meta, stream< UdpAppDLen > &siUSIF_DLen, stream< UdpAppData > &soUSIF_Data, stream< UdpAppMeta > &soUSIF_Meta, stream< UdpAppDLen > &soUSIF_DLen)
Main process of the UDP Application Flash (UAF)
Definition: udp_app_flash.cpp:506
DEBUG_LEVEL
#define DEBUG_LEVEL
Definition: udp_app_flash.cpp:67
pUdpEchoStoreAndForward
void pUdpEchoStoreAndForward(CmdBit *piSHL_Enable, stream< UdpAppData > &siRXp_Data, stream< UdpAppMeta > &siRXp_Meta, stream< UdpAppDLen > &siRXp_DLen, stream< UdpAppData > &soTXp_Data, stream< UdpAppMeta > &soTXp_Meta, stream< UdpAppDLen > &soTXp_DLen)
Echo loopback between the Rx and Tx ports of the UDP connection.
Definition: udp_app_flash.cpp:87
udp_app_flash.hpp
: UDP Application Flash (UAF)