AxisUdp.hpp

Go to the documentation of this file.

/*
 * Copyright 2016 -- 2021 IBM Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef _AXIS_UDP_H_
#define _AXIS_UDP_H_
 
#include "AxisRaw.hpp"
 
 
#define UDP_HEADER_LEN  8           // In bytes
 
 
typedef ap_uint<16> LE_UdpSrcPort;  // UDP Source Port
typedef ap_uint<16> LE_UdpDstPort;  // UDP Destination Port
typedef ap_uint<16> LE_UdpPort;     // UDP source or destination Port
typedef ap_uint<16> LE_UdpLen;      // UDP header and data Length
typedef ap_uint<16> LE_UdpCsum;     // UDP header and data Checksum
typedef LE_tData    LE_UdpData;     // UDP Data unit of transfer
 
 
typedef ap_uint<16> UdpSrcPort;     // UDP Source Port
typedef ap_uint<16> UdpDstPort;     // UDP Destination Port
typedef ap_uint<16> UdpPort;        // UDP source or destination Port
typedef ap_uint<16> UdpLen;         // UDP header and data Length
typedef ap_uint<16> UdpCsum;        // UDP header and data Checksum
typedef tData       UdpData;        // UDP Data unit of transfer
typedef tDataHalf   UdpDataHi;      // UDP High part of a data unit of transfer
typedef tDataHalf   UdpDataLo;      // UDP Low part of a data unit of transfer
 
typedef ap_uint<16> UdpDgmLen;      // UDP Datagram Length in octets (same as UdpLen=Hdr+Data)
typedef ap_uint<16> UdpDatLen;      // UDP Data     Length in octets (same as UdpDgmLen minus UdpHdrLen)
 
 
class AxisUdp: public AxisRaw {
 
  public:
    AxisUdp() {}
    AxisUdp(AxisRaw axisRaw) :
        AxisRaw(axisRaw.getLE_TData(), axisRaw.getLE_TKeep(), axisRaw.getLE_TLast()) {}
    AxisUdp(LE_tData tdata, LE_tKeep tkeep, LE_tLast tlast) :
        AxisRaw(tdata, tkeep, tlast) {}
    AxisUdp(const AxisUdp &axisUdp) :
        AxisRaw(axisUdp.tdata, axisUdp.tkeep, axisUdp.tlast) {}
 
 
    // Set-Get the UDP Source Port
    void          setUdpSrcPort(UdpPort port)   {                  tdata.range(15,  0) = swapWord(port);  }
    UdpPort       getUdpSrcPort()               { return swapWord (tdata.range(15,  0));                  }
    LE_UdpPort getLE_UdpSrcPort()               {           return tdata.range(15,  0) ;                  }
 
    // Set-Get the UDP Destination Port
    void          setUdpDstPort(UdpPort port)   {                  tdata.range(31, 16) = swapWord(port);  }
    UdpPort       getUdpDstPort()               { return swapWord (tdata.range(31, 16));                  }
    LE_UdpPort getLE_UdpDstPort()               {           return tdata.range(31, 16);                   }
 
    // Set-Get the UDP length field
    void          setUdpLen(UdpLen length)      {                  tdata.range(47, 32) = swapWord(length);}
    UdpLen        getUdpLen()                   { return swapWord (tdata.range(47, 32));                  }
    LE_UdpLen     getLE_UdpLen()                   {           return tdata.range(47, 32);                   }
 
    // Set-Get the UDP Checksum field
    void          setUdpCsum(UdpCsum csum)      {                  tdata.range(63, 48) = swapWord(csum);  }
    UdpCsum       getUdpCsum()                  { return swapWord (tdata.range(63, 48));                  }
 
  private:
    // Reverse the bits within a nibble.
    ap_uint<4> swapNibble(ap_uint<4> nibble) {
        return (nibble.range(0,3));
    }
    // Reverse the bits within a byte.
    ap_uint<8> swapByte(ap_uint<8> byte) {
        return (byte.range(0,7));
    }
    // Swap the two bytes of a word (.i.e, 16 bits)
    ap_uint<16> swapWord(ap_uint<16> word) {
      return (word.range(7,0), word.range(15, 8));
    }
    // Swap the four bytes of a double-word (.i.e, 32 bits)
    ap_uint<32> swapDWord(ap_uint<32> dword) {
      return (dword.range( 7, 0), dword.range(15,  8),
              dword.range(23,16), dword.range(31, 24));
    }
 
}; // End of: AxisUdp
 
#endif