int main() {
printf("The word byte for position 2: ");
replace_byte(0x12345678, 2, 0xAB); //result should be 0x12AB5678
printf("The word byte for position 0: ");
replace_byte(0x12345678, 0, 0xAB); //result should be 0x123456AB
return 0;
}
int main( void )
{
unsigned source = 0x12345678;
printf( "%#x\n", source );
printf( "%#x\n", replace_byte( source, 0xab, 2 ) );
printf( "%#x\n", replace_byte( source, 0xab, 0 ) );
return 0;
}
int main()
{
int i;
int j;
int k;
hls::stream<t_axis> m_axis;
hls::stream<t_m_xgmii> m_xgmii;
int correct_frames = 0;
hls::stream<t_tx_status> tx_status_stream;
for (j = 0; j < FRAMES_CNT; j++) {
i = 0;
int start_word = 0;
while(i < frames[j].len){
t_axis word = (t_axis) {0x0000000000000000, 0x00, 0, 0};
ap_uint<64> mask;
for(k = 0; (k < 8) && (i < frames[j].len); k++){
word.data = replace_byte(word.data, frames[j].data[i++], k);
word.keep |= (1 << k);
}
if (i == frames[j].len) {
word.last = 1;
}
m_axis.write(word);
}
}
transmit(m_axis, m_xgmii, tx_status_stream);
while (!m_xgmii.empty()) {
t_m_xgmii xgmii = m_xgmii.read();
if ((xgmii.txd == 0xd5555555555555fb) && (xgmii.txc == 0x01)) {
printf("***********************************************************************************\n");
i = 0;
} else if (xgmii.txc != 0xff) {
printf("%02d: TXD 0x%016lx, TXC 0x%02x\n", i, xgmii.txd.to_long(), xgmii.txc.to_int());
i++;
} else {
printf("ID: TXD 0x%016lx, TXC 0x%02x\n", xgmii.txd.to_long(), xgmii.txc.to_int());
}
}
while (!tx_status_stream.empty()){
t_tx_status tx_status = tx_status_stream.read();
}
return 0;
}
void test(uint x, uchar b, int i){
printf("%x replace at %d by %x, ret:%x\n", x, i, b, replace_byte(x, b, i));
}
void receive(
hls::stream<t_s_xgmii> &s_xgmii,
hls::stream<t_axis> &m_axis,
hls::stream<t_rx_status> &rx_status
)
{
#ifdef RELEASE
#pragma HLS interface ap_ctrl_none port=return
#pragma HLS data_pack variable=s_xgmii
#endif
#pragma HLS INTERFACE axis port=m_axis
#pragma HLS data_pack variable=rx_status
int i;
t_s_xgmii cur = {0, 0};
t_s_xgmii precur = {0, 0};
t_s_xgmii last_word;
ap_uint<32> crc_state = 0xffffffff;
ap_uint<16> frm_cnt = 0;
int data_err = 0;
ap_uint<16> len_type = 0xffff;
int last_user_byte_lane_before_frame_end;
int user_data_end_detected = 0;
int last_user_word_pos;
ap_uint<3> last_user_byte_lane;
MAIN: while (1) {
if (user_data_end_detected) {
int fcs_err = (crc_state != 0x00000000);
int len_err = 0;
int frm_byte_cnt = frm_cnt*8 + last_user_byte_lane_before_frame_end + 1 + 4;
int under = (frm_byte_cnt < 64);
int over = (frm_byte_cnt > 1500);
if (is_len(len_type)) {
if (len_type > 2) {
len_err = (len_type != ((last_user_word_pos - 2) * 8 + 2 + last_user_byte_lane + 1));
} else {
len_err = (len_type != ((last_user_word_pos - 2) * 8 + 2 + 8 - (last_user_byte_lane + 1)));
}
}
int good = !(fcs_err | len_err | data_err | under | over);
m_axis.write((t_axis){last_word.rxd, mask_up_to_bit(8, last_user_byte_lane), !good, 1});
rx_status.write((t_rx_status) {frm_cnt, good, 0, 0, under, len_err, fcs_err, data_err, 0, over});
}
cur = precur;
if (!s_xgmii.read_nb(precur)) return;
frm_cnt = 0;
crc_state = 0xffffffff;
len_type = 0xffff;
IDLE_AND_PREAMBLE: while (!((cur.rxc == 0x01) && (cur.rxd == 0xd5555555555555fb))) {
#pragma HLS LATENCY max=0 min=0
cur = precur;
if (!s_xgmii.read_nb(precur)) return;
// printf("RXD 0x%016lx, RXC 0x%02x\n", cur.rxd.to_long(), cur.rxc.to_int());
}
cur = precur;
if (!s_xgmii.read_nb(precur)) return;
// printf("RXD 0x%016lx, RXC 0x%02x\n", cur.rxd.to_long(), cur.rxc.to_int());
user_data_end_detected = 0;
int frame_end_detected = 0;
USER_DATA: do {
#pragma HLS LATENCY max=0 min=0
ap_uint<8> crc_field_mask;
// END-OF-FRAME detection
if (cur.rxc != 0x00) {
switch(cur.rxc) {
case 0xe0 : last_user_byte_lane_before_frame_end = 0; crc_field_mask = 0x1e; break;
case 0xc0 : last_user_byte_lane_before_frame_end = 1; crc_field_mask = 0x3c; break;
case 0x80 : last_user_byte_lane_before_frame_end = 2; crc_field_mask = 0x78; break;
default: crc_field_mask = 0xff; break;
}
frame_end_detected = 1;
if (!user_data_end_detected) {
last_word = cur;
last_user_byte_lane = last_user_byte_lane_before_frame_end;
}
user_data_end_detected = 1;
} else if ((precur.rxc != 0x00) && ((ap_uint<8>) ~precur.rxc <= 0x0f)) {
switch(precur.rxc) {
case 0xf0 : last_user_byte_lane_before_frame_end = 7; break;
case 0xf8 : last_user_byte_lane_before_frame_end = 6; crc_field_mask = 0x80; break;
case 0xfc : last_user_byte_lane_before_frame_end = 5; crc_field_mask = 0xc0; break;
case 0xfe : last_user_byte_lane_before_frame_end = 4; crc_field_mask = 0xe0; break;
case 0xff : last_user_byte_lane_before_frame_end = 3; crc_field_mask = 0xf0; frame_end_detected = 1; break;
}
if (!user_data_end_detected) {
last_word = cur;
last_user_byte_lane = last_user_byte_lane_before_frame_end;
}
user_data_end_detected = 1;
} else {
crc_field_mask = 0x00;
}
// END-OF-USER-DATA detection
if (!user_data_end_detected) {
if (frm_cnt == 1) {
len_type = ((ap_uint<16>) wbyte(cur.rxd, 4) << 8) | wbyte(cur.rxd, 5);
if (is_len(len_type)) {
// Calculate the position of the last word within the frame
// which contains valid user data (based on LENGTH/TYPE field
// value. -3 is subtracted before division because first two
// bytes of user data are not word aligned, and 1 is subtracted
// additionally since we want to find out the last word that
// still contains data, not the number of user data words. +2
// since first word aligned user data byte starts at word #2.
last_user_word_pos = (len_type - 3) / 8 + 2;
last_user_byte_lane = (len_type - 3) % 8;
if (len_type <= 2) {
user_data_end_detected = 1;
last_word = cur;
}
}
} else if (is_len(len_type)) {
if (frm_cnt == last_user_word_pos) {
last_word = cur;
user_data_end_detected = 1;
}
}
}
if (!user_data_end_detected) {
m_axis.write((t_axis){cur.rxd, 0xff, 0, 0});
frm_cnt++;
}
ap_uint<64> crc_data = 0;
CRC_MASK_CALC: for (i = 0; i < 8; i++) {
#pragma HLS LOOP unroll
if (!wbit(cur.rxc, i)) {
ap_uint<8> d = wbyte(cur.rxd, i);
if (wbit(crc_field_mask,i)) {
d = ~d;
}
crc_data = replace_byte(crc_data, d, i);
}
}
crc32<ap_uint<64>>(crc_data, &crc_state);
// printf("RXD 0x%016lx, RXC 0x%02x, CRC_DATA 0x%016lx, crc_field_mask 0x%02x, CRC_STATE 0x%08lx, FRMEND %d\n", cur.rxd.to_long(), cur.rxc.to_int(), crc_data.to_long(), crc_field_mask.to_int(), crc_state.to_int(), frame_end_detected);
//// printf("RXD 0x%016lx, RXC 0x%02x, CRC_STATE 0x%08lx, FRMEND %d\n", cur.rxd.to_long(), cur.rxc.to_int(), crc_state.to_int(), frame_end_detected);
cur = precur;
if (!s_xgmii.read_nb(precur)) return;
} while(!frame_end_detected);
}
}
