cloudFPGA (cF) API  1.0
The documentation of the source code of cloudFPGA (cF)
iprx.cpp
Go to the documentation of this file.
1 
17 
43 
56 #include "iprx.hpp"
57 
58 using namespace hls;
59 
60 
64 #ifndef __SYNTHESIS__
65  extern bool gTraceEvent;
66 #endif
67 #define THIS_NAME "IPRX"
68 
69 #define TRACE_OFF 0x0000
70 #define TRACE_IBUF 1 << 1
71 #define TRACE_MPD 1 << 2
72 #define TRACE_ILC 1 << 3
73 #define TRACE_ICA 1 << 4
74 #define TRACE_ICC 1 << 5
75 #define TRACE_IID 1 << 6
76 #define TRACE_ICL 1 << 7
77 #define TRACE_IPR 1 << 8
78 #define TRACE_ALL 0xFFFF
79 
80 #define DEBUG_LEVEL (TRACE_OFF)
81 
82 
83 
94 void pInputBuffer(
95  stream<AxisEth> &siETH_Data,
96  stream<AxisEth> &soMPd_Data)
97 {
98  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
99  #pragma HLS INLINE off
100  #pragma HLS PIPELINE II=1 enable_flush
101 
102  const char *myName = concat3(THIS_NAME, "/", "IBuf");
103 
104  if (!siETH_Data.empty() && !soMPd_Data.full()) {
105  AxisEth axisEth;
106  siETH_Data.read(axisEth);
107  if (not axisEth.isValid()) {
108  if (DEBUG_LEVEL & TRACE_IBUF) {
109  printWarn(myName, "Received an AxisChunk with an unexpected \'tkeep\' or \'tlast\' value.\n");
110  printAxisRaw(myName, "Aborting the frame after: ", AxisRaw(axisEth.getLE_TData(), axisEth.getLE_TKeep(), axisEth.getLE_TLast()));
111  }
112  soMPd_Data.write(AxisEth(axisEth.getLE_TData(), 0x00, 1));
113  }
114  else {
115  soMPd_Data.write(axisEth);
116  }
117  }
118 }
119 
120 
133 void pMacProtocolDetector(
134  EthAddr piMMIO_MacAddr,
135  stream<AxisEth> &siIBuf_Data,
136  stream<AxisArp> &soARP_Data,
137  stream<AxisEth> &soILc_Data)
138 {
139  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
140  #pragma HLS INLINE off
141  #pragma HLS PIPELINE II=1 enable_flush
142 
143  const char *myName = concat3(THIS_NAME, "/", "MPd");
144 
145  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
146  static enum FsmStates { S0=0, S1 } mpd_fsmState=S0;
147  #pragma HLS RESET variable=mpd_fsmState
148  static ap_uint<2> mpd_chunkCount=0;
149  #pragma HLS RESET variable=mpd_chunkCount
150 
151  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
152  static EtherType mpd_etherType;
153  static AxisEth mpd_prevChunk;
154 
155  //-- DYNAMIC VARIABLES -----------------------------------------------------
156  AxisEth currChunk;
157 
158  switch (mpd_fsmState) {
159  case S0:
160  if (!siIBuf_Data.empty() && !soARP_Data.full() && !soILc_Data.full()) {
161  siIBuf_Data.read(currChunk);
162  switch (mpd_chunkCount) {
163  case 0:
164  // Compare MAC_DA with our MMIO_MacAddress and with BROADCAST
165  // [TODO - Is this really needed given ARP ?]
166  if (currChunk.getEthDstAddr() != piMMIO_MacAddr &&
167  currChunk.getEthDstAddr() != 0xFFFFFFFFFFFF) {
168  mpd_etherType = CMD_DROP;
169  printInfo(myName, "Requesting current frame with MAC destination address = 0x%16.16lX (0x%16.16lX) to be dropped\n",
170  currChunk.getEthDstAddr().to_long(), currChunk.getLE_EthDstAddr().to_long());
171  }
172  else {
173  mpd_etherType = CMD_KEEP;
174  }
175  mpd_chunkCount++;
176  break;
177  default:
178  if (mpd_chunkCount == 1) {
179  if (mpd_etherType != CMD_DROP) {
180  mpd_etherType = currChunk.getEtherType();
181  }
182  mpd_chunkCount++;
183  }
184  if (mpd_etherType == ETH_ETHERTYPE_ARP) {
185  soARP_Data.write(mpd_prevChunk);
186  }
187  else if (mpd_etherType == ETH_ETHERTYPE_IP4) {
188  soILc_Data.write(mpd_prevChunk);
189  }
190  break;
191  }
192  mpd_prevChunk = currChunk;
193  if (currChunk.getLE_TLast()) {
194  mpd_chunkCount = 0;
195  mpd_fsmState = S1;
196  }
197  }
198  break;
199  case S1:
200  if( !soARP_Data.full() && !soILc_Data.full()){
201  if (mpd_etherType == ETH_ETHERTYPE_ARP) {
202  soARP_Data.write(mpd_prevChunk);
203  }
204  else if (mpd_etherType == ETH_ETHERTYPE_IP4) {
205  soILc_Data.write(mpd_prevChunk);
206  }
207  mpd_fsmState = S0;
208  }
209  break;
210 
211  } // End of: switch
212 }
213 
214 
226 void pIpLengthChecker(
227  stream<AxisEth> &siMPd_Data,
228  stream<AxisEth> &soICa_Data)
229 {
230  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
231  #pragma HLS INLINE off
232  #pragma HLS PIPELINE II=1 enable_flush
233 
234  const char *myName = concat3(THIS_NAME, "/", "ILc");
235 
236  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
237  static ap_uint<2> ilc_leftToWrite=0;
238  #pragma HLS RESET variable=ilc_leftToWrite
239  static enum FsmStates {FSM_IDLE=0, FSM_SIZECHECK, FSM_STREAM} ilc_fsmState=FSM_IDLE;
240  #pragma HLS RESET variable=ilc_fsmState
241  static ap_uint<2> ilc_chunkCount=0;
242  #pragma HLS RESET variable=ilc_chunkCount
243  static ap_uint<1> ilc_filterPacket=0;
244  #pragma HLS RESET variable=ilc_filterPacket
245 
246  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
247  static ap_shift_reg<AxisEth, 2> chunkBuffer; // A shift reg. holding 2 AxisChunks
248 
249  //-- DYNAMIC VARIABLES -----------------------------------------------------
250  AxisEth tempChunk;
251  Ip4TotalLen ip4TotLen;
252 
253  if (ilc_leftToWrite == 0) {
254  if (!siMPd_Data.empty() && !soICa_Data.full()) {
255  AxisEth currChunk = siMPd_Data.read();
256  switch (ilc_fsmState) {
257  case FSM_IDLE:
258  // Read head of shift reg, shift up one, and load current chunk into location 0
259  chunkBuffer.shift(currChunk);
260  if (ilc_chunkCount == 1) {
261  ilc_fsmState = FSM_SIZECHECK;
262  }
263  ilc_chunkCount++;
264  break;
265  case FSM_SIZECHECK:
266  // Check the IPv4/TotalLength field ([FIXME - Consider removing.])
267  ip4TotLen = currChunk.getIp4TotalLen();
268  if (ip4TotLen > MaxDatagramSize) {
269  ilc_filterPacket = 1;
270  printWarn(myName, "Current frame will be discarded because frame is too long!\n");
271  }
272  else {
273  ilc_filterPacket = 0;
274  if (DEBUG_LEVEL & TRACE_ILC) {
275  printInfo(myName, "Start of IPv4 packet - Total length = %d bytes.\n", ip4TotLen.to_int());
276  }
277  }
278  // Read head of shift reg, shift up one, and load current chunk into location 0
279  tempChunk = chunkBuffer.shift(currChunk);
280  if (ilc_filterPacket == 0) {
281  soICa_Data.write(tempChunk);
282  }
283  ilc_fsmState = FSM_STREAM;
284  break;
285  case FSM_STREAM:
286  tempChunk = chunkBuffer.shift(currChunk);
287  if (ilc_filterPacket == 0) {
288  soICa_Data.write(tempChunk);
289  }
290  break;
291  } // End of: switch
292 
293  if (currChunk.getLE_TLast()) {
294  ilc_chunkCount = 0;
295  ilc_leftToWrite = 2;
296  ilc_fsmState = FSM_IDLE;
297  }
298  }
299  }
300  else if (ilc_leftToWrite != 0 && !soICa_Data.full() ) {
301  tempChunk = chunkBuffer.shift(AxisEth(0, 0, 0));
302  if (ilc_filterPacket == 0) {
303  soICa_Data.write(tempChunk);
304  }
305  ilc_leftToWrite--;
306  }
307 }
308 
309 
323 void pIpChecksumAccumulator(
324  Ip4Addr piMMIO_Ip4Address,
325  stream<AxisEth> &siILc_Data,
326  stream<AxisIp4> &soIId_Data,
327  stream<Ip4Version> &soIId_IpVer,
328  stream<CmdBit> &soIId_DropCmd,
329  stream<SubSums> &soICc_SubSums)
330 {
331  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
332  #pragma HLS INLINE off
333  #pragma HLS PIPELINE II=1 enable_flush
334 
335  const char *myName = concat3(THIS_NAME, "/", "ICa");
336 
337  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
338  static bool ica_wasLastChunk=false;
339  #pragma HLS RESET variable=ica_wasLastChunk
340  static ap_uint<3> ica_chunkCount=0;
341  #pragma HLS RESET variable=ica_chunkCount
342 
343  //-- STATIC DATAFLOW VARIABLES --------------------------------------------
344  static ap_uint<17> ica_ipHdrSums[4];
345  static ap_uint<8> ica_ipHdrLen;
346  static LE_Ip4Addr ica_dstIpAddress;
347  static AxisEth ica_prevChunk;
348 
349  //-- DYNAMIC VARIABLES -----------------------------------------------------
350  AxisEth currChunk;
351  AxisIp4 sendChunk;
352  ap_uint<16> ip4FlagsAndFragOff;
353  bool ipAddrMatch;
354 
355  currChunk.setLE_TLast(0);
356  if (!siILc_Data.empty() && !ica_wasLastChunk && !soIId_IpVer.full() &&
357  !soIId_DropCmd.full() && !soICc_SubSums.full() && !soIId_Data.full()) {
358  siILc_Data.read(currChunk);
359 
360  switch (ica_chunkCount) {
361  case 0:
362  // Skip because chunk contains MAC_SA[1:0] | MAC_DA[5:0]
363  for (int i=0; i<4 ;++i) {
364  ica_ipHdrSums[i] = 0;
365  }
366  ica_chunkCount++;
367  break;
368  case 1:
369  // Retrieve the IP version field
370  soIId_IpVer.write(currChunk.getIp4Version());
371  // Retrieve the Internet Header Length
372  ica_ipHdrLen = currChunk.getIp4HdrLen();
373  // Retrieve the first two bytes of the IPv4 header
374  ica_ipHdrSums[3].range(15,12) = currChunk.getIp4Version();
375  ica_ipHdrSums[3].range(11, 8) = currChunk.getIp4HdrLen();
376  ica_ipHdrSums[3].range( 7, 0) = currChunk.getIp4ToS();
377  ica_chunkCount++;
378  break;
379  case 2:
380  // Check for fragmentation in this cycle. Need to check the MF flag.
381  // If set, then drop. If not set, then check the fragment offset and
382  // if it is non-zero then drop.
383  ip4FlagsAndFragOff = byteSwap16(currChunk.getLE_TData().range(47, 32));
384  if (ip4FlagsAndFragOff.range(12, 0) != 0 || ip4FlagsAndFragOff.bit(13) != 0) {
385  soIId_DropCmd.write(CMD_DROP);
386  if (ip4FlagsAndFragOff.bit(13) != 0) {
387  printWarn(myName, "The More Fragments (MF) is set but IP fragmentation is not supported (yet).\n");
388  }
389  if (ip4FlagsAndFragOff.range(12, 0) != 0) {
390  printWarn(myName, "Fragment offset is set but not supported (yet) !!!\n");
391  }
392  }
393  else {
394  soIId_DropCmd.write(CMD_KEEP);
395  }
396  for (int i = 0; i < 4; i++) {
397  #pragma HLS unroll
398  ica_ipHdrSums[i] += byteSwap16(currChunk.getLE_TData().range(i*16+15, i*16));
399  ica_ipHdrSums[i] = (ica_ipHdrSums[i] + (ica_ipHdrSums[i] >> 16)) & 0xFFFF;
400  }
401  ica_ipHdrLen -= 2;
402  ica_chunkCount++;
403  break;
404  case 3:
405  ica_dstIpAddress.range(31, 16) = currChunk.getIp4DstAddrHi();
406  for (int i = 0; i < 4; i++) {
407  #pragma HLS unroll
408  ica_ipHdrSums[i] += byteSwap16(currChunk.getLE_TData().range(i*16+15, i*16));
409  ica_ipHdrSums[i] = (ica_ipHdrSums[i] + (ica_ipHdrSums[i] >> 16)) & 0xFFFF;
410  }
411  ica_ipHdrLen -= 2;
412  ica_chunkCount++;
413  break;
414 
415  default:
416  if (ica_chunkCount == 4) {
417  ica_dstIpAddress(15, 0) = currChunk.getIp4DstAddrLo();
418  }
419  switch (ica_ipHdrLen) {
420  case 0:
421  break;
422  case 1:
423  // Sum up part0
424  ica_ipHdrSums[0] += currChunk.getIp4DstAddrLo();
425  ica_ipHdrSums[0] = (ica_ipHdrSums[0] + (ica_ipHdrSums[0] >> 16)) & 0xFFFF;
426  ica_ipHdrLen = 0;
427  // Assess destination IP address (FYI - IP Broadcast addresses are dropped)
428  if (ica_dstIpAddress == piMMIO_Ip4Address) {
429  ipAddrMatch = true;
430  }
431  else {
432  ipAddrMatch = false;
433  }
434  soICc_SubSums.write(SubSums(ica_ipHdrSums, ipAddrMatch));
435  break;
436  case 2:
437  // Sum up parts 0-2
438  for (int i = 0; i < 4; i++) {
439  #pragma HLS unroll
440  ica_ipHdrSums[i] += byteSwap16(currChunk.getLE_TData().range(i*16+15, i*16));
441  ica_ipHdrSums[i] = (ica_ipHdrSums[i] + (ica_ipHdrSums[i] >> 16)) & 0xFFFF;
442  }
443  ica_ipHdrLen = 0;
444  // Assess destination IP address (FYI - IP Broadcast addresses are dropped)
445  if (ica_dstIpAddress == piMMIO_Ip4Address) {
446  // || ica_dstIpAddress == 0xFFFFFFFF) {
447  ipAddrMatch = true;
448  }
449  else {
450  ipAddrMatch = false;
451  }
452  soICc_SubSums.write(SubSums(ica_ipHdrSums, ipAddrMatch));
453  break;
454  default:
455  // Sum up everything
456  for (int i = 0; i < 4; i++) {
457  #pragma HLS unroll
458  ica_ipHdrSums[i] += byteSwap16(currChunk.getLE_TData().range(i*16+15, i*16));
459  ica_ipHdrSums[i] = (ica_ipHdrSums[i] + (ica_ipHdrSums[i] >> 16)) & 0xFFFF;
460  }
461  ica_ipHdrLen -= 2;
462  break;
463  }
464  break;
465  } // End of: switch(ica_chunkCount)f
466 
467  if (ica_chunkCount > 2) {
468  // Send AxisIp4 chunks while re-aligning the outgoing chunks
469  sendChunk = AxisIp4((currChunk.getLE_TData().range(47, 0), ica_prevChunk.getLE_TData().range(63, 48)),
470  (currChunk.getLE_TKeep().range( 5, 0), ica_prevChunk.getLE_TKeep().range( 7, 6)),
471  (currChunk.getLE_TKeep()[6] == 0));
472  soIId_Data.write(sendChunk);
473  }
474  ica_prevChunk = currChunk;
475  if (currChunk.getLE_TLast()) {
476  ica_chunkCount = 0;
477  ica_wasLastChunk = !sendChunk.getLE_TLast();
478  }
479  }
480  else if(ica_wasLastChunk && !soIId_Data.full()) {
481  // Send remaining Chunk;
482  sendChunk = AxisIp4(ica_prevChunk.getLE_TData().range(63, 48),
483  ica_prevChunk.getLE_TKeep().range( 7, 6),
484  TLAST);
485  soIId_Data.write(sendChunk);
486  ica_wasLastChunk = false;
487  }
488 }
489 
490 
504 void pIpInvalidDropper(
505  stream<AxisIp4> &siICa_Data,
506  stream<Ip4Version> &siICa_IpVer,
507  stream<ValBit> &siICa_DropFrag,
508  stream<ValBit> &siICc_CsumValid,
509  stream<AxisIp4> &soICl_Data)
510 {
511  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
512  #pragma HLS INLINE off
513  #pragma HLS PIPELINE II=1 enable_flush
514 
515  const char *myName = concat3(THIS_NAME, "/", "IId");
516 
517  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
518  static enum FsmStates {FSM_IDLE=0, FSM_FWD, FSM_DROP} iid_fsmState=FSM_IDLE;
519  #pragma HLS RESET variable=iid_fsmState
520 
521  //-- DYNAMIC VARIABLES -----------------------------------------------------
522  AxisIp4 currChunk = AxisIp4(0, 0, 0);
523 
524  switch(iid_fsmState) {
525  case FSM_IDLE:
526  if (!siICc_CsumValid.empty() && !siICa_IpVer.empty() && !siICa_DropFrag.empty() &&
527  !siICa_Data.empty() && !soICl_Data.full()) {
528  siICa_Data.read(currChunk);
529  // Assess validity of the current IPv4 packet
530  ValBit csumValid = (siICc_CsumValid.read() == 1); // CSUM is valid
531  ValBit isIpv4Pkt = (siICa_IpVer.read() == 4); // IP Version is 4
532  ValBit doKeepPkt = (siICa_DropFrag.read() == CMD_KEEP); // Do not drop
533  ap_uint<2> valid = (csumValid + isIpv4Pkt + doKeepPkt);
534  if (valid != 3) {
535  iid_fsmState = FSM_DROP;
536  printWarn(myName, "The current IP packet will be dropped because:\n");
537  printWarn(myName, " csumValid=%d | isIpv4Pkt=%d | doKeepPkt=%d\n",
538  csumValid.to_int(), isIpv4Pkt.to_int(), doKeepPkt.to_int());
539  }
540  else {
541  soICl_Data.write(currChunk);
542  iid_fsmState = FSM_FWD;
543  }
544  }
545  break;
546  case FSM_FWD:
547  if(!siICa_Data.empty() && !soICl_Data.full()) {
548  siICa_Data.read(currChunk);
549  soICl_Data.write(currChunk);
550  if (currChunk.getLE_TLast()) {
551  iid_fsmState = FSM_IDLE;
552  }
553  }
554  break;
555  case FSM_DROP:
556  if(!siICa_Data.empty()){
557  siICa_Data.read(currChunk);
558  if (currChunk.getLE_TLast()) {
559  iid_fsmState = FSM_IDLE;
560  }
561  }
562  break;
563  }
564 }
565 
566 
576 void pIpCutLength(
577  stream<AxisIp4> &siIId_Data,
578  stream<AxisIp4> &soIPr_Data)
579 {
580  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
581  #pragma HLS INLINE off
582  #pragma HLS PIPELINE II=1 enable_flush
583 
584  const char *myName = concat3(THIS_NAME, "/", "ICl");
585 
586  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
587  static enum FsmStates {FSM_FWD=0, FSM_DROP} icl_fsmState=FSM_FWD;
588  #pragma HLS RESET variable=icl_fsmState
589  static ap_uint<13> icl_chunkCount=0; // Ip4TotalLen/8
590  #pragma HLS RESET variable=icl_chunkCount
591 
592  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
593  static Ip4TotalLen icl_ip4TotalLength;
594 
595  switch(icl_fsmState){
596  case FSM_FWD:
597  if (!siIId_Data.empty() && !soIPr_Data.full()) {
598  AxisIp4 currChunk = siIId_Data.read();
599  switch (icl_chunkCount) {
600  case 0:
601  icl_ip4TotalLength = currChunk.getIp4TotalLen();
602  break;
603  default:
604  if (((icl_chunkCount+1)*8) >= icl_ip4TotalLength) {
605  if (currChunk.getLE_TLast() == 0) {
606  icl_fsmState = FSM_DROP;
607  }
608  currChunk.setLE_TLast(TLAST);
609  ap_uint<4> leftLength = icl_ip4TotalLength - (icl_chunkCount*8);
610  currChunk.setLE_TKeep(lenToLE_tKeep(leftLength));
611  }
612  break;
613  } // End of: switch(icl_chunkCount)
614  soIPr_Data.write(currChunk);
615  icl_chunkCount++;
616  if (currChunk.getLE_TLast()) {
617  icl_chunkCount = 0;
618  }
619  }
620  break;
621  case FSM_DROP:
622  if (!siIId_Data.empty()) {
623  AxisIp4 currChunk = siIId_Data.read();
624  if (currChunk.getLE_TLast()) {
625  icl_fsmState = FSM_FWD;
626  }
627  }
628  break;
629 
630  } // End of: switch(icl_fsmState)
631 }
632 
633 
643 void pIpChecksumChecker(
644  stream<SubSums> &siICa_SubSums,
645  stream<ValBit> &soIId_CsumValid)
646 {
647  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
648  #pragma HlS INLINE off
649  #pragma HLS PIPELINE II=1 enable_flush
650 
651  const char *myName = concat3(THIS_NAME, "/", "ICc");
652 
653  if (!siICa_SubSums.empty() && !soIId_CsumValid.full()) {
654  SubSums ipHdrSums = siICa_SubSums.read();
655 
656  ipHdrSums.sum0 += ipHdrSums.sum2;
657  ipHdrSums.sum1 += ipHdrSums.sum3;
658  ipHdrSums.sum0 = (ipHdrSums.sum0 + (ipHdrSums.sum0 >> 16)) & 0xFFFF;
659  ipHdrSums.sum1 = (ipHdrSums.sum1 + (ipHdrSums.sum1 >> 16)) & 0xFFFF;
660  ipHdrSums.sum0 += ipHdrSums.sum1;
661  ipHdrSums.sum0 = (ipHdrSums.sum0 + (ipHdrSums.sum0 >> 16)) & 0xFFFF;
662  ipHdrSums.sum0 = ~ipHdrSums.sum0;
663  if (ipHdrSums.sum0(15, 0) != 0x0000) {
664  printError(myName, "Bad IP header checksum: Expected 0x0000 - Computed 0x%4.4X\n", ipHdrSums.sum0(15, 0).to_int());
665  }
666  soIId_CsumValid.write((ipHdrSums.sum0(15, 0) == 0x0000) && ipHdrSums.ipMatch);
667  }
668 }
669 
670 
689 void pIpPacketRouter(
690  stream<AxisIp4> &siICl_Data,
691  stream<AxisIp4> &soICMP_Data,
692  stream<AxisIp4> &soICMP_Derr,
693  stream<AxisIp4> &soUOE_Data,
694  stream<AxisIp4> &soTOE_Data)
695 {
696  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
697  #pragma HLS INLINE off
698  #pragma HLS PIPELINE II=1 enable_flush
699 
700  const char *myName = concat3(THIS_NAME, "/", "IPr");
701 
702  //-- STATIC CONTROL VARIABLES (with RESET) ---------------------------------
703  static enum FsmStates { FSM_IDLE=0, FSM_LAST} ipr_fsmState=FSM_IDLE;
704  #pragma HLS RESET variable=ipr_fsmState
705  static ap_uint<2> ipr_chunkCount=0;
706  #pragma HLS RESET variable=ipr_chunkCount
707  static bool ipr_leftToWrite=false;
708  #pragma HLS RESET variable=ipr_leftToWrite
709 
710  //-- STATIC DATAFLOW VARIABLES ---------------------------------------------
711  static StsBit ipr_ttlExpired;
712  static Ip4Prot ipr_ipProtocol;
713  static AxisIp4 ipr_prevChunk;
714 
715  //-- DYNAMIC VARIABLES -----------------------------------------------------
716  AxisIp4 currChunk;
717 
718  switch (ipr_fsmState) {
719  case FSM_IDLE:
720  if (!siICl_Data.empty() &&
721  !soICMP_Derr.full() && !soICMP_Data.full() &&
722  !soUOE_Data.full() && !soTOE_Data.full()) {
723  siICl_Data.read(currChunk);
724  switch (ipr_chunkCount) {
725  case 0:
726  ipr_chunkCount++;
727  break;
728  default:
729  if (ipr_chunkCount == 1) {
730  if (currChunk.getIp4TtL() == 1) {
731  ipr_ttlExpired = 1;
732  }
733  else {
734  ipr_ttlExpired = 0;
735  }
736  ipr_ipProtocol = currChunk.getIp4Prot();
737  ipr_chunkCount++;
738  }
739  if (ipr_ttlExpired == 1) {
740  // Forward the current IP packet to ICMP for building the error message
741  soICMP_Derr.write(ipr_prevChunk);
742  }
743  else {
744  switch (ipr_ipProtocol) {
745  // FYI - There is no default case. If the current packet
746  // does not match any case, it is automatically dropped.
747  case IP4_PROT_ICMP:
748  soICMP_Data.write(ipr_prevChunk);
749  break;
750  case IP4_PROT_UDP:
751  soUOE_Data.write(ipr_prevChunk);
752  break;
753  case IP4_PROT_TCP:
754  soTOE_Data.write(ipr_prevChunk);
755  break;
756  }
757  }
758  break;
759  }
760  ipr_prevChunk = currChunk;
761  if (currChunk.getLE_TLast()) {
762  ipr_chunkCount = 0;
763  ipr_leftToWrite = true;
764  ipr_fsmState = FSM_LAST;
765  }
766  }
767  break;
768  case FSM_LAST:
769  if (!soICMP_Derr.full() &&
770  !soICMP_Data.full() && !soUOE_Data.full() && !soTOE_Data.full() ) {
771  ap_uint<log2Ceil<8>::val> bitCounter = 0;
772  bitCounter = ipr_prevChunk.getLen();
773  if (ipr_prevChunk.getLE_TKeep() != 0xFF) {
774  ipr_prevChunk.setLE_TData(0, 63, 64-((8-bitCounter.to_int())*8));
775  }
776  if (ipr_ttlExpired == 1) {
777  soICMP_Derr.write(ipr_prevChunk);
778  }
779  else {
780  switch (ipr_ipProtocol) {
781  case IP4_PROT_ICMP:
782  soICMP_Data.write(ipr_prevChunk);
783  break;
784  case IP4_PROT_UDP:
785  soUOE_Data.write(ipr_prevChunk);
786  break;
787  case IP4_PROT_TCP:
788  soTOE_Data.write(ipr_prevChunk);
789  break;
790  }
791  }
792  ipr_leftToWrite = false;
793  ipr_fsmState = FSM_IDLE;
794  }
795  break;
796  }
797 }
798 
799 
800 
826 void iprx(
827  //------------------------------------------------------
828  //-- MMIO Interfaces
829  //------------------------------------------------------
830  EthAddr piMMIO_MacAddress,
831  Ip4Addr piMMIO_Ip4Address,
832  //------------------------------------------------------
833  //-- ETHernet MAC Layer Interface
834  //------------------------------------------------------
835  stream<AxisEth> &siETH_Data,
836  //------------------------------------------------------
837  //-- ARP Interface
838  //------------------------------------------------------
839  stream<AxisArp> &soARP_Data,
840  //------------------------------------------------------
841  //-- ICMP Interfaces
842  //------------------------------------------------------
843  stream<AxisIp4> &soICMP_Data,
844  stream<AxisIp4> &soICMP_Derr,
845  //------------------------------------------------------
846  //-- UOE Interface
847  //------------------------------------------------------
848  stream<AxisIp4> &soUOE_Data,
849  //------------------------------------------------------
850  //-- TOE Interface
851  //------------------------------------------------------
852  stream<AxisIp4> &soTOE_Data)
853 {
854  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
855  #pragma HLS DATAFLOW
856  #pragma HLS INLINE
857  #pragma HLS INTERFACE ap_ctrl_none port=return
858 
859  //--------------------------------------------------------------------------
860  //-- LOCAL STREAMS (Sorted by the name of the modules which generate them)
861  //--------------------------------------------------------------------------
862 
863  //-- Input Buffer (IBuf)
864  static stream<AxisEth> ssIBufToMPd_Data ("ssIBufToMPd_Data");
865  #pragma HLS STREAM variable=ssIBufToMPd_Data depth=8192
866 
867  //-- MAC Protocol Detector (MPd)
868  static stream<AxisEth> ssMPdToILc_Data ("ssMPdToILc_Data");
869  #pragma HLS STREAM variable=ssMPdToILc_Data depth=32
870 
871  //-- IPv4 Length Checker (ILc)
872  static stream<AxisEth> ssILcToICa_Data ("ssILcToICa_Data");
873  #pragma HLS STREAM variable=ssILcToICa_Data depth=32
874 
875  //-- IPv4 Checksum Accumulator (ICa)
876  static stream<AxisIp4> ssICaToIId_Data ("ssICaToIId_Data");
877  #pragma HLS STREAM variable=ssICaToIId_Data depth=1024 // Must hold IP header for checksum checking
878  static stream<Ip4Version> ssICaToIId_IpVer ("ssICaToIId_IpVer");
879  #pragma HLS STREAM variable=ssICaToIId_IpVer depth=32
880  static stream<CmdBit> ssICaToIId_DropFrag ("ssICaToIId_DropFrag");
881  #pragma HLS STREAM variable=ssICaToIId_DropFrag depth=32
882  static stream<SubSums> ssICaToICc_SubSums ("ssICaToICc_SubSums");
883  #pragma HLS DATA_PACK variable=ssICaToICc_SubSums
884  #pragma HLS STREAM variable=ssICaToICc_SubSums depth=32
885 
886  //-- IPv4 Invalid Dropper (IId)
887  static stream<AxisIp4> ssIIdToICl_Data ("ssIIdToICl_Data");
888  #pragma HLS DATA_PACK variable=ssIIdToICl_Data
889  #pragma HLS STREAM variable=ssIIdToICl_Data depth=32
890 
891  //-- IPv4 Cut Length (ICl)
892  static stream<AxisIp4> ssIClToIPr_Data ("ssIClToIPr_Data");
893  #pragma HLS DATA_PACK variable=ssIClToIPr_Data
894  #pragma HLS STREAM variable=ssIClToIPr_Data depth=32
895 
896  //-- IPv4 Checksum Checker
897  static stream<ValBit> ssICcToIId_CsumVal ("ssICcToIId_CsumVal");
898  #pragma HLS STREAM variable=ssICcToIId_CsumVal depth=32
899 
900  //-- PROCESS FUNCTIONS -----------------------------------------------------
901 
902  pInputBuffer(
903  siETH_Data,
904  ssIBufToMPd_Data);
905 
906  pMacProtocolDetector(
907  piMMIO_MacAddress,
908  ssIBufToMPd_Data,
909  soARP_Data,
910  ssMPdToILc_Data);
911 
912  pIpLengthChecker(
913  ssMPdToILc_Data,
914  ssILcToICa_Data);
915 
916  pIpChecksumAccumulator(
917  piMMIO_Ip4Address,
918  ssILcToICa_Data,
919  ssICaToIId_Data,
920  ssICaToIId_IpVer,
921  ssICaToIId_DropFrag,
922  ssICaToICc_SubSums);
923 
924  pIpChecksumChecker(
925  ssICaToICc_SubSums,
926  ssICcToIId_CsumVal);
927 
928  pIpInvalidDropper(
929  ssICaToIId_Data,
930  ssICaToIId_IpVer,
931  ssICaToIId_DropFrag,
932  ssICcToIId_CsumVal,
933  ssIIdToICl_Data);
934 
935  pIpCutLength(
936  ssIIdToICl_Data,
937  ssIClToIPr_Data);
938 
939  pIpPacketRouter(
940  ssIClToIPr_Data,
941  soICMP_Data,
942  soICMP_Derr,
943  soUOE_Data,
944  soTOE_Data);
945 
946 }
947 
948 
961 #if HLS_VERSION == 2017
962  void iprx_top(
963  //------------------------------------------------------
964  //-- MMIO Interfaces
965  //------------------------------------------------------
966  EthAddr piMMIO_MacAddress,
967  Ip4Addr piMMIO_Ip4Address,
968  //------------------------------------------------------
969  //-- ETHernet MAC Layer Interface
970  //------------------------------------------------------
971  stream<AxisEth> &siETH_Data,
972  //------------------------------------------------------
973  //-- ARP Interface
974  //------------------------------------------------------
975  stream<AxisArp> &soARP_Data,
976  //------------------------------------------------------
977  //-- ICMP Interfaces
978  //------------------------------------------------------
979  stream<AxisIp4> &soICMP_Data,
980  stream<AxisIp4> &soICMP_Derr,
981  //------------------------------------------------------
982  //-- UOE Interface
983  //------------------------------------------------------
984  stream<AxisIp4> &soUOE_Data,
985  //------------------------------------------------------
986  //-- TOE Interface
987  //------------------------------------------------------
988  stream<AxisIp4> &soTOE_Data)
989 {
990  //-- DIRECTIVES FOR THE INTERFACES -----------------------------------------
991  #pragma HLS INTERFACE ap_ctrl_none port=return
992 
993 
994 
995 
996 
997  #pragma HLS INTERFACE ap_stable register port=piMMIO_MacAddress
998  #pragma HLS INTERFACE ap_stable register port=piMMIO_Ip4Address
999 
1000  #pragma HLS RESOURCE core=AXI4Stream variable=siETH_Data metadata="-bus_bundle siETH_Data"
1001 
1002  #pragma HLS RESOURCE core=AXI4Stream variable=soARP_Data metadata="-bus_bundle soARP_Data"
1003 
1004  #pragma HLS RESOURCE core=AXI4Stream variable=soICMP_Data metadata="-bus_bundle soICMP_Data"
1005  #pragma HLS RESOURCE core=AXI4Stream variable=soICMP_Derr metadata="-bus_bundle soICMP_Derr"
1006 
1007  #pragma HLS RESOURCE core=AXI4Stream variable=soUOE_Data metadata="-bus_bundle soUOE_Data"
1008  #pragma HLS RESOURCE core=AXI4Stream variable=soTOE_Data metadata="-bus_bundle soTOE_Data"
1009 
1010  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
1011  #pragma HLS DATAFLOW
1012 
1013  //-- MAIN IPRX PROCESS -----------------------------------------------------
1014  iprx(
1015  //-- MMIO Interfaces
1016  piMMIO_MacAddress,
1017  piMMIO_Ip4Address,
1018  //-- ETHernet MAC Layer Interface
1019  siETH_Data,
1020  //-- ARP Interface
1021  soARP_Data,
1022  //-- ICMP Interfaces
1023  soICMP_Data,
1024  soICMP_Derr,
1025  //-- UDP Interface
1026  soUOE_Data,
1027  //-- TOE Interface
1028  soTOE_Data);
1029 
1030 }
1031 #else
1032  void iprx_top(
1033  //------------------------------------------------------
1034  //-- MMIO Interfaces
1035  //------------------------------------------------------
1036  EthAddr piMMIO_MacAddress,
1037  Ip4Addr piMMIO_Ip4Address,
1038  //------------------------------------------------------
1039  //-- ETHernet MAC Layer Interface
1040  //------------------------------------------------------
1041  stream<AxisRaw> &siETH_Data,
1042  //------------------------------------------------------
1043  //-- ARP Interface
1044  //------------------------------------------------------
1045  stream<AxisRaw> &soARP_Data,
1046  //------------------------------------------------------
1047  //-- ICMP Interfaces
1048  //------------------------------------------------------
1049  stream<AxisRaw> &soICMP_Data,
1050  stream<AxisRaw> &soICMP_Derr,
1051  //------------------------------------------------------
1052  //-- UOE Interface
1053  //------------------------------------------------------
1054  stream<AxisRaw> &soUOE_Data,
1055  //------------------------------------------------------
1056  //-- TOE Interface
1057  //------------------------------------------------------
1058  stream<AxisRaw> &soTOE_Data)
1059 {
1060 
1061  //-- DIRECTIVES FOR THE INTERFACES -----------------------------------------
1062  #pragma HLS INTERFACE ap_ctrl_none port=return
1063 
1064  #pragma HLS INTERFACE ap_stable port=piMMIO_MacAddress name=piMMIO_MacAddress
1065  #pragma HLS INTERFACE ap_stable port=piMMIO_Ip4Address name=piMMIO_Ip4Address
1066 
1067  #pragma HLS INTERFACE axis off port=siETH_Data name=siETH_Data
1068 
1069  #pragma HLS INTERFACE axis off port=soARP_Data name=soARP_Data
1070 
1071  #pragma HLS INTERFACE axis off port=soICMP_Data name=soICMP_Data
1072  #pragma HLS INTERFACE axis off port=soICMP_Derr name=soICMP_Derr
1073 
1074  #pragma HLS INTERFACE axis off port=soUOE_Data name=soUOE_Data
1075  #pragma HLS INTERFACE axis off port=soTOE_Data name=soTOE_Data
1076 
1077  //-- DIRECTIVES FOR THIS PROCESS -------------------------------------------
1078  #pragma HLS DATAFLOW disable_start_propagation
1079 
1080  //-- LOCAL INPUT and OUTPUT STREAMS ----------------------------------------
1081  static stream<AxisEth> ssiETH_Data;
1082  static stream<AxisArp> ssoARP_Data;
1083  static stream<AxisIp4> ssoICMP_Data;
1084  static stream<AxisIp4> ssoICMP_Derr;
1085  static stream<AxisIp4> ssoUOE_Data;
1086  static stream<AxisIp4> ssoTOE_Data;
1087 
1088  //-- INPUT STREAM CASTING --------------------------------------------------
1089  pAxisRawCast(siETH_Data, ssiETH_Data);
1090 
1091  //-- MAIN IPRX PROCESS -----------------------------------------------------
1092  iprx(
1093  //-- MMIO Interfaces
1094  piMMIO_MacAddress,
1095  piMMIO_Ip4Address,
1096  //-- ETHernet MAC Layer Interface
1097  ssiETH_Data,
1098  //-- ARP Interface
1099  ssoARP_Data,
1100  //-- ICMP Interfaces
1101  ssoICMP_Data,
1102  ssoICMP_Derr,
1103  //-- UDP Interface
1104  ssoUOE_Data,
1105  //-- TOE Interface
1106  ssoTOE_Data);
1107 
1108  //-- OUTPUT STREAM CASTING -------------------------------------------------
1109  pAxisRawCast(ssoARP_Data, soARP_Data);
1110  pAxisRawCast(ssoICMP_Data, soICMP_Data);
1111  pAxisRawCast(ssoICMP_Derr, soICMP_Derr);
1112  pAxisRawCast(ssoUOE_Data, soUOE_Data);
1113  pAxisRawCast(ssoTOE_Data, soTOE_Data);
1114 
1115 }
1116 #endif // HLS_VERSION
1117 
AxisEth::getIp4HdrLen
Ip4HdrLen getIp4HdrLen()
Definition: AxisEth.hpp:237
AxisEth::getIp4DstAddrHi
Ip4DstAddrHi getIp4DstAddrHi()
Definition: AxisEth.hpp:268
AxisEth::getEtherType
EtherType getEtherType()
Definition: AxisEth.hpp:172
AxisEth::getIp4Version
Ip4Version getIp4Version()
Definition: AxisEth.hpp:234
AxisEth::getIp4DstAddrLo
Ip4DstAddrLo getIp4DstAddrLo()
Definition: AxisEth.hpp:270
AxisEth::getLE_EthDstAddr
LE_EthAddr getLE_EthDstAddr()
Definition: AxisEth.hpp:176
AxisEth::getIp4TotalLen
Ip4TotalLen getIp4TotalLen()
Definition: AxisEth.hpp:243
AxisEth::getEthDstAddr
EthAddr getEthDstAddr()
Definition: AxisEth.hpp:161
AxisEth::getIp4ToS
Ip4ToS getIp4ToS()
Definition: AxisEth.hpp:240
AxisIp4::getIp4TtL
Ip4TtL getIp4TtL()
Definition: AxisIp4.hpp:218
AxisIp4::getIp4TotalLen
Ip4TotalLen getIp4TotalLen()
Definition: AxisIp4.hpp:205
AxisIp4::getIp4Prot
Ip4Prot getIp4Prot()
Definition: AxisIp4.hpp:221
AxisRaw::getLE_TKeep
LE_tKeep getLE_TKeep(int leHi=64/8-1, int leLo=0) const
Definition: AxisRaw.hpp:264
AxisRaw::getLE_TData
LE_tData getLE_TData(int leHi=64 -1, int leLo=0) const
Definition: AxisRaw.hpp:260
AxisRaw::setLE_TLast
void setLE_TLast(LE_tLast last)
Definition: AxisRaw.hpp:280
AxisRaw::setLE_TData
void setLE_TData(LE_tData data, int leHi=64 -1, int leLo=0)
Definition: AxisRaw.hpp:272
AxisRaw::getLen
int getLen() const
Definition: AxisRaw.hpp:411
AxisRaw::setLE_TKeep
void setLE_TKeep(LE_tKeep keep, int leHi=64/8-1, int leLo=0)
Definition: AxisRaw.hpp:276
AxisRaw::isValid
bool isValid() const
Definition: AxisRaw.hpp:434
AxisRaw::getLE_TLast
LE_tLast getLE_TLast() const
Definition: AxisRaw.hpp:268
SubSums
Definition: iprx.hpp:73
SubSums::sum1
ap_uint< 17 > sum1
Definition: iprx.hpp:76
SubSums::sum0
ap_uint< 17 > sum0
Definition: iprx.hpp:75
SubSums::ipMatch
bool ipMatch
Definition: iprx.hpp:79
SubSums::sum2
ap_uint< 17 > sum2
Definition: iprx.hpp:77
SubSums::sum3
ap_uint< 17 > sum3
Definition: iprx.hpp:78
FSM_IDLE
#define FSM_IDLE
Definition: harris.hpp:79
pIpCutLength
void pIpCutLength(stream< AxisIp4 > &siIId_Data, stream< AxisIp4 > &soIPr_Data)
Definition: iprx.cpp:576
TRACE_IBUF
#define TRACE_IBUF
Definition: iprx.cpp:70
pIpLengthChecker
void pIpLengthChecker(stream< AxisEth > &siMPd_Data, stream< AxisEth > &soICa_Data)
Definition: iprx.cpp:226
MaxDatagramSize
const UdpLen MaxDatagramSize
Definition: iprx.hpp:68
pIpInvalidDropper
void pIpInvalidDropper(stream< AxisIp4 > &siICa_Data, stream< Ip4Version > &siICa_IpVer, stream< ValBit > &siICa_DropFrag, stream< ValBit > &siICc_CsumValid, stream< AxisIp4 > &soICl_Data)
Definition: iprx.cpp:504
iprx
void iprx(EthAddr piMMIO_MacAddress, Ip4Addr piMMIO_Ip4Address, stream< AxisEth > &siETH_Data, stream< AxisArp > &soARP_Data, stream< AxisIp4 > &soICMP_Data, stream< AxisIp4 > &soICMP_Derr, stream< AxisIp4 > &soUOE_Data, stream< AxisIp4 > &soTOE_Data)
Main process of the IP Receive handler (IPRX).
Definition: iprx.cpp:826
TRACE_ILC
#define TRACE_ILC
Definition: iprx.cpp:72
gTraceEvent
bool gTraceEvent
Definition: tb_nal.cpp:151
iprx_top
void iprx_top(EthAddr piMMIO_MacAddress, Ip4Addr piMMIO_Ip4Address, stream< AxisRaw > &siETH_Data, stream< AxisRaw > &soARP_Data, stream< AxisRaw > &soICMP_Data, stream< AxisRaw > &soICMP_Derr, stream< AxisRaw > &soUOE_Data, stream< AxisRaw > &soTOE_Data)
Top of IP Receive handler (IPRX)
Definition: iprx.cpp:1032
pInputBuffer
void pInputBuffer(stream< AxisEth > &siETH_Data, stream< AxisEth > &soMPd_Data)
Definition: iprx.cpp:94
THIS_NAME
#define THIS_NAME
Definition: iprx.cpp:67
pMacProtocolDetector
void pMacProtocolDetector(EthAddr piMMIO_MacAddr, stream< AxisEth > &siIBuf_Data, stream< AxisArp > &soARP_Data, stream< AxisEth > &soILc_Data)
Definition: iprx.cpp:133
pIpChecksumChecker
void pIpChecksumChecker(stream< SubSums > &siICa_SubSums, stream< ValBit > &soIId_CsumValid)
Definition: iprx.cpp:643
pIpPacketRouter
void pIpPacketRouter(stream< AxisIp4 > &siICl_Data, stream< AxisIp4 > &soICMP_Data, stream< AxisIp4 > &soICMP_Derr, stream< AxisIp4 > &soUOE_Data, stream< AxisIp4 > &soTOE_Data)
Definition: iprx.cpp:689
DEBUG_LEVEL
#define DEBUG_LEVEL
Definition: iprx.cpp:80
pIpChecksumAccumulator
void pIpChecksumAccumulator(Ip4Addr piMMIO_Ip4Address, stream< AxisEth > &siILc_Data, stream< AxisIp4 > &soIId_Data, stream< Ip4Version > &soIId_IpVer, stream< CmdBit > &soIId_DropCmd, stream< SubSums > &soICc_SubSums)
Definition: iprx.cpp:323
IP4_PROT_ICMP
#define IP4_PROT_ICMP
Definition: nts_types.hpp:183
Ip4Prot
ap_uint< 8 > Ip4Prot
Definition: AxisIp4.hpp:164
EthAddr
ap_uint< 48 > EthAddr
Definition: AxisEth.hpp:120
printError
#define printError(callerName, format,...)
A macro to print an error message.
Definition: nts_utils.hpp:195
LE_Ip4Addr
ap_uint< 32 > LE_Ip4Addr
Definition: AxisIp4.hpp:149
lenToLE_tKeep
LE_tKeep lenToLE_tKeep(ap_uint< 4 > noValidBytes)
A function to set a number of '1' in an 8-bit field. It is used here to set the number of valid bytes...
Definition: nts_utils.cpp:307
StsBit
ap_uint< 1 > StsBit
Definition: nts_types.hpp:116
IP4_PROT_UDP
#define IP4_PROT_UDP
Definition: nts_types.hpp:185
printAxisRaw
void printAxisRaw(const char *callerName, AxisRaw chunk)
Prints an Axis raw data chunk (used for debugging).
Definition: nts_utils.cpp:46
Ip4Addr
ap_uint< 32 > Ip4Addr
Definition: AxisIp4.hpp:169
ValBit
ap_uint< 1 > ValBit
Definition: nts_types.hpp:117
pAxisRawCast
void pAxisRawCast(hls::stream< TypeIn > &si, hls::stream< TypeOut > &so)
AxisRaw cast - Casts an AxisRaw stream to/from an AxisRaw derived class.
Definition: AxisRaw.hpp:148
CMD_DROP
#define CMD_DROP
Definition: nts_types.hpp:61
IP4_PROT_TCP
#define IP4_PROT_TCP
Definition: nts_types.hpp:184
ETH_ETHERTYPE_ARP
#define ETH_ETHERTYPE_ARP
Definition: nts_types.hpp:156
CMD_KEEP
#define CMD_KEEP
Definition: nts_types.hpp:62
printInfo
#define printInfo(callerName, format,...)
A macro to print an information message.
Definition: nts_utils.hpp:169
Ip4TotalLen
ap_uint< 16 > Ip4TotalLen
Definition: AxisIp4.hpp:159
printWarn
#define printWarn(callerName, format,...)
A macro to print a warning message.
Definition: nts_utils.hpp:182
concat3
#define concat3(firstCharConst, secondCharConst, thirdCharConst)
Definition: nts_utils.hpp:161
ETH_ETHERTYPE_IP4
#define ETH_ETHERTYPE_IP4
Definition: nts_types.hpp:155
TLAST
#define TLAST
Definition: AxisRaw.hpp:116
EtherType
ap_uint< 16 > EtherType
Definition: AxisEth.hpp:122
iprx.hpp
: IP Receiver packet handler (IPRX).
byteSwap16
ap_uint< 16 > byteSwap16(ap_uint< 16 > inputVector)
Definition: udp.cpp:82