Dataset Viewer
text
stringlengths 21
997k
|
|---|
module bits_to_bytes
(
input clock,
input enable,
input reset,
input bit_in,
input input_strobe,
output reg [7:0] byte_out,
output reg output_strobe
);
reg [7:0] bit_buf;
reg [2:0] addr;
always @(posedge clock) begin
if (reset) begin
addr <= 0;
bit_buf <= 0;
byte_out <= 0;
output_strobe <= 0;
end else if (enable & input_strobe) begin
bit_buf[7] <= bit_in;
bit_buf[6:0] <= bit_buf[7:1];
addr <= addr + 1;
if (addr == 7) begin
byte_out <= {bit_in, bit_buf[7:1]};
output_strobe <= 1;
end else begin
output_strobe <= 0;
end
end else begin
output_strobe <= 0;
end
end
endmodule |
module calc_mean
(
input clock,
input enable,
input reset,
input signed [15:0] a,
input signed [15:0] b,
input sign,
input input_strobe,
output reg signed [15:0] c,
output reg output_strobe
);
reg signed [15:0] aa;
reg signed [15:0] bb;
reg signed [15:0] cc;
reg [1:0] delay;
reg [1:0] sign_stage;
always @(posedge clock) begin
if (reset) begin
aa <= 0;
bb <= 0;
cc <= 0;
c <= 0;
output_strobe <= 0;
delay <= 0;
end else if (enable) begin
delay[0] <= input_strobe;
delay[1] <= delay[0];
output_strobe <= delay[1];
sign_stage[1] <= sign_stage[0];
sign_stage[0] <= sign;
aa <= a>>>1;
bb <= b>>>1;
cc <= aa + bb;
c <= sign_stage[1]? ~cc+1: cc;
end
end
endmodule |
module sky130_sram_1kbyte_1rw1r_32x256_8(
`ifdef use_power_pins
vccd1,
vssd1,
`endif
clk0,csb0,web0,wmask0,addr0,din0,dout0,
clk1,csb1,addr1,dout1
);
parameter num_wmasks = 4 ;
parameter data_width = 32 ;
parameter addr_width = 8 ;
parameter ram_depth = 1 << addr_width;
parameter delay = 3 ;
parameter verbose = 1 ; parameter t_hold = 1 ;
`ifdef use_power_pins
inout vccd1;
inout vssd1;
`endif
input clk0; input csb0; input web0; input [num_wmasks-1:0] wmask0; input [addr_width-1:0] addr0;
input [data_width-1:0] din0;
output [data_width-1:0] dout0;
input clk1; input csb1; input [addr_width-1:0] addr1;
output [data_width-1:0] dout1;
endmodule |
module usb_ep(
input clk,
input direction_in,
input setup,
input success,
input[6:0] cnt,
output reg toggle,
output bank_usb,
output reg[1:0] handshake,
output bank_in,
output bank_out,
output in_data_valid,
input ctrl_dir_in,
output reg[15:0] ctrl_rd_data,
input[15:0] ctrl_wr_data,
input[1:0] ctrl_wr_en
);
localparam
hs_ack = 2'b00,
hs_none = 2'b01,
hs_nak = 2'b10,
hs_stall = 2'b11;
reg ep_setup;
reg ep_out_full;
reg ep_out_empty;
reg ep_in_full;
reg ep_out_stall;
reg ep_in_stall;
reg ep_out_toggle;
reg ep_in_toggle;
reg[6:0] ep_in_cnt;
reg[6:0] ep_out_cnt;
assign in_data_valid = (cnt != ep_in_cnt);
assign bank_usb = 1'b0;
assign bank_in = 1'b0;
assign bank_out = 1'b0;
always @(*) begin
if (!direction_in && setup)
toggle = 1'b0;
else if (ep_setup)
toggle = 1'b1;
else if (direction_in)
toggle = ep_in_toggle;
else
toggle = ep_out_toggle;
end
always @(*) begin
if (direction_in) begin
if (!ep_in_stall && !ep_setup && ep_in_full) begin
handshake = hs_ack;
end else if (!ep_setup && ep_in_stall) begin
handshake = hs_stall;
end else begin
handshake = hs_nak;
end
end else begin
if (setup || (!ep_out_stall && !ep_setup && ep_out_full)) begin
handshake = hs_ack;
end else if (!ep_setup && ep_out_stall) begin
handshake = hs_stall;
end else begin
handshake = hs_nak;
end
end
end
always @(*) begin
if (ctrl_dir_in) begin
ctrl_rd_data[15:8] = ep_in_cnt;
ctrl_rd_data[7:0] = { ep_in_toggle, ep_in_stall, 1'b0, !ep_in_full, ep_in_full };
end else begin
ctrl_rd_data[15:8] = ep_out_cnt;
ctrl_rd_data[7:0] = { ep_out_toggle, ep_out_stall, ep_setup, ep_out_empty, ep_out_full };
end
end
wire flush = ctrl_wr_data[5] || ctrl_wr_data[4] || ctrl_wr_data[3];
always @(posedge clk) begin
if (success) begin
if (direction_in) begin
ep_in_full <= 1'b0;
ep_in_toggle <= !ep_in_toggle;
end else begin
if (setup)
ep_setup <= 1'b1;
ep_out_toggle <= !ep_out_toggle;
ep_out_empty <= 1'b0;
ep_out_full <= 1'b0;
ep_out_cnt <= cnt;
end
end
if (ctrl_wr_en[1] && ctrl_dir_in) begin
ep_in_cnt <= ctrl_wr_data[14:8];
end
if (ctrl_wr_en[0] && ctrl_dir_in) begin
if (ctrl_wr_data[5]) begin
ep_in_toggle <= 1'b0;
ep_in_stall <= 1'b0;
end
if (ctrl_wr_data[4]) begin
ep_in_toggle <= 1'b1;
ep_in_stall <= 1'b0;
end
if (ctrl_wr_data[3])
ep_in_stall <= 1'b1;
if (flush)
ep_in_full <= 1'b0;
if (ctrl_wr_data[0])
ep_in_full <= 1'b1;
end
if (ctrl_wr_en[0] && !ctrl_dir_in) begin
if (ctrl_wr_data[5]) begin
ep_out_toggle <= 1'b0;
ep_out_stall <= 1'b0;
end
if (ctrl_wr_data[4]) begin
ep_out_toggle <= 1'b1;
ep_out_stall <= 1'b0;
end
if (ctrl_wr_data[3])
ep_out_stall <= 1'b1;
if (flush) begin
ep_out_full <= 1'b0;
ep_out_empty <= 1'b1;
end
if (ctrl_wr_data[2])
ep_setup <= 1'b0;
if (ctrl_wr_data[1])
ep_out_empty <= 1'b1;
if (ctrl_wr_data[0])
ep_out_full <= 1'b1;
end
end
endmodule |
module usb_ep_banked(
input clk,
input direction_in,
input setup,
input success,
input[6:0] cnt,
output reg toggle,
output bank_usb,
output reg[1:0] handshake,
output bank_in,
output bank_out,
output in_data_valid,
input ctrl_dir_in,
output reg[15:0] ctrl_rd_data,
input[15:0] ctrl_wr_data,
input[1:0] ctrl_wr_en
);
localparam
hs_ack = 2'b00,
hs_none = 2'b01,
hs_nak = 2'b10,
hs_stall = 2'b11;
reg ep_setup;
reg ep_out_full;
reg ep_out_empty;
reg ep_in_empty;
reg ep_out_stall;
reg ep_in_stall;
reg ep_out_toggle;
reg ep_in_toggle;
reg ep_in_bank;
reg[6:0] ep_in_cnt_0;
reg[6:0] ep_in_cnt_1;
reg[6:0] ep_out_cnt;
assign in_data_valid = (cnt != (ep_in_toggle? ep_in_cnt_1: ep_in_cnt_0));
assign bank_usb = direction_in? ep_in_toggle: 1'b0;
assign bank_in = ep_in_bank;
assign bank_out = 1'b0;
always @(*) begin
if (!direction_in && setup)
toggle = 1'b0;
else if (ep_setup)
toggle = 1'b1;
else if (direction_in)
toggle = ep_in_toggle;
else
toggle = ep_out_toggle;
end
always @(*) begin
if (direction_in) begin
if (!ep_in_stall && !ep_setup && !ep_in_empty) begin
handshake = hs_ack;
end else if (!ep_setup && ep_in_stall) begin
handshake = hs_stall;
end else begin
handshake = hs_nak;
end
end else begin
if (setup || (!ep_out_stall && !ep_setup && ep_out_full)) begin
handshake = hs_ack;
end else if (!ep_setup && ep_out_stall) begin
handshake = hs_stall;
end else begin
handshake = hs_nak;
end
end
end
always @(*) begin
if (ctrl_dir_in) begin
ctrl_rd_data[15:8] = ep_in_bank? ep_in_cnt_1: ep_in_cnt_0;
ctrl_rd_data[7:0] = { ep_in_bank, ep_in_toggle, ep_in_stall, 1'b0, ep_in_empty, !ep_in_empty && ep_in_toggle == ep_in_bank };
end else begin
ctrl_rd_data[15:8] = ep_out_cnt;
ctrl_rd_data[7:0] = { ep_out_toggle, ep_out_stall, ep_setup, ep_out_empty, ep_out_full };
end
end
wire flush = ctrl_wr_data[5] || ctrl_wr_data[4] || ctrl_wr_data[3];
always @(posedge clk) begin
if (success) begin
if (direction_in) begin
if (ep_in_toggle != ep_in_bank)
ep_in_empty <= 1'b1;
ep_in_toggle = !ep_in_toggle;
end else begin
if (setup)
ep_setup <= 1'b1;
ep_out_toggle = !ep_out_toggle;
ep_out_empty <= 1'b0;
ep_out_cnt <= cnt;
end
end
if (ctrl_wr_en[1] && ctrl_dir_in) begin
if (ep_in_bank)
ep_in_cnt_1 <= ctrl_wr_data[14:8];
else
ep_in_cnt_0 <= ctrl_wr_data[14:8];
end
if (ctrl_wr_en[0] && ctrl_dir_in) begin
if (ctrl_wr_data[5]) begin
ep_in_toggle = 1'b0;
ep_in_stall <= 1'b0;
ep_in_bank <= 1'b0;
end
if (ctrl_wr_data[4]) begin
ep_in_toggle = 1'b1;
ep_in_stall <= 1'b0;
ep_in_bank <= 1'b1;
end
if (ctrl_wr_data[3]) begin
ep_in_stall <= 1'b1;
ep_in_bank <= ep_in_toggle;
end
if (flush) begin
ep_in_empty <= 1'b1;
end
if (ctrl_wr_data[0]) begin
ep_in_empty <= 1'b0;
ep_in_bank <= !ep_in_bank;
end
end
if (ctrl_wr_en[0] && !ctrl_dir_in) begin
if (ctrl_wr_data[5]) begin
ep_out_toggle = 1'b0;
ep_out_stall <= 1'b0;
end
if (ctrl_wr_data[4]) begin
ep_out_toggle = 1'b1;
ep_out_stall <= 1'b0;
end
if (ctrl_wr_data[3])
ep_out_stall <= 1'b1;
if (flush) begin
ep_out_full <= 1'b0;
ep_out_empty <= 1'b1;
end
if (ctrl_wr_data[2])
ep_setup <= 1'b0;
if (ctrl_wr_data[1]) begin
ep_out_empty <= 1'b1;
ep_out_full <= 1'b0;
end
if (ctrl_wr_data[0])
ep_out_full <= 1'b1;
end
end
endmodule |
module usb_crc5(
input rst_n,
input clk,
input clken,
input d,
output valid
);
reg[4:0] r;
reg[4:0] next;
wire top = r[4];
assign valid = (next == 5'b01100);
always @(*) begin
if (top == d)
next = { r[3], r[2], r[1], r[0], 1'b0 };
else
next = { r[3], r[2], !r[1], r[0], 1'b1 };
end
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
r <= 5'b11111;
end else if (clken) begin
r <= next;
end
end
endmodule |
module usb_crc16(
input rst_n,
input clk,
input clken,
input d,
input dump,
output out,
output valid
);
reg[15:0] r;
reg[15:0] next;
assign out = r[15];
assign valid = (next == 16'b1000000000001101);
always @(*) begin
if (dump || out == d)
next = { r[14:0], 1'b0 };
else
next = { !r[14], r[13:2], !r[1], r[0], 1'b1 };
end
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
r <= 16'hffff;
end else if (clken) begin
r <= next;
end
end
endmodule |
module usb_clk_recovery(
input rst_n,
input clk,
input i,
output strobe
);
reg[1:0] cntr;
reg prev_i;
assign strobe = cntr == 1'b0;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
cntr <= 1'b0;
prev_i <= 1'b0;
end else begin
if (i == prev_i) begin
cntr <= cntr - 1'b1;
end else begin
cntr <= 1'b1;
end
prev_i <= i;
end
end
endmodule |
module usb_bit_destuff(
input rst_n,
input clk,
input clken,
input d,
output strobe);
reg[6:0] data;
assign strobe = clken && (data != 7'b0111111);
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
data <= 7'b0000000;
end else if (clken) begin
data <= { data[5:0], d };
end
end
endmodule |
module usb_sync_detect(
input rst_n,
input clk,
input clken,
input j,
input se0,
output sync);
reg[6:0] data;
assign sync = (data == 7'b0101010 && !j && !se0);
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
data <= 1'd0;
end else if (clken) begin
data <= { data[5:0], j || se0 };
end
end
endmodule |
module usb_reset_detect(
input rst_n,
input clk,
input se0,
output usb_rst);
reg[18:0] cntr;
assign usb_rst = cntr == 1'b0;
always @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
cntr <= 1'b0;
end else begin
if (se0) begin
if (!usb_rst)
cntr <= cntr - 1'b1;
end else begin
cntr <= 19'd480000;
end
end
end
endmodule |
module multisample3(
input clk,
input in,
output reg out
);
reg[2:0] r;
always @(r) begin
case (r)
3'b000: out = 1'b0;
3'b001: out = 1'b0;
3'b010: out = 1'b0;
3'b011: out = 1'b1;
3'b100: out = 1'b0;
3'b101: out = 1'b1;
3'b110: out = 1'b1;
3'b111: out = 1'b1;
endcase
end
always @(posedge clk) begin
r <= { r[1:0], in };
end
endmodule |
module multisample5(
input clk,
input in,
output reg out
);
reg[4:0] r;
always @(r) begin
case (r)
5'b00000: out = 1'b0;
5'b00001: out = 1'b0;
5'b00010: out = 1'b0;
5'b00011: out = 1'b0;
5'b00100: out = 1'b0;
5'b00101: out = 1'b0;
5'b00110: out = 1'b0;
5'b00111: out = 1'b1;
5'b01000: out = 1'b0;
5'b01001: out = 1'b0;
5'b01010: out = 1'b0;
5'b01011: out = 1'b1;
5'b01100: out = 1'b0;
5'b01101: out = 1'b1;
5'b01110: out = 1'b1;
5'b01111: out = 1'b1;
5'b10000: out = 1'b0;
5'b10001: out = 1'b0;
5'b10010: out = 1'b0;
5'b10011: out = 1'b1;
5'b10100: out = 1'b0;
5'b10101: out = 1'b1;
5'b10110: out = 1'b1;
5'b10111: out = 1'b1;
5'b11000: out = 1'b0;
5'b11001: out = 1'b1;
5'b11010: out = 1'b1;
5'b11011: out = 1'b1;
5'b11100: out = 1'b1;
5'b11101: out = 1'b1;
5'b11110: out = 1'b1;
5'b11111: out = 1'b1;
endcase
end
always @(posedge clk) begin
r <= { r[3:0], in };
end
endmodule |
module nrzi_decode(
input clk,
input clken,
input i,
output o
);
reg prev_i;
assign o = (prev_i == i);
always @(posedge clk) begin
if (clken) begin
prev_i <= i;
end
end
endmodule |
module usbf_crc16
(
input [ 15:0] crc_in_i
,input [ 7:0] din_i
,output [ 15:0] crc_out_o
);
assign crc_out_o[15] = din_i[0] ^ din_i[1] ^ din_i[2] ^ din_i[3] ^ din_i[4] ^ din_i[5] ^ din_i[6] ^ din_i[7] ^
crc_in_i[7] ^ crc_in_i[6] ^ crc_in_i[5] ^ crc_in_i[4] ^ crc_in_i[3] ^ crc_in_i[2] ^ crc_in_i[1] ^ crc_in_i[0];
assign crc_out_o[14] = din_i[0] ^ din_i[1] ^ din_i[2] ^ din_i[3] ^ din_i[4] ^ din_i[5] ^ din_i[6] ^
crc_in_i[6] ^ crc_in_i[5] ^ crc_in_i[4] ^ crc_in_i[3] ^ crc_in_i[2] ^ crc_in_i[1] ^ crc_in_i[0];
assign crc_out_o[13] = din_i[6] ^ din_i[7] ^
crc_in_i[7] ^ crc_in_i[6];
assign crc_out_o[12] = din_i[5] ^ din_i[6] ^
crc_in_i[6] ^ crc_in_i[5];
assign crc_out_o[11] = din_i[4] ^ din_i[5] ^
crc_in_i[5] ^ crc_in_i[4];
assign crc_out_o[10] = din_i[3] ^ din_i[4] ^
crc_in_i[4] ^ crc_in_i[3];
assign crc_out_o[9] = din_i[2] ^ din_i[3] ^
crc_in_i[3] ^ crc_in_i[2];
assign crc_out_o[8] = din_i[1] ^ din_i[2] ^
crc_in_i[2] ^ crc_in_i[1];
assign crc_out_o[7] = din_i[0] ^ din_i[1] ^
crc_in_i[15] ^ crc_in_i[1] ^ crc_in_i[0];
assign crc_out_o[6] = din_i[0] ^
crc_in_i[14] ^ crc_in_i[0];
assign crc_out_o[5] = crc_in_i[13];
assign crc_out_o[4] = crc_in_i[12];
assign crc_out_o[3] = crc_in_i[11];
assign crc_out_o[2] = crc_in_i[10];
assign crc_out_o[1] = crc_in_i[9];
assign crc_out_o[0] = din_i[0] ^ din_i[1] ^ din_i[2] ^ din_i[3] ^ din_i[4] ^ din_i[5] ^ din_i[6] ^ din_i[7] ^
crc_in_i[8] ^ crc_in_i[7] ^ crc_in_i[6] ^ crc_in_i[5] ^ crc_in_i[4] ^ crc_in_i[3] ^ crc_in_i[2] ^ crc_in_i[1] ^ crc_in_i[0];
endmodule |
module usb_desc_rom
(
input hs_i,
input [7:0] addr_i,
output [7:0] data_o
);
reg [7:0] desc_rom_r;
always @ *
begin
case (addr_i)
8'd0: desc_rom_r = 8'h12;
8'd1: desc_rom_r = 8'h01;
8'd2: desc_rom_r = 8'h00;
8'd3: desc_rom_r = 8'h02;
8'd4: desc_rom_r = 8'h02;
8'd5: desc_rom_r = 8'h00;
8'd6: desc_rom_r = 8'h00;
8'd7: desc_rom_r = hs_i ? 8'h40 : 8'h08;
8'd8: desc_rom_r = 8'h50; 8'd9: desc_rom_r = 8'h1d; 8'd10: desc_rom_r = 8'h49; 8'd11: desc_rom_r = 8'h61; 8'd12: desc_rom_r = 8'h01;
8'd13: desc_rom_r = 8'h01;
8'd14: desc_rom_r = 8'h00;
8'd15: desc_rom_r = 8'h00;
8'd16: desc_rom_r = 8'h00;
8'd17: desc_rom_r = 8'h01;
8'd18: desc_rom_r = 8'h09;
8'd19: desc_rom_r = 8'h02;
8'd20: desc_rom_r = 8'h43;
8'd21: desc_rom_r = 8'h00;
8'd22: desc_rom_r = 8'h02;
8'd23: desc_rom_r = 8'h01;
8'd24: desc_rom_r = 8'h00;
8'd25: desc_rom_r = 8'h80;
8'd26: desc_rom_r = 8'h32;
8'd27: desc_rom_r = 8'h09;
8'd28: desc_rom_r = 8'h04;
8'd29: desc_rom_r = 8'h00;
8'd30: desc_rom_r = 8'h00;
8'd31: desc_rom_r = 8'h01;
8'd32: desc_rom_r = 8'h02;
8'd33: desc_rom_r = 8'h02;
8'd34: desc_rom_r = 8'h01;
8'd35: desc_rom_r = 8'h00;
8'd36: desc_rom_r = 8'h05;
8'd37: desc_rom_r = 8'h24;
8'd38: desc_rom_r = 8'h00;
8'd39: desc_rom_r = 8'h10;
8'd40: desc_rom_r = 8'h01;
8'd41: desc_rom_r = 8'h05;
8'd42: desc_rom_r = 8'h24;
8'd43: desc_rom_r = 8'h01;
8'd44: desc_rom_r = 8'h03;
8'd45: desc_rom_r = 8'h01;
8'd46: desc_rom_r = 8'h04;
8'd47: desc_rom_r = 8'h24;
8'd48: desc_rom_r = 8'h02;
8'd49: desc_rom_r = 8'h06;
8'd50: desc_rom_r = 8'h05;
8'd51: desc_rom_r = 8'h24;
8'd52: desc_rom_r = 8'h06;
8'd53: desc_rom_r = 8'h00;
8'd54: desc_rom_r = 8'h01;
8'd55: desc_rom_r = 8'h07;
8'd56: desc_rom_r = 8'h05;
8'd57: desc_rom_r = 8'h83;
8'd58: desc_rom_r = 8'h03;
8'd59: desc_rom_r = 8'h40;
8'd60: desc_rom_r = 8'h00;
8'd61: desc_rom_r = 8'h02;
8'd62: desc_rom_r = 8'h09;
8'd63: desc_rom_r = 8'h04;
8'd64: desc_rom_r = 8'h01;
8'd65: desc_rom_r = 8'h00;
8'd66: desc_rom_r = 8'h02;
8'd67: desc_rom_r = 8'h0a;
8'd68: desc_rom_r = 8'h00;
8'd69: desc_rom_r = 8'h00;
8'd70: desc_rom_r = 8'h00;
8'd71: desc_rom_r = 8'h07;
8'd72: desc_rom_r = 8'h05;
8'd73: desc_rom_r = 8'h01;
8'd74: desc_rom_r = 8'h02;
8'd75: desc_rom_r = hs_i ? 8'h00 : 8'h40;
8'd76: desc_rom_r = hs_i ? 8'h02 : 8'h00;
8'd77: desc_rom_r = 8'h00;
8'd78: desc_rom_r = 8'h07;
8'd79: desc_rom_r = 8'h05;
8'd80: desc_rom_r = 8'h82;
8'd81: desc_rom_r = 8'h02;
8'd82: desc_rom_r = hs_i ? 8'h00 : 8'h40;
8'd83: desc_rom_r = hs_i ? 8'h02 : 8'h00;
8'd84: desc_rom_r = 8'h00;
8'd85: desc_rom_r = 8'h04;
8'd86: desc_rom_r = 8'h03;
8'd87: desc_rom_r = 8'h09;
8'd88: desc_rom_r = 8'h04;
8'd89: desc_rom_r = 8'h1e;
8'd90: desc_rom_r = 8'h03;
8'd91: desc_rom_r = 8'h55;
8'd92: desc_rom_r = 8'h00;
8'd93: desc_rom_r = 8'h4c;
8'd94: desc_rom_r = 8'h00;
8'd95: desc_rom_r = 8'h54;
8'd96: desc_rom_r = 8'h00;
8'd97: desc_rom_r = 8'h52;
8'd98: desc_rom_r = 8'h00;
8'd99: desc_rom_r = 8'h41;
8'd100: desc_rom_r = 8'h00;
8'd101: desc_rom_r = 8'h2d;
8'd102: desc_rom_r = 8'h00;
8'd103: desc_rom_r = 8'h45;
8'd104: desc_rom_r = 8'h00;
8'd105: desc_rom_r = 8'h4d;
8'd106: desc_rom_r = 8'h00;
8'd107: desc_rom_r = 8'h42;
8'd108: desc_rom_r = 8'h00;
8'd109: desc_rom_r = 8'h45;
8'd110: desc_rom_r = 8'h00;
8'd111: desc_rom_r = 8'h44;
8'd112: desc_rom_r = 8'h00;
8'd113: desc_rom_r = 8'h44;
8'd114: desc_rom_r = 8'h00;
8'd115: desc_rom_r = 8'h45;
8'd116: desc_rom_r = 8'h00;
8'd117: desc_rom_r = 8'h44;
8'd118: desc_rom_r = 8'h00;
8'd119: desc_rom_r = 8'h1e;
8'd120: desc_rom_r = 8'h03;
8'd121: desc_rom_r = 8'h55;
8'd122: desc_rom_r = 8'h00;
8'd123: desc_rom_r = 8'h53;
8'd124: desc_rom_r = 8'h00;
8'd125: desc_rom_r = 8'h42;
8'd126: desc_rom_r = 8'h00;
8'd127: desc_rom_r = 8'h20;
8'd128: desc_rom_r = 8'h00;
8'd129: desc_rom_r = 8'h44;
8'd130: desc_rom_r = 8'h00;
8'd131: desc_rom_r = 8'h45;
8'd132: desc_rom_r = 8'h00;
8'd133: desc_rom_r = 8'h4d;
8'd134: desc_rom_r = 8'h00;
8'd135: desc_rom_r = 8'h4f;
8'd136: desc_rom_r = 8'h00;
8'd137: desc_rom_r = 8'h20;
8'd138: desc_rom_r = 8'h00;
8'd139: desc_rom_r = 8'h20;
8'd140: desc_rom_r = 8'h00;
8'd141: desc_rom_r = 8'h20;
8'd142: desc_rom_r = 8'h00;
8'd143: desc_rom_r = 8'h20;
8'd144: desc_rom_r = 8'h00;
8'd145: desc_rom_r = 8'h20;
8'd146: desc_rom_r = 8'h00;
8'd147: desc_rom_r = 8'h20;
8'd148: desc_rom_r = 8'h00;
8'd149: desc_rom_r = 8'h0e;
8'd150: desc_rom_r = 8'h03;
8'd151: desc_rom_r = 8'h30;
8'd152: desc_rom_r = 8'h00;
8'd153: desc_rom_r = 8'h30;
8'd154: desc_rom_r = 8'h00;
8'd155: desc_rom_r = 8'h30;
8'd156: desc_rom_r = 8'h00;
8'd157: desc_rom_r = 8'h30;
8'd158: desc_rom_r = 8'h00;
8'd159: desc_rom_r = 8'h30;
8'd160: desc_rom_r = 8'h00;
8'd161: desc_rom_r = 8'h30;
8'd162: desc_rom_r = 8'h00;
8'd163: desc_rom_r = 8'h00;
8'd164: desc_rom_r = 8'hc2;
8'd165: desc_rom_r = 8'h01;
8'd166: desc_rom_r = 8'h00;
8'd167: desc_rom_r = 8'h00;
8'd168: desc_rom_r = 8'h00;
8'd169: desc_rom_r = 8'h08;
default: desc_rom_r = 8'h00;
endcase
end
assign data_o = desc_rom_r;
endmodule |
module xtea(clock, reset, mode, data_in1, data_in2, key_in, data_out1, data_out2, all_done);
parameter s0 = 8'd0, s1 = 8'd1, s2 = 8'd2, s3 = 8'd3, s4 = 8'd4, s5 = 8'd5, s6 = 8'd6, s7 = 8'd7, s8 = 8'd8, s9 = 8'd9, s10 = 8'd10,
s11 = 8'd11, s12 = 8'd12, s13 = 8'd13, s14 = 8'd14, s15 = 8'd15, s16 = 8'd16, s17 = 8'd17;
input clock, reset, mode;
input[31:0] data_in1, data_in2;
input[127:0] key_in;
output[31:0] data_out1, data_out2;
output all_done;
wire clock, reset;
wire[31:0] data_in1, data_in2;
wire[127:0] key_in;
reg all_done, while_flag, modereg;
reg[1:0] selectslice;
reg[7:0] state;
reg[7:0] x;
reg[31:0] data_out1, data_out2, sum, workunit1, workunit2, delta;
always @(posedge clock or posedge reset)
begin
if (reset)
state = s0;
else begin
case (state)
s0: state = s1;
s1: state = s2;
s2: state = s3;
s3: state = while_flag ? s4 : s14;
s4: state = modereg ? s10 : s5;
s5: state = s6;
s6: state = s7;
s7: state = s8;
s8: state = s9;
s9: state = s2;
s10: state = s11;
s11: state = s12;
s12: state = s13;
s13: state = s14;
s14: state = s2;
s15: state = s16;
s16: state = s17;
s17: state = s17;
default: state = 4'bxxxx;
endcase
end
end
always @(posedge clock or posedge reset)
begin
if (reset) begin
data_out1 = 32'h00000000;
data_out2 = 32'h00000000;
x = 8'b00000000;
sum = 32'h00000000;
while_flag = 1'b0;
workunit1 = 32'h00000000;
workunit2 = 32'h00000000;
selectslice = 1'b0;
all_done = 1'b0;
delta = 32'h00000000;
modereg = 1'b0;
end
else begin
case (state)
s1: begin
workunit1 = data_in1;
workunit2 = data_in2;
delta = 32'h9e3779b9;
sum = 32'hc6ef3720;
modereg = mode;
end
s2: if (x < 8'd32) while_flag = 1'b1; else while_flag = 1'b0;
s3: begin
end
s4: begin
end
s5: selectslice = (sum >> 32'd11 & 32'd3);
s6: case (selectslice)
2'b00: workunit2 = workunit2 - (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[127:96]));
2'b01: workunit2 = workunit2 - (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[95:64]));
2'b10: workunit2 = workunit2 - (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[63:32]));
2'b11: workunit2 = workunit2 - (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[31:0]));
default: workunit2 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
endcase
s7: sum = sum - delta;
s8: selectslice = (sum & 32'd3);
s9: begin
case (selectslice)
2'b00: workunit1 = workunit1 - (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[127:96]));
2'b01: workunit1 = workunit1 - (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[95:64]));
2'b10: workunit1 = workunit1 - (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[63:32]));
2'b11: workunit1 = workunit1 - (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[31:0]));
default: workunit1 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
endcase
x = x + 1'b1;
end
s10: selectslice = (sum & 32'd3);
s11: case (selectslice)
2'b00: workunit1 = workunit1 + (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[127:96]));
2'b01: workunit1 = workunit1 + (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[95:64]));
2'b10: workunit1 = workunit1 + (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[63:32]));
2'b11: workunit1 = workunit1 + (((workunit2 << 4 ^ workunit2 >> 5) + workunit2) ^ (sum + key_in[31:0]));
default: workunit1 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
endcase
s12: sum = sum + delta;
s13: selectslice = (sum >> 32'd11 & 32'd3);
s14: begin
case (selectslice)
2'b00: workunit2 = workunit2 + (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[127:96]));
2'b01: workunit2 = workunit2 + (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[95:64]));
2'b10: workunit2 = workunit2 + (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[63:32]));
2'b11: workunit2 = workunit2 + (((workunit1 << 4 ^ workunit1 >> 5) + workunit1) ^ (sum + key_in[31:0]));
default: workunit2 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
endcase
x = x + 1'b1;
end
s15: begin
end
s16: begin
data_out1 = workunit1;
data_out2 = workunit2;
end
s17: all_done = 1'b1;
default: begin
data_out1 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
data_out2 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
end
endcase
end
end
endmodule |
module y_huff(clk, rst, enable,
y11, y12, y13, y14, y15, y16, y17, y18, y21, y22, y23, y24, y25, y26, y27, y28,
y31, y32, y33, y34, y35, y36, y37, y38, y41, y42, y43, y44, y45, y46, y47, y48,
y51, y52, y53, y54, y55, y56, y57, y58, y61, y62, y63, y64, y65, y66, y67, y68,
y71, y72, y73, y74, y75, y76, y77, y78, y81, y82, y83, y84, y85, y86, y87, y88,
jpeg_bitstream, data_ready, output_reg_count, end_of_block_output,
end_of_block_empty);
input clk;
input rst;
input enable;
input [10:0] y11, y12, y13, y14, y15, y16, y17, y18, y21, y22, y23, y24;
input [10:0] y25, y26, y27, y28, y31, y32, y33, y34, y35, y36, y37, y38;
input [10:0] y41, y42, y43, y44, y45, y46, y47, y48, y51, y52, y53, y54;
input [10:0] y55, y56, y57, y58, y61, y62, y63, y64, y65, y66, y67, y68;
input [10:0] y71, y72, y73, y74, y75, y76, y77, y78, y81, y82, y83, y84;
input [10:0] y85, y86, y87, y88;
output [31:0] jpeg_bitstream;
output data_ready;
output [4:0] output_reg_count;
output end_of_block_output;
output end_of_block_empty;
reg [7:0] block_counter;
reg [11:0] y11_amp, y11_1_pos, y11_1_neg, y11_diff;
reg [11:0] y11_previous, y11_1;
reg [10:0] y12_amp, y12_pos, y12_neg;
reg [10:0] y21_pos, y21_neg, y31_pos, y31_neg, y22_pos, y22_neg;
reg [10:0] y13_pos, y13_neg, y14_pos, y14_neg, y15_pos, y15_neg;
reg [10:0] y16_pos, y16_neg, y17_pos, y17_neg, y18_pos, y18_neg;
reg [10:0] y23_pos, y23_neg, y24_pos, y24_neg, y25_pos, y25_neg;
reg [10:0] y26_pos, y26_neg, y27_pos, y27_neg, y28_pos, y28_neg;
reg [10:0] y32_pos, y32_neg;
reg [10:0] y33_pos, y33_neg, y34_pos, y34_neg, y35_pos, y35_neg;
reg [10:0] y36_pos, y36_neg, y37_pos, y37_neg, y38_pos, y38_neg;
reg [10:0] y41_pos, y41_neg, y42_pos, y42_neg;
reg [10:0] y43_pos, y43_neg, y44_pos, y44_neg, y45_pos, y45_neg;
reg [10:0] y46_pos, y46_neg, y47_pos, y47_neg, y48_pos, y48_neg;
reg [10:0] y51_pos, y51_neg, y52_pos, y52_neg;
reg [10:0] y53_pos, y53_neg, y54_pos, y54_neg, y55_pos, y55_neg;
reg [10:0] y56_pos, y56_neg, y57_pos, y57_neg, y58_pos, y58_neg;
reg [10:0] y61_pos, y61_neg, y62_pos, y62_neg;
reg [10:0] y63_pos, y63_neg, y64_pos, y64_neg, y65_pos, y65_neg;
reg [10:0] y66_pos, y66_neg, y67_pos, y67_neg, y68_pos, y68_neg;
reg [10:0] y71_pos, y71_neg, y72_pos, y72_neg;
reg [10:0] y73_pos, y73_neg, y74_pos, y74_neg, y75_pos, y75_neg;
reg [10:0] y76_pos, y76_neg, y77_pos, y77_neg, y78_pos, y78_neg;
reg [10:0] y81_pos, y81_neg, y82_pos, y82_neg;
reg [10:0] y83_pos, y83_neg, y84_pos, y84_neg, y85_pos, y85_neg;
reg [10:0] y86_pos, y86_neg, y87_pos, y87_neg, y88_pos, y88_neg;
reg [3:0] y11_bits_pos, y11_bits_neg, y11_bits, y11_bits_1;
reg [3:0] y12_bits_pos, y12_bits_neg, y12_bits, y12_bits_1;
reg [3:0] y12_bits_2, y12_bits_3;
reg y11_msb, y12_msb, y12_msb_1, data_ready;
reg enable_1, enable_2, enable_3, enable_4, enable_5, enable_6;
reg enable_7, enable_8, enable_9, enable_10, enable_11, enable_12;
reg enable_13, enable_module, enable_latch_7, enable_latch_8;
reg y12_et_zero, rollover, rollover_1, rollover_2, rollover_3;
reg rollover_4, rollover_5, rollover_6, rollover_7;
reg y21_et_zero, y21_msb, y31_et_zero, y31_msb;
reg y22_et_zero, y22_msb, y13_et_zero, y13_msb;
reg y14_et_zero, y14_msb, y15_et_zero, y15_msb;
reg y16_et_zero, y16_msb, y17_et_zero, y17_msb;
reg y18_et_zero, y18_msb;
reg y23_et_zero, y23_msb, y24_et_zero, y24_msb;
reg y25_et_zero, y25_msb, y26_et_zero, y26_msb;
reg y27_et_zero, y27_msb, y28_et_zero, y28_msb;
reg y32_et_zero, y32_msb, y33_et_zero, y33_msb;
reg y34_et_zero, y34_msb, y35_et_zero, y35_msb;
reg y36_et_zero, y36_msb, y37_et_zero, y37_msb;
reg y38_et_zero, y38_msb;
reg y41_et_zero, y41_msb, y42_et_zero, y42_msb;
reg y43_et_zero, y43_msb, y44_et_zero, y44_msb;
reg y45_et_zero, y45_msb, y46_et_zero, y46_msb;
reg y47_et_zero, y47_msb, y48_et_zero, y48_msb;
reg y51_et_zero, y51_msb, y52_et_zero, y52_msb;
reg y53_et_zero, y53_msb, y54_et_zero, y54_msb;
reg y55_et_zero, y55_msb, y56_et_zero, y56_msb;
reg y57_et_zero, y57_msb, y58_et_zero, y58_msb;
reg y61_et_zero, y61_msb, y62_et_zero, y62_msb;
reg y63_et_zero, y63_msb, y64_et_zero, y64_msb;
reg y65_et_zero, y65_msb, y66_et_zero, y66_msb;
reg y67_et_zero, y67_msb, y68_et_zero, y68_msb;
reg y71_et_zero, y71_msb, y72_et_zero, y72_msb;
reg y73_et_zero, y73_msb, y74_et_zero, y74_msb;
reg y75_et_zero, y75_msb, y76_et_zero, y76_msb;
reg y77_et_zero, y77_msb, y78_et_zero, y78_msb;
reg y81_et_zero, y81_msb, y82_et_zero, y82_msb;
reg y83_et_zero, y83_msb, y84_et_zero, y84_msb;
reg y85_et_zero, y85_msb, y86_et_zero, y86_msb;
reg y87_et_zero, y87_msb, y88_et_zero, y88_msb;
reg y12_et_zero_1, y12_et_zero_2, y12_et_zero_3, y12_et_zero_4, y12_et_zero_5;
reg [10:0] y_dc [11:0];
reg [3:0] y_dc_code_length [11:0];
reg [15:0] y_ac [161:0];
reg [4:0] y_ac_code_length [161:0];
reg [7:0] y_ac_run_code [250:0];
reg [10:0] y11_huff, y11_huff_1, y11_huff_2;
reg [15:0] y12_huff, y12_huff_1, y12_huff_2;
reg [3:0] y11_huff_count, y11_huff_shift, y11_huff_shift_1, y11_amp_shift, y12_amp_shift;
reg [3:0] y12_huff_shift, y12_huff_shift_1, zero_run_length, zrl_1, zrl_2, zrl_3;
reg [4:0] y12_huff_count, y12_huff_count_1;
reg [4:0] output_reg_count, y11_output_count, old_orc_1, old_orc_2;
reg [4:0] old_orc_3, old_orc_4, old_orc_5, old_orc_6, y12_oc_1;
reg [4:0] orc_3, orc_4, orc_5, orc_6, orc_7, orc_8;
reg [4:0] y12_output_count;
reg [4:0] y12_edge, y12_edge_1, y12_edge_2, y12_edge_3, y12_edge_4;
reg [31:0] jpeg_bitstream, jpeg_bs, jpeg_bs_1, jpeg_bs_2, jpeg_bs_3, jpeg_bs_4, jpeg_bs_5;
reg [31:0] jpeg_y12_bs, jpeg_y12_bs_1, jpeg_y12_bs_2, jpeg_y12_bs_3, jpeg_y12_bs_4;
reg [31:0] jpeg_ro_bs, jpeg_ro_bs_1, jpeg_ro_bs_2, jpeg_ro_bs_3, jpeg_ro_bs_4;
reg [21:0] y11_jpeg_lsbs_3;
reg [10:0] y11_jpeg_lsbs, y11_jpeg_lsbs_1, y11_jpeg_lsbs_2;
reg [9:0] y12_jpeg_lsbs, y12_jpeg_lsbs_1, y12_jpeg_lsbs_2, y12_jpeg_lsbs_3;
reg [25:0] y11_jpeg_bits, y11_jpeg_bits_1, y12_jpeg_bits, y12_jpeg_lsbs_4;
reg [7:0] y12_code_entry;
reg third_8_all_0s, fourth_8_all_0s, fifth_8_all_0s, sixth_8_all_0s, seventh_8_all_0s;
reg eighth_8_all_0s, end_of_block, code_15_0, zrl_et_15, end_of_block_output;
reg end_of_block_empty;
wire [7:0] code_index = { zrl_2, y12_bits };
always @(posedge clk)
begin
if (rst) begin
third_8_all_0s <= 0; fourth_8_all_0s <= 0;
fifth_8_all_0s <= 0; sixth_8_all_0s <= 0; seventh_8_all_0s <= 0;
eighth_8_all_0s <= 0;
end
else if (enable_1) begin
third_8_all_0s <= y25_et_zero & y34_et_zero & y43_et_zero & y52_et_zero
& y61_et_zero & y71_et_zero & y62_et_zero & y53_et_zero;
fourth_8_all_0s <= y44_et_zero & y35_et_zero & y26_et_zero & y17_et_zero
& y18_et_zero & y27_et_zero & y36_et_zero & y45_et_zero;
fifth_8_all_0s <= y54_et_zero & y63_et_zero & y72_et_zero & y81_et_zero
& y82_et_zero & y73_et_zero & y64_et_zero & y55_et_zero;
sixth_8_all_0s <= y46_et_zero & y37_et_zero & y28_et_zero & y38_et_zero
& y47_et_zero & y56_et_zero & y65_et_zero & y74_et_zero;
seventh_8_all_0s <= y83_et_zero & y84_et_zero & y75_et_zero & y66_et_zero
& y57_et_zero & y48_et_zero & y58_et_zero & y67_et_zero;
eighth_8_all_0s <= y76_et_zero & y85_et_zero & y86_et_zero & y77_et_zero
& y68_et_zero & y78_et_zero & y87_et_zero & y88_et_zero;
end
end
always @(posedge clk)
begin
if (rst)
end_of_block <= 0;
else if (enable)
end_of_block <= 0;
else if (enable_module & block_counter < 32)
end_of_block <= third_8_all_0s & fourth_8_all_0s & fifth_8_all_0s
& sixth_8_all_0s & seventh_8_all_0s & eighth_8_all_0s;
else if (enable_module & block_counter < 48)
end_of_block <= fifth_8_all_0s & sixth_8_all_0s & seventh_8_all_0s
& eighth_8_all_0s;
else if (enable_module & block_counter <= 64)
end_of_block <= seventh_8_all_0s & eighth_8_all_0s;
else if (enable_module & block_counter > 64)
end_of_block <= 1;
end
always @(posedge clk)
begin
if (rst) begin
block_counter <= 0;
end
else if (enable) begin
block_counter <= 0;
end
else if (enable_module) begin
block_counter <= block_counter + 1;
end
end
always @(posedge clk)
begin
if (rst) begin
output_reg_count <= 0;
end
else if (end_of_block_output) begin
output_reg_count <= 0;
end
else if (enable_6) begin
output_reg_count <= output_reg_count + y11_output_count;
end
else if (enable_latch_7) begin
output_reg_count <= output_reg_count + y12_oc_1;
end
end
always @(posedge clk)
begin
if (rst) begin
old_orc_1 <= 0;
end
else if (end_of_block_output) begin
old_orc_1 <= 0;
end
else if (enable_module) begin
old_orc_1 <= output_reg_count;
end
end
always @(posedge clk)
begin
if (rst) begin
rollover <= 0; rollover_1 <= 0; rollover_2 <= 0;
rollover_3 <= 0; rollover_4 <= 0; rollover_5 <= 0;
rollover_6 <= 0; rollover_7 <= 0;
old_orc_2 <= 0;
orc_3 <= 0; orc_4 <= 0; orc_5 <= 0; orc_6 <= 0;
orc_7 <= 0; orc_8 <= 0; data_ready <= 0;
end_of_block_output <= 0; end_of_block_empty <= 0;
end
else if (enable_module) begin
rollover <= (old_orc_1 > output_reg_count);
rollover_1 <= rollover;
rollover_2 <= rollover_1;
rollover_3 <= rollover_2;
rollover_4 <= rollover_3;
rollover_5 <= rollover_4;
rollover_6 <= rollover_5;
rollover_7 <= rollover_6;
old_orc_2 <= old_orc_1;
orc_3 <= old_orc_2;
orc_4 <= orc_3; orc_5 <= orc_4;
orc_6 <= orc_5; orc_7 <= orc_6;
orc_8 <= orc_7;
data_ready <= rollover_6 | block_counter == 77;
end_of_block_output <= block_counter == 77;
end_of_block_empty <= rollover_7 & block_counter == 77 & output_reg_count == 0;
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs_5 <= 0;
end
else if (enable_module) begin
jpeg_bs_5[31] <= (rollover_6 & orc_7 > 0) ? jpeg_ro_bs_4[31] : jpeg_bs_4[31];
jpeg_bs_5[30] <= (rollover_6 & orc_7 > 1) ? jpeg_ro_bs_4[30] : jpeg_bs_4[30];
jpeg_bs_5[29] <= (rollover_6 & orc_7 > 2) ? jpeg_ro_bs_4[29] : jpeg_bs_4[29];
jpeg_bs_5[28] <= (rollover_6 & orc_7 > 3) ? jpeg_ro_bs_4[28] : jpeg_bs_4[28];
jpeg_bs_5[27] <= (rollover_6 & orc_7 > 4) ? jpeg_ro_bs_4[27] : jpeg_bs_4[27];
jpeg_bs_5[26] <= (rollover_6 & orc_7 > 5) ? jpeg_ro_bs_4[26] : jpeg_bs_4[26];
jpeg_bs_5[25] <= (rollover_6 & orc_7 > 6) ? jpeg_ro_bs_4[25] : jpeg_bs_4[25];
jpeg_bs_5[24] <= (rollover_6 & orc_7 > 7) ? jpeg_ro_bs_4[24] : jpeg_bs_4[24];
jpeg_bs_5[23] <= (rollover_6 & orc_7 > 8) ? jpeg_ro_bs_4[23] : jpeg_bs_4[23];
jpeg_bs_5[22] <= (rollover_6 & orc_7 > 9) ? jpeg_ro_bs_4[22] : jpeg_bs_4[22];
jpeg_bs_5[21] <= (rollover_6 & orc_7 > 10) ? jpeg_ro_bs_4[21] : jpeg_bs_4[21];
jpeg_bs_5[20] <= (rollover_6 & orc_7 > 11) ? jpeg_ro_bs_4[20] : jpeg_bs_4[20];
jpeg_bs_5[19] <= (rollover_6 & orc_7 > 12) ? jpeg_ro_bs_4[19] : jpeg_bs_4[19];
jpeg_bs_5[18] <= (rollover_6 & orc_7 > 13) ? jpeg_ro_bs_4[18] : jpeg_bs_4[18];
jpeg_bs_5[17] <= (rollover_6 & orc_7 > 14) ? jpeg_ro_bs_4[17] : jpeg_bs_4[17];
jpeg_bs_5[16] <= (rollover_6 & orc_7 > 15) ? jpeg_ro_bs_4[16] : jpeg_bs_4[16];
jpeg_bs_5[15] <= (rollover_6 & orc_7 > 16) ? jpeg_ro_bs_4[15] : jpeg_bs_4[15];
jpeg_bs_5[14] <= (rollover_6 & orc_7 > 17) ? jpeg_ro_bs_4[14] : jpeg_bs_4[14];
jpeg_bs_5[13] <= (rollover_6 & orc_7 > 18) ? jpeg_ro_bs_4[13] : jpeg_bs_4[13];
jpeg_bs_5[12] <= (rollover_6 & orc_7 > 19) ? jpeg_ro_bs_4[12] : jpeg_bs_4[12];
jpeg_bs_5[11] <= (rollover_6 & orc_7 > 20) ? jpeg_ro_bs_4[11] : jpeg_bs_4[11];
jpeg_bs_5[10] <= (rollover_6 & orc_7 > 21) ? jpeg_ro_bs_4[10] : jpeg_bs_4[10];
jpeg_bs_5[9] <= (rollover_6 & orc_7 > 22) ? jpeg_ro_bs_4[9] : jpeg_bs_4[9];
jpeg_bs_5[8] <= (rollover_6 & orc_7 > 23) ? jpeg_ro_bs_4[8] : jpeg_bs_4[8];
jpeg_bs_5[7] <= (rollover_6 & orc_7 > 24) ? jpeg_ro_bs_4[7] : jpeg_bs_4[7];
jpeg_bs_5[6] <= (rollover_6 & orc_7 > 25) ? jpeg_ro_bs_4[6] : jpeg_bs_4[6];
jpeg_bs_5[5] <= (rollover_6 & orc_7 > 26) ? jpeg_ro_bs_4[5] : jpeg_bs_4[5];
jpeg_bs_5[4] <= (rollover_6 & orc_7 > 27) ? jpeg_ro_bs_4[4] : jpeg_bs_4[4];
jpeg_bs_5[3] <= (rollover_6 & orc_7 > 28) ? jpeg_ro_bs_4[3] : jpeg_bs_4[3];
jpeg_bs_5[2] <= (rollover_6 & orc_7 > 29) ? jpeg_ro_bs_4[2] : jpeg_bs_4[2];
jpeg_bs_5[1] <= (rollover_6 & orc_7 > 30) ? jpeg_ro_bs_4[1] : jpeg_bs_4[1];
jpeg_bs_5[0] <= jpeg_bs_4[0];
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs_4 <= 0; jpeg_ro_bs_4 <= 0;
end
else if (enable_module) begin
jpeg_bs_4 <= (old_orc_6 == 1) ? jpeg_bs_3 >> 1 : jpeg_bs_3;
jpeg_ro_bs_4 <= (y12_edge_4 <= 1) ? jpeg_ro_bs_3 << 1 : jpeg_ro_bs_3;
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs_3 <= 0; old_orc_6 <= 0; jpeg_ro_bs_3 <= 0;
y12_edge_4 <= 0;
end
else if (enable_module) begin
jpeg_bs_3 <= (old_orc_5 >= 2) ? jpeg_bs_2 >> 2 : jpeg_bs_2;
old_orc_6 <= (old_orc_5 >= 2) ? old_orc_5 - 2 : old_orc_5;
jpeg_ro_bs_3 <= (y12_edge_3 <= 2) ? jpeg_ro_bs_2 << 2 : jpeg_ro_bs_2;
y12_edge_4 <= (y12_edge_3 <= 2) ? y12_edge_3 : y12_edge_3 - 2;
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs_2 <= 0; old_orc_5 <= 0; jpeg_ro_bs_2 <= 0;
y12_edge_3 <= 0;
end
else if (enable_module) begin
jpeg_bs_2 <= (old_orc_4 >= 4) ? jpeg_bs_1 >> 4 : jpeg_bs_1;
old_orc_5 <= (old_orc_4 >= 4) ? old_orc_4 - 4 : old_orc_4;
jpeg_ro_bs_2 <= (y12_edge_2 <= 4) ? jpeg_ro_bs_1 << 4 : jpeg_ro_bs_1;
y12_edge_3 <= (y12_edge_2 <= 4) ? y12_edge_2 : y12_edge_2 - 4;
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs_1 <= 0; old_orc_4 <= 0; jpeg_ro_bs_1 <= 0;
y12_edge_2 <= 0;
end
else if (enable_module) begin
jpeg_bs_1 <= (old_orc_3 >= 8) ? jpeg_bs >> 8 : jpeg_bs;
old_orc_4 <= (old_orc_3 >= 8) ? old_orc_3 - 8 : old_orc_3;
jpeg_ro_bs_1 <= (y12_edge_1 <= 8) ? jpeg_ro_bs << 8 : jpeg_ro_bs;
y12_edge_2 <= (y12_edge_1 <= 8) ? y12_edge_1 : y12_edge_1 - 8;
end
end
always @(posedge clk)
begin
if (rst) begin
jpeg_bs <= 0; old_orc_3 <= 0; jpeg_ro_bs <= 0;
y12_edge_1 <= 0; y11_jpeg_bits_1 <= 0;
end
else if (enable_module) begin
jpeg_bs <= (old_orc_2 >= 16) ? y11_jpeg_bits >> 10 : y11_jpeg_bits << 6;
old_orc_3 <= (old_orc_2 >= 16) ? old_orc_2 - 16 : old_orc_2;
jpeg_ro_bs <= (y12_edge <= 16) ? y11_jpeg_bits_1 << 16 : y11_jpeg_bits_1;
y12_edge_1 <= (y12_edge <= 16) ? y12_edge : y12_edge - 16;
y11_jpeg_bits_1 <= y11_jpeg_bits;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_jpeg_bits <= 0; y12_edge <= 0;
end
else if (enable_module) begin
y12_jpeg_bits[25] <= (y12_huff_shift_1 >= 16) ? y12_jpeg_lsbs_4[25] : y12_huff_2[15];
y12_jpeg_bits[24] <= (y12_huff_shift_1 >= 15) ? y12_jpeg_lsbs_4[24] : y12_huff_2[14];
y12_jpeg_bits[23] <= (y12_huff_shift_1 >= 14) ? y12_jpeg_lsbs_4[23] : y12_huff_2[13];
y12_jpeg_bits[22] <= (y12_huff_shift_1 >= 13) ? y12_jpeg_lsbs_4[22] : y12_huff_2[12];
y12_jpeg_bits[21] <= (y12_huff_shift_1 >= 12) ? y12_jpeg_lsbs_4[21] : y12_huff_2[11];
y12_jpeg_bits[20] <= (y12_huff_shift_1 >= 11) ? y12_jpeg_lsbs_4[20] : y12_huff_2[10];
y12_jpeg_bits[19] <= (y12_huff_shift_1 >= 10) ? y12_jpeg_lsbs_4[19] : y12_huff_2[9];
y12_jpeg_bits[18] <= (y12_huff_shift_1 >= 9) ? y12_jpeg_lsbs_4[18] : y12_huff_2[8];
y12_jpeg_bits[17] <= (y12_huff_shift_1 >= 8) ? y12_jpeg_lsbs_4[17] : y12_huff_2[7];
y12_jpeg_bits[16] <= (y12_huff_shift_1 >= 7) ? y12_jpeg_lsbs_4[16] : y12_huff_2[6];
y12_jpeg_bits[15] <= (y12_huff_shift_1 >= 6) ? y12_jpeg_lsbs_4[15] : y12_huff_2[5];
y12_jpeg_bits[14] <= (y12_huff_shift_1 >= 5) ? y12_jpeg_lsbs_4[14] : y12_huff_2[4];
y12_jpeg_bits[13] <= (y12_huff_shift_1 >= 4) ? y12_jpeg_lsbs_4[13] : y12_huff_2[3];
y12_jpeg_bits[12] <= (y12_huff_shift_1 >= 3) ? y12_jpeg_lsbs_4[12] : y12_huff_2[2];
y12_jpeg_bits[11] <= (y12_huff_shift_1 >= 2) ? y12_jpeg_lsbs_4[11] : y12_huff_2[1];
y12_jpeg_bits[10] <= (y12_huff_shift_1 >= 1) ? y12_jpeg_lsbs_4[10] : y12_huff_2[0];
y12_jpeg_bits[9:0] <= y12_jpeg_lsbs_4[9:0];
y12_edge <= old_orc_2 + 26; end
end
always @(posedge clk)
begin
if (rst) begin
y11_jpeg_bits <= 0;
end
else if (enable_7) begin
y11_jpeg_bits[25] <= (y11_huff_shift_1 >= 11) ? y11_jpeg_lsbs_3[21] : y11_huff_2[10];
y11_jpeg_bits[24] <= (y11_huff_shift_1 >= 10) ? y11_jpeg_lsbs_3[20] : y11_huff_2[9];
y11_jpeg_bits[23] <= (y11_huff_shift_1 >= 9) ? y11_jpeg_lsbs_3[19] : y11_huff_2[8];
y11_jpeg_bits[22] <= (y11_huff_shift_1 >= 8) ? y11_jpeg_lsbs_3[18] : y11_huff_2[7];
y11_jpeg_bits[21] <= (y11_huff_shift_1 >= 7) ? y11_jpeg_lsbs_3[17] : y11_huff_2[6];
y11_jpeg_bits[20] <= (y11_huff_shift_1 >= 6) ? y11_jpeg_lsbs_3[16] : y11_huff_2[5];
y11_jpeg_bits[19] <= (y11_huff_shift_1 >= 5) ? y11_jpeg_lsbs_3[15] : y11_huff_2[4];
y11_jpeg_bits[18] <= (y11_huff_shift_1 >= 4) ? y11_jpeg_lsbs_3[14] : y11_huff_2[3];
y11_jpeg_bits[17] <= (y11_huff_shift_1 >= 3) ? y11_jpeg_lsbs_3[13] : y11_huff_2[2];
y11_jpeg_bits[16] <= (y11_huff_shift_1 >= 2) ? y11_jpeg_lsbs_3[12] : y11_huff_2[1];
y11_jpeg_bits[15] <= (y11_huff_shift_1 >= 1) ? y11_jpeg_lsbs_3[11] : y11_huff_2[0];
y11_jpeg_bits[14:4] <= y11_jpeg_lsbs_3[10:0];
end
else if (enable_latch_8) begin
y11_jpeg_bits <= y12_jpeg_bits;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_oc_1 <= 0; y12_jpeg_lsbs_4 <= 0;
y12_huff_2 <= 0; y12_huff_shift_1 <= 0;
end
else if (enable_module) begin
y12_oc_1 <= (y12_et_zero_5 & !code_15_0 & block_counter != 67) ? 0 :
y12_bits_3 + y12_huff_count_1;
y12_jpeg_lsbs_4 <= y12_jpeg_lsbs_3 << y12_huff_shift;
y12_huff_2 <= y12_huff_1;
y12_huff_shift_1 <= y12_huff_shift;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_jpeg_lsbs_3 <= 0; y11_huff_2 <= 0;
y11_huff_shift_1 <= 0;
end
else if (enable_6) begin
y11_jpeg_lsbs_3 <= y11_jpeg_lsbs_2 << y11_huff_shift;
y11_huff_2 <= y11_huff_1;
y11_huff_shift_1 <= y11_huff_shift;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_huff_shift <= 0;
y12_huff_1 <= 0; y12_jpeg_lsbs_3 <= 0; y12_bits_3 <= 0;
y12_huff_count_1 <= 0; y12_et_zero_5 <= 0; code_15_0 <= 0;
end
else if (enable_module) begin
y12_huff_shift <= 16 - y12_huff_count;
y12_huff_1 <= y12_huff;
y12_jpeg_lsbs_3 <= y12_jpeg_lsbs_2;
y12_bits_3 <= y12_bits_2;
y12_huff_count_1 <= y12_huff_count;
y12_et_zero_5 <= y12_et_zero_4;
code_15_0 <= zrl_et_15 & !end_of_block;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_output_count <= 0; y11_jpeg_lsbs_2 <= 0; y11_huff_shift <= 0;
y11_huff_1 <= 0;
end
else if (enable_5) begin
y11_output_count <= y11_bits_1 + y11_huff_count;
y11_jpeg_lsbs_2 <= y11_jpeg_lsbs_1 << y11_amp_shift;
y11_huff_shift <= 11 - y11_huff_count;
y11_huff_1 <= y11_huff;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_jpeg_lsbs_2 <= 0;
y12_huff <= 0; y12_huff_count <= 0; y12_bits_2 <= 0;
y12_et_zero_4 <= 0; zrl_et_15 <= 0; zrl_3 <= 0;
end
else if (enable_module) begin
y12_jpeg_lsbs_2 <= y12_jpeg_lsbs_1 << y12_amp_shift;
y12_huff <= y_ac[y12_code_entry];
y12_huff_count <= y_ac_code_length[y12_code_entry];
y12_bits_2 <= y12_bits_1;
y12_et_zero_4 <= y12_et_zero_3;
zrl_et_15 <= zrl_3 == 15;
zrl_3 <= zrl_2;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_huff <= 0; y11_huff_count <= 0; y11_amp_shift <= 0;
y11_jpeg_lsbs_1 <= 0; y11_bits_1 <= 0;
end
else if (enable_4) begin
y11_huff[10:0] <= y_dc[y11_bits];
y11_huff_count <= y_dc_code_length[y11_bits];
y11_amp_shift <= 11 - y11_bits;
y11_jpeg_lsbs_1 <= y11_jpeg_lsbs;
y11_bits_1 <= y11_bits;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_code_entry <= 0; y12_jpeg_lsbs_1 <= 0; y12_amp_shift <= 0;
y12_bits_1 <= 0; y12_et_zero_3 <= 0; zrl_2 <= 0;
end
else if (enable_module) begin
y12_code_entry <= y_ac_run_code[code_index];
y12_jpeg_lsbs_1 <= y12_jpeg_lsbs;
y12_amp_shift <= 10 - y12_bits;
y12_bits_1 <= y12_bits;
y12_et_zero_3 <= y12_et_zero_2;
zrl_2 <= zrl_1;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_bits <= 0; y11_jpeg_lsbs <= 0;
end
else if (enable_3) begin
y11_bits <= y11_msb ? y11_bits_neg : y11_bits_pos;
y11_jpeg_lsbs <= y11_amp[10:0]; end
end
always @(posedge clk)
begin
if (rst) begin
y12_bits <= 0; y12_jpeg_lsbs <= 0; zrl_1 <= 0;
y12_et_zero_2 <= 0;
end
else if (enable_module) begin
y12_bits <= y12_msb_1 ? y12_bits_neg : y12_bits_pos;
y12_jpeg_lsbs <= y12_amp[9:0]; zrl_1 <= block_counter == 62 & y12_et_zero ? 0 : zero_run_length;
y12_et_zero_2 <= y12_et_zero_1;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_amp <= 0;
end
else if (enable_2) begin
y11_amp <= y11_msb ? y11_1_neg : y11_1_pos;
end
end
always @(posedge clk)
begin
if (rst)
zero_run_length <= 0;
else if (enable)
zero_run_length <= 0;
else if (enable_module)
zero_run_length <= y12_et_zero ? zero_run_length + 1: 0;
end
always @(posedge clk)
begin
if (rst) begin
y12_amp <= 0;
y12_et_zero_1 <= 0; y12_msb_1 <= 0;
end
else if (enable_module) begin
y12_amp <= y12_msb ? y12_neg : y12_pos;
y12_et_zero_1 <= y12_et_zero;
y12_msb_1 <= y12_msb;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_1_pos <= 0; y11_1_neg <= 0; y11_msb <= 0;
y11_previous <= 0;
end
else if (enable_1) begin
y11_1_pos <= y11_diff;
y11_1_neg <= y11_diff - 1;
y11_msb <= y11_diff[11];
y11_previous <= y11_1;
end
end
always @(posedge clk)
begin
if (rst) begin
y12_pos <= 0; y12_neg <= 0; y12_msb <= 0; y12_et_zero <= 0;
y13_pos <= 0; y13_neg <= 0; y13_msb <= 0; y13_et_zero <= 0;
y14_pos <= 0; y14_neg <= 0; y14_msb <= 0; y14_et_zero <= 0;
y15_pos <= 0; y15_neg <= 0; y15_msb <= 0; y15_et_zero <= 0;
y16_pos <= 0; y16_neg <= 0; y16_msb <= 0; y16_et_zero <= 0;
y17_pos <= 0; y17_neg <= 0; y17_msb <= 0; y17_et_zero <= 0;
y18_pos <= 0; y18_neg <= 0; y18_msb <= 0; y18_et_zero <= 0;
y21_pos <= 0; y21_neg <= 0; y21_msb <= 0; y21_et_zero <= 0;
y22_pos <= 0; y22_neg <= 0; y22_msb <= 0; y22_et_zero <= 0;
y23_pos <= 0; y23_neg <= 0; y23_msb <= 0; y23_et_zero <= 0;
y24_pos <= 0; y24_neg <= 0; y24_msb <= 0; y24_et_zero <= 0;
y25_pos <= 0; y25_neg <= 0; y25_msb <= 0; y25_et_zero <= 0;
y26_pos <= 0; y26_neg <= 0; y26_msb <= 0; y26_et_zero <= 0;
y27_pos <= 0; y27_neg <= 0; y27_msb <= 0; y27_et_zero <= 0;
y28_pos <= 0; y28_neg <= 0; y28_msb <= 0; y28_et_zero <= 0;
y31_pos <= 0; y31_neg <= 0; y31_msb <= 0; y31_et_zero <= 0;
y32_pos <= 0; y32_neg <= 0; y32_msb <= 0; y32_et_zero <= 0;
y33_pos <= 0; y33_neg <= 0; y33_msb <= 0; y33_et_zero <= 0;
y34_pos <= 0; y34_neg <= 0; y34_msb <= 0; y34_et_zero <= 0;
y35_pos <= 0; y35_neg <= 0; y35_msb <= 0; y35_et_zero <= 0;
y36_pos <= 0; y36_neg <= 0; y36_msb <= 0; y36_et_zero <= 0;
y37_pos <= 0; y37_neg <= 0; y37_msb <= 0; y37_et_zero <= 0;
y38_pos <= 0; y38_neg <= 0; y38_msb <= 0; y38_et_zero <= 0;
y41_pos <= 0; y41_neg <= 0; y41_msb <= 0; y41_et_zero <= 0;
y42_pos <= 0; y42_neg <= 0; y42_msb <= 0; y42_et_zero <= 0;
y43_pos <= 0; y43_neg <= 0; y43_msb <= 0; y43_et_zero <= 0;
y44_pos <= 0; y44_neg <= 0; y44_msb <= 0; y44_et_zero <= 0;
y45_pos <= 0; y45_neg <= 0; y45_msb <= 0; y45_et_zero <= 0;
y46_pos <= 0; y46_neg <= 0; y46_msb <= 0; y46_et_zero <= 0;
y47_pos <= 0; y47_neg <= 0; y47_msb <= 0; y47_et_zero <= 0;
y48_pos <= 0; y48_neg <= 0; y48_msb <= 0; y48_et_zero <= 0;
y51_pos <= 0; y51_neg <= 0; y51_msb <= 0; y51_et_zero <= 0;
y52_pos <= 0; y52_neg <= 0; y52_msb <= 0; y52_et_zero <= 0;
y53_pos <= 0; y53_neg <= 0; y53_msb <= 0; y53_et_zero <= 0;
y54_pos <= 0; y54_neg <= 0; y54_msb <= 0; y54_et_zero <= 0;
y55_pos <= 0; y55_neg <= 0; y55_msb <= 0; y55_et_zero <= 0;
y56_pos <= 0; y56_neg <= 0; y56_msb <= 0; y56_et_zero <= 0;
y57_pos <= 0; y57_neg <= 0; y57_msb <= 0; y57_et_zero <= 0;
y58_pos <= 0; y58_neg <= 0; y58_msb <= 0; y58_et_zero <= 0;
y61_pos <= 0; y61_neg <= 0; y61_msb <= 0; y61_et_zero <= 0;
y62_pos <= 0; y62_neg <= 0; y62_msb <= 0; y62_et_zero <= 0;
y63_pos <= 0; y63_neg <= 0; y63_msb <= 0; y63_et_zero <= 0;
y64_pos <= 0; y64_neg <= 0; y64_msb <= 0; y64_et_zero <= 0;
y65_pos <= 0; y65_neg <= 0; y65_msb <= 0; y65_et_zero <= 0;
y66_pos <= 0; y66_neg <= 0; y66_msb <= 0; y66_et_zero <= 0;
y67_pos <= 0; y67_neg <= 0; y67_msb <= 0; y67_et_zero <= 0;
y68_pos <= 0; y68_neg <= 0; y68_msb <= 0; y68_et_zero <= 0;
y71_pos <= 0; y71_neg <= 0; y71_msb <= 0; y71_et_zero <= 0;
y72_pos <= 0; y72_neg <= 0; y72_msb <= 0; y72_et_zero <= 0;
y73_pos <= 0; y73_neg <= 0; y73_msb <= 0; y73_et_zero <= 0;
y74_pos <= 0; y74_neg <= 0; y74_msb <= 0; y74_et_zero <= 0;
y75_pos <= 0; y75_neg <= 0; y75_msb <= 0; y75_et_zero <= 0;
y76_pos <= 0; y76_neg <= 0; y76_msb <= 0; y76_et_zero <= 0;
y77_pos <= 0; y77_neg <= 0; y77_msb <= 0; y77_et_zero <= 0;
y78_pos <= 0; y78_neg <= 0; y78_msb <= 0; y78_et_zero <= 0;
y81_pos <= 0; y81_neg <= 0; y81_msb <= 0; y81_et_zero <= 0;
y82_pos <= 0; y82_neg <= 0; y82_msb <= 0; y82_et_zero <= 0;
y83_pos <= 0; y83_neg <= 0; y83_msb <= 0; y83_et_zero <= 0;
y84_pos <= 0; y84_neg <= 0; y84_msb <= 0; y84_et_zero <= 0;
y85_pos <= 0; y85_neg <= 0; y85_msb <= 0; y85_et_zero <= 0;
y86_pos <= 0; y86_neg <= 0; y86_msb <= 0; y86_et_zero <= 0;
y87_pos <= 0; y87_neg <= 0; y87_msb <= 0; y87_et_zero <= 0;
y88_pos <= 0; y88_neg <= 0; y88_msb <= 0; y88_et_zero <= 0;
end
else if (enable) begin
y12_pos <= y12;
y12_neg <= y12 - 1;
y12_msb <= y12[10];
y12_et_zero <= !(|y12);
y13_pos <= y13;
y13_neg <= y13 - 1;
y13_msb <= y13[10];
y13_et_zero <= !(|y13);
y14_pos <= y14;
y14_neg <= y14 - 1;
y14_msb <= y14[10];
y14_et_zero <= !(|y14);
y15_pos <= y15;
y15_neg <= y15 - 1;
y15_msb <= y15[10];
y15_et_zero <= !(|y15);
y16_pos <= y16;
y16_neg <= y16 - 1;
y16_msb <= y16[10];
y16_et_zero <= !(|y16);
y17_pos <= y17;
y17_neg <= y17 - 1;
y17_msb <= y17[10];
y17_et_zero <= !(|y17);
y18_pos <= y18;
y18_neg <= y18 - 1;
y18_msb <= y18[10];
y18_et_zero <= !(|y18);
y21_pos <= y21;
y21_neg <= y21 - 1;
y21_msb <= y21[10];
y21_et_zero <= !(|y21);
y22_pos <= y22;
y22_neg <= y22 - 1;
y22_msb <= y22[10];
y22_et_zero <= !(|y22);
y23_pos <= y23;
y23_neg <= y23 - 1;
y23_msb <= y23[10];
y23_et_zero <= !(|y23);
y24_pos <= y24;
y24_neg <= y24 - 1;
y24_msb <= y24[10];
y24_et_zero <= !(|y24);
y25_pos <= y25;
y25_neg <= y25 - 1;
y25_msb <= y25[10];
y25_et_zero <= !(|y25);
y26_pos <= y26;
y26_neg <= y26 - 1;
y26_msb <= y26[10];
y26_et_zero <= !(|y26);
y27_pos <= y27;
y27_neg <= y27 - 1;
y27_msb <= y27[10];
y27_et_zero <= !(|y27);
y28_pos <= y28;
y28_neg <= y28 - 1;
y28_msb <= y28[10];
y28_et_zero <= !(|y28);
y31_pos <= y31;
y31_neg <= y31 - 1;
y31_msb <= y31[10];
y31_et_zero <= !(|y31);
y32_pos <= y32;
y32_neg <= y32 - 1;
y32_msb <= y32[10];
y32_et_zero <= !(|y32);
y33_pos <= y33;
y33_neg <= y33 - 1;
y33_msb <= y33[10];
y33_et_zero <= !(|y33);
y34_pos <= y34;
y34_neg <= y34 - 1;
y34_msb <= y34[10];
y34_et_zero <= !(|y34);
y35_pos <= y35;
y35_neg <= y35 - 1;
y35_msb <= y35[10];
y35_et_zero <= !(|y35);
y36_pos <= y36;
y36_neg <= y36 - 1;
y36_msb <= y36[10];
y36_et_zero <= !(|y36);
y37_pos <= y37;
y37_neg <= y37 - 1;
y37_msb <= y37[10];
y37_et_zero <= !(|y37);
y38_pos <= y38;
y38_neg <= y38 - 1;
y38_msb <= y38[10];
y38_et_zero <= !(|y38);
y41_pos <= y41;
y41_neg <= y41 - 1;
y41_msb <= y41[10];
y41_et_zero <= !(|y41);
y42_pos <= y42;
y42_neg <= y42 - 1;
y42_msb <= y42[10];
y42_et_zero <= !(|y42);
y43_pos <= y43;
y43_neg <= y43 - 1;
y43_msb <= y43[10];
y43_et_zero <= !(|y43);
y44_pos <= y44;
y44_neg <= y44 - 1;
y44_msb <= y44[10];
y44_et_zero <= !(|y44);
y45_pos <= y45;
y45_neg <= y45 - 1;
y45_msb <= y45[10];
y45_et_zero <= !(|y45);
y46_pos <= y46;
y46_neg <= y46 - 1;
y46_msb <= y46[10];
y46_et_zero <= !(|y46);
y47_pos <= y47;
y47_neg <= y47 - 1;
y47_msb <= y47[10];
y47_et_zero <= !(|y47);
y48_pos <= y48;
y48_neg <= y48 - 1;
y48_msb <= y48[10];
y48_et_zero <= !(|y48);
y51_pos <= y51;
y51_neg <= y51 - 1;
y51_msb <= y51[10];
y51_et_zero <= !(|y51);
y52_pos <= y52;
y52_neg <= y52 - 1;
y52_msb <= y52[10];
y52_et_zero <= !(|y52);
y53_pos <= y53;
y53_neg <= y53 - 1;
y53_msb <= y53[10];
y53_et_zero <= !(|y53);
y54_pos <= y54;
y54_neg <= y54 - 1;
y54_msb <= y54[10];
y54_et_zero <= !(|y54);
y55_pos <= y55;
y55_neg <= y55 - 1;
y55_msb <= y55[10];
y55_et_zero <= !(|y55);
y56_pos <= y56;
y56_neg <= y56 - 1;
y56_msb <= y56[10];
y56_et_zero <= !(|y56);
y57_pos <= y57;
y57_neg <= y57 - 1;
y57_msb <= y57[10];
y57_et_zero <= !(|y57);
y58_pos <= y58;
y58_neg <= y58 - 1;
y58_msb <= y58[10];
y58_et_zero <= !(|y58);
y61_pos <= y61;
y61_neg <= y61 - 1;
y61_msb <= y61[10];
y61_et_zero <= !(|y61);
y62_pos <= y62;
y62_neg <= y62 - 1;
y62_msb <= y62[10];
y62_et_zero <= !(|y62);
y63_pos <= y63;
y63_neg <= y63 - 1;
y63_msb <= y63[10];
y63_et_zero <= !(|y63);
y64_pos <= y64;
y64_neg <= y64 - 1;
y64_msb <= y64[10];
y64_et_zero <= !(|y64);
y65_pos <= y65;
y65_neg <= y65 - 1;
y65_msb <= y65[10];
y65_et_zero <= !(|y65);
y66_pos <= y66;
y66_neg <= y66 - 1;
y66_msb <= y66[10];
y66_et_zero <= !(|y66);
y67_pos <= y67;
y67_neg <= y67 - 1;
y67_msb <= y67[10];
y67_et_zero <= !(|y67);
y68_pos <= y68;
y68_neg <= y68 - 1;
y68_msb <= y68[10];
y68_et_zero <= !(|y68);
y71_pos <= y71;
y71_neg <= y71 - 1;
y71_msb <= y71[10];
y71_et_zero <= !(|y71);
y72_pos <= y72;
y72_neg <= y72 - 1;
y72_msb <= y72[10];
y72_et_zero <= !(|y72);
y73_pos <= y73;
y73_neg <= y73 - 1;
y73_msb <= y73[10];
y73_et_zero <= !(|y73);
y74_pos <= y74;
y74_neg <= y74 - 1;
y74_msb <= y74[10];
y74_et_zero <= !(|y74);
y75_pos <= y75;
y75_neg <= y75 - 1;
y75_msb <= y75[10];
y75_et_zero <= !(|y75);
y76_pos <= y76;
y76_neg <= y76 - 1;
y76_msb <= y76[10];
y76_et_zero <= !(|y76);
y77_pos <= y77;
y77_neg <= y77 - 1;
y77_msb <= y77[10];
y77_et_zero <= !(|y77);
y78_pos <= y78;
y78_neg <= y78 - 1;
y78_msb <= y78[10];
y78_et_zero <= !(|y78);
y81_pos <= y81;
y81_neg <= y81 - 1;
y81_msb <= y81[10];
y81_et_zero <= !(|y81);
y82_pos <= y82;
y82_neg <= y82 - 1;
y82_msb <= y82[10];
y82_et_zero <= !(|y82);
y83_pos <= y83;
y83_neg <= y83 - 1;
y83_msb <= y83[10];
y83_et_zero <= !(|y83);
y84_pos <= y84;
y84_neg <= y84 - 1;
y84_msb <= y84[10];
y84_et_zero <= !(|y84);
y85_pos <= y85;
y85_neg <= y85 - 1;
y85_msb <= y85[10];
y85_et_zero <= !(|y85);
y86_pos <= y86;
y86_neg <= y86 - 1;
y86_msb <= y86[10];
y86_et_zero <= !(|y86);
y87_pos <= y87;
y87_neg <= y87 - 1;
y87_msb <= y87[10];
y87_et_zero <= !(|y87);
y88_pos <= y88;
y88_neg <= y88 - 1;
y88_msb <= y88[10];
y88_et_zero <= !(|y88);
end
else if (enable_module) begin
y12_pos <= y21_pos;
y12_neg <= y21_neg;
y12_msb <= y21_msb;
y12_et_zero <= y21_et_zero;
y21_pos <= y31_pos;
y21_neg <= y31_neg;
y21_msb <= y31_msb;
y21_et_zero <= y31_et_zero;
y31_pos <= y22_pos;
y31_neg <= y22_neg;
y31_msb <= y22_msb;
y31_et_zero <= y22_et_zero;
y22_pos <= y13_pos;
y22_neg <= y13_neg;
y22_msb <= y13_msb;
y22_et_zero <= y13_et_zero;
y13_pos <= y14_pos;
y13_neg <= y14_neg;
y13_msb <= y14_msb;
y13_et_zero <= y14_et_zero;
y14_pos <= y23_pos;
y14_neg <= y23_neg;
y14_msb <= y23_msb;
y14_et_zero <= y23_et_zero;
y23_pos <= y32_pos;
y23_neg <= y32_neg;
y23_msb <= y32_msb;
y23_et_zero <= y32_et_zero;
y32_pos <= y41_pos;
y32_neg <= y41_neg;
y32_msb <= y41_msb;
y32_et_zero <= y41_et_zero;
y41_pos <= y51_pos;
y41_neg <= y51_neg;
y41_msb <= y51_msb;
y41_et_zero <= y51_et_zero;
y51_pos <= y42_pos;
y51_neg <= y42_neg;
y51_msb <= y42_msb;
y51_et_zero <= y42_et_zero;
y42_pos <= y33_pos;
y42_neg <= y33_neg;
y42_msb <= y33_msb;
y42_et_zero <= y33_et_zero;
y33_pos <= y24_pos;
y33_neg <= y24_neg;
y33_msb <= y24_msb;
y33_et_zero <= y24_et_zero;
y24_pos <= y15_pos;
y24_neg <= y15_neg;
y24_msb <= y15_msb;
y24_et_zero <= y15_et_zero;
y15_pos <= y16_pos;
y15_neg <= y16_neg;
y15_msb <= y16_msb;
y15_et_zero <= y16_et_zero;
y16_pos <= y25_pos;
y16_neg <= y25_neg;
y16_msb <= y25_msb;
y16_et_zero <= y25_et_zero;
y25_pos <= y34_pos;
y25_neg <= y34_neg;
y25_msb <= y34_msb;
y25_et_zero <= y34_et_zero;
y34_pos <= y43_pos;
y34_neg <= y43_neg;
y34_msb <= y43_msb;
y34_et_zero <= y43_et_zero;
y43_pos <= y52_pos;
y43_neg <= y52_neg;
y43_msb <= y52_msb;
y43_et_zero <= y52_et_zero;
y52_pos <= y61_pos;
y52_neg <= y61_neg;
y52_msb <= y61_msb;
y52_et_zero <= y61_et_zero;
y61_pos <= y71_pos;
y61_neg <= y71_neg;
y61_msb <= y71_msb;
y61_et_zero <= y71_et_zero;
y71_pos <= y62_pos;
y71_neg <= y62_neg;
y71_msb <= y62_msb;
y71_et_zero <= y62_et_zero;
y62_pos <= y53_pos;
y62_neg <= y53_neg;
y62_msb <= y53_msb;
y62_et_zero <= y53_et_zero;
y53_pos <= y44_pos;
y53_neg <= y44_neg;
y53_msb <= y44_msb;
y53_et_zero <= y44_et_zero;
y44_pos <= y35_pos;
y44_neg <= y35_neg;
y44_msb <= y35_msb;
y44_et_zero <= y35_et_zero;
y35_pos <= y26_pos;
y35_neg <= y26_neg;
y35_msb <= y26_msb;
y35_et_zero <= y26_et_zero;
y26_pos <= y17_pos;
y26_neg <= y17_neg;
y26_msb <= y17_msb;
y26_et_zero <= y17_et_zero;
y17_pos <= y18_pos;
y17_neg <= y18_neg;
y17_msb <= y18_msb;
y17_et_zero <= y18_et_zero;
y18_pos <= y27_pos;
y18_neg <= y27_neg;
y18_msb <= y27_msb;
y18_et_zero <= y27_et_zero;
y27_pos <= y36_pos;
y27_neg <= y36_neg;
y27_msb <= y36_msb;
y27_et_zero <= y36_et_zero;
y36_pos <= y45_pos;
y36_neg <= y45_neg;
y36_msb <= y45_msb;
y36_et_zero <= y45_et_zero;
y45_pos <= y54_pos;
y45_neg <= y54_neg;
y45_msb <= y54_msb;
y45_et_zero <= y54_et_zero;
y54_pos <= y63_pos;
y54_neg <= y63_neg;
y54_msb <= y63_msb;
y54_et_zero <= y63_et_zero;
y63_pos <= y72_pos;
y63_neg <= y72_neg;
y63_msb <= y72_msb;
y63_et_zero <= y72_et_zero;
y72_pos <= y81_pos;
y72_neg <= y81_neg;
y72_msb <= y81_msb;
y72_et_zero <= y81_et_zero;
y81_pos <= y82_pos;
y81_neg <= y82_neg;
y81_msb <= y82_msb;
y81_et_zero <= y82_et_zero;
y82_pos <= y73_pos;
y82_neg <= y73_neg;
y82_msb <= y73_msb;
y82_et_zero <= y73_et_zero;
y73_pos <= y64_pos;
y73_neg <= y64_neg;
y73_msb <= y64_msb;
y73_et_zero <= y64_et_zero;
y64_pos <= y55_pos;
y64_neg <= y55_neg;
y64_msb <= y55_msb;
y64_et_zero <= y55_et_zero;
y55_pos <= y46_pos;
y55_neg <= y46_neg;
y55_msb <= y46_msb;
y55_et_zero <= y46_et_zero;
y46_pos <= y37_pos;
y46_neg <= y37_neg;
y46_msb <= y37_msb;
y46_et_zero <= y37_et_zero;
y37_pos <= y28_pos;
y37_neg <= y28_neg;
y37_msb <= y28_msb;
y37_et_zero <= y28_et_zero;
y28_pos <= y38_pos;
y28_neg <= y38_neg;
y28_msb <= y38_msb;
y28_et_zero <= y38_et_zero;
y38_pos <= y47_pos;
y38_neg <= y47_neg;
y38_msb <= y47_msb;
y38_et_zero <= y47_et_zero;
y47_pos <= y56_pos;
y47_neg <= y56_neg;
y47_msb <= y56_msb;
y47_et_zero <= y56_et_zero;
y56_pos <= y65_pos;
y56_neg <= y65_neg;
y56_msb <= y65_msb;
y56_et_zero <= y65_et_zero;
y65_pos <= y74_pos;
y65_neg <= y74_neg;
y65_msb <= y74_msb;
y65_et_zero <= y74_et_zero;
y74_pos <= y83_pos;
y74_neg <= y83_neg;
y74_msb <= y83_msb;
y74_et_zero <= y83_et_zero;
y83_pos <= y84_pos;
y83_neg <= y84_neg;
y83_msb <= y84_msb;
y83_et_zero <= y84_et_zero;
y84_pos <= y75_pos;
y84_neg <= y75_neg;
y84_msb <= y75_msb;
y84_et_zero <= y75_et_zero;
y75_pos <= y66_pos;
y75_neg <= y66_neg;
y75_msb <= y66_msb;
y75_et_zero <= y66_et_zero;
y66_pos <= y57_pos;
y66_neg <= y57_neg;
y66_msb <= y57_msb;
y66_et_zero <= y57_et_zero;
y57_pos <= y48_pos;
y57_neg <= y48_neg;
y57_msb <= y48_msb;
y57_et_zero <= y48_et_zero;
y48_pos <= y58_pos;
y48_neg <= y58_neg;
y48_msb <= y58_msb;
y48_et_zero <= y58_et_zero;
y58_pos <= y67_pos;
y58_neg <= y67_neg;
y58_msb <= y67_msb;
y58_et_zero <= y67_et_zero;
y67_pos <= y76_pos;
y67_neg <= y76_neg;
y67_msb <= y76_msb;
y67_et_zero <= y76_et_zero;
y76_pos <= y85_pos;
y76_neg <= y85_neg;
y76_msb <= y85_msb;
y76_et_zero <= y85_et_zero;
y85_pos <= y86_pos;
y85_neg <= y86_neg;
y85_msb <= y86_msb;
y85_et_zero <= y86_et_zero;
y86_pos <= y77_pos;
y86_neg <= y77_neg;
y86_msb <= y77_msb;
y86_et_zero <= y77_et_zero;
y77_pos <= y68_pos;
y77_neg <= y68_neg;
y77_msb <= y68_msb;
y77_et_zero <= y68_et_zero;
y68_pos <= y78_pos;
y68_neg <= y78_neg;
y68_msb <= y78_msb;
y68_et_zero <= y78_et_zero;
y78_pos <= y87_pos;
y78_neg <= y87_neg;
y78_msb <= y87_msb;
y78_et_zero <= y87_et_zero;
y87_pos <= y88_pos;
y87_neg <= y88_neg;
y87_msb <= y88_msb;
y87_et_zero <= y88_et_zero;
y88_pos <= 0;
y88_neg <= 0;
y88_msb <= 0;
y88_et_zero <= 1;
end
end
always @(posedge clk)
begin
if (rst) begin
y11_diff <= 0; y11_1 <= 0;
end
else if (enable) begin y11_diff <= {y11[10], y11} - y11_previous;
y11_1 <= y11[10] ? { 1'b1, y11 } : { 1'b0, y11 };
end
end
always @(posedge clk)
begin
if (rst)
y11_bits_pos <= 0;
else if (y11_1_pos[10] == 1)
y11_bits_pos <= 11;
else if (y11_1_pos[9] == 1)
y11_bits_pos <= 10;
else if (y11_1_pos[8] == 1)
y11_bits_pos <= 9;
else if (y11_1_pos[7] == 1)
y11_bits_pos <= 8;
else if (y11_1_pos[6] == 1)
y11_bits_pos <= 7;
else if (y11_1_pos[5] == 1)
y11_bits_pos <= 6;
else if (y11_1_pos[4] == 1)
y11_bits_pos <= 5;
else if (y11_1_pos[3] == 1)
y11_bits_pos <= 4;
else if (y11_1_pos[2] == 1)
y11_bits_pos <= 3;
else if (y11_1_pos[1] == 1)
y11_bits_pos <= 2;
else if (y11_1_pos[0] == 1)
y11_bits_pos <= 1;
else
y11_bits_pos <= 0;
end
always @(posedge clk)
begin
if (rst)
y11_bits_neg <= 0;
else if (y11_1_neg[10] == 0)
y11_bits_neg <= 11;
else if (y11_1_neg[9] == 0)
y11_bits_neg <= 10;
else if (y11_1_neg[8] == 0)
y11_bits_neg <= 9;
else if (y11_1_neg[7] == 0)
y11_bits_neg <= 8;
else if (y11_1_neg[6] == 0)
y11_bits_neg <= 7;
else if (y11_1_neg[5] == 0)
y11_bits_neg <= 6;
else if (y11_1_neg[4] == 0)
y11_bits_neg <= 5;
else if (y11_1_neg[3] == 0)
y11_bits_neg <= 4;
else if (y11_1_neg[2] == 0)
y11_bits_neg <= 3;
else if (y11_1_neg[1] == 0)
y11_bits_neg <= 2;
else if (y11_1_neg[0] == 0)
y11_bits_neg <= 1;
else
y11_bits_neg <= 0;
end
always @(posedge clk)
begin
if (rst)
y12_bits_pos <= 0;
else if (y12_pos[9] == 1)
y12_bits_pos <= 10;
else if (y12_pos[8] == 1)
y12_bits_pos <= 9;
else if (y12_pos[7] == 1)
y12_bits_pos <= 8;
else if (y12_pos[6] == 1)
y12_bits_pos <= 7;
else if (y12_pos[5] == 1)
y12_bits_pos <= 6;
else if (y12_pos[4] == 1)
y12_bits_pos <= 5;
else if (y12_pos[3] == 1)
y12_bits_pos <= 4;
else if (y12_pos[2] == 1)
y12_bits_pos <= 3;
else if (y12_pos[1] == 1)
y12_bits_pos <= 2;
else if (y12_pos[0] == 1)
y12_bits_pos <= 1;
else
y12_bits_pos <= 0;
end
always @(posedge clk)
begin
if (rst)
y12_bits_neg <= 0;
else if (y12_neg[9] == 0)
y12_bits_neg <= 10;
else if (y12_neg[8] == 0)
y12_bits_neg <= 9;
else if (y12_neg[7] == 0)
y12_bits_neg <= 8;
else if (y12_neg[6] == 0)
y12_bits_neg <= 7;
else if (y12_neg[5] == 0)
y12_bits_neg <= 6;
else if (y12_neg[4] == 0)
y12_bits_neg <= 5;
else if (y12_neg[3] == 0)
y12_bits_neg <= 4;
else if (y12_neg[2] == 0)
y12_bits_neg <= 3;
else if (y12_neg[1] == 0)
y12_bits_neg <= 2;
else if (y12_neg[0] == 0)
y12_bits_neg <= 1;
else
y12_bits_neg <= 0;
end
always @(posedge clk)
begin
if (rst) begin
enable_module <= 0;
end
else if (enable) begin
enable_module <= 1;
end
end
always @(posedge clk)
begin
if (rst) begin
enable_latch_7 <= 0;
end
else if (block_counter == 68) begin
enable_latch_7 <= 0;
end
else if (enable_6) begin
enable_latch_7 <= 1;
end
end
always @(posedge clk)
begin
if (rst) begin
enable_latch_8 <= 0;
end
else if (enable_7) begin
enable_latch_8 <= 1;
end
end
always @(posedge clk)
begin
if (rst) begin
enable_1 <= 0; enable_2 <= 0; enable_3 <= 0;
enable_4 <= 0; enable_5 <= 0; enable_6 <= 0;
enable_7 <= 0; enable_8 <= 0; enable_9 <= 0;
enable_10 <= 0; enable_11 <= 0; enable_12 <= 0;
enable_13 <= 0;
end
else begin
enable_1 <= enable; enable_2 <= enable_1; enable_3 <= enable_2;
enable_4 <= enable_3; enable_5 <= enable_4; enable_6 <= enable_5;
enable_7 <= enable_6; enable_8 <= enable_7; enable_9 <= enable_8;
enable_10 <= enable_9; enable_11 <= enable_10; enable_12 <= enable_11;
enable_13 <= enable_12;
end
end
always @(posedge clk)
begin
y_dc_code_length[0] <= 2;
y_dc_code_length[1] <= 2;
y_dc_code_length[2] <= 2;
y_dc_code_length[3] <= 3;
y_dc_code_length[4] <= 4;
y_dc_code_length[5] <= 5;
y_dc_code_length[6] <= 6;
y_dc_code_length[7] <= 7;
y_dc_code_length[8] <= 8;
y_dc_code_length[9] <= 9;
y_dc_code_length[10] <= 10;
y_dc_code_length[11] <= 11;
y_dc[0] <= 11'b00000000000;
y_dc[1] <= 11'b01000000000;
y_dc[2] <= 11'b10000000000;
y_dc[3] <= 11'b11000000000;
y_dc[4] <= 11'b11100000000;
y_dc[5] <= 11'b11110000000;
y_dc[6] <= 11'b11111000000;
y_dc[7] <= 11'b11111100000;
y_dc[8] <= 11'b11111110000;
y_dc[9] <= 11'b11111111000;
y_dc[10] <= 11'b11111111100;
y_dc[11] <= 11'b11111111110;
y_ac_code_length[0] <= 2;
y_ac_code_length[1] <= 2;
y_ac_code_length[2] <= 3;
y_ac_code_length[3] <= 4;
y_ac_code_length[4] <= 4;
y_ac_code_length[5] <= 4;
y_ac_code_length[6] <= 5;
y_ac_code_length[7] <= 5;
y_ac_code_length[8] <= 5;
y_ac_code_length[9] <= 6;
y_ac_code_length[10] <= 6;
y_ac_code_length[11] <= 7;
y_ac_code_length[12] <= 7;
y_ac_code_length[13] <= 7;
y_ac_code_length[14] <= 7;
y_ac_code_length[15] <= 8;
y_ac_code_length[16] <= 8;
y_ac_code_length[17] <= 8;
y_ac_code_length[18] <= 9;
y_ac_code_length[19] <= 9;
y_ac_code_length[20] <= 9;
y_ac_code_length[21] <= 9;
y_ac_code_length[22] <= 9;
y_ac_code_length[23] <= 10;
y_ac_code_length[24] <= 10;
y_ac_code_length[25] <= 10;
y_ac_code_length[26] <= 10;
y_ac_code_length[27] <= 10;
y_ac_code_length[28] <= 11;
y_ac_code_length[29] <= 11;
y_ac_code_length[30] <= 11;
y_ac_code_length[31] <= 11;
y_ac_code_length[32] <= 12;
y_ac_code_length[33] <= 12;
y_ac_code_length[34] <= 12;
y_ac_code_length[35] <= 12;
y_ac_code_length[36] <= 15;
y_ac_code_length[37] <= 16;
y_ac_code_length[38] <= 16;
y_ac_code_length[39] <= 16;
y_ac_code_length[40] <= 16;
y_ac_code_length[41] <= 16;
y_ac_code_length[42] <= 16;
y_ac_code_length[43] <= 16;
y_ac_code_length[44] <= 16;
y_ac_code_length[45] <= 16;
y_ac_code_length[46] <= 16;
y_ac_code_length[47] <= 16;
y_ac_code_length[48] <= 16;
y_ac_code_length[49] <= 16;
y_ac_code_length[50] <= 16;
y_ac_code_length[51] <= 16;
y_ac_code_length[52] <= 16;
y_ac_code_length[53] <= 16;
y_ac_code_length[54] <= 16;
y_ac_code_length[55] <= 16;
y_ac_code_length[56] <= 16;
y_ac_code_length[57] <= 16;
y_ac_code_length[58] <= 16;
y_ac_code_length[59] <= 16;
y_ac_code_length[60] <= 16;
y_ac_code_length[61] <= 16;
y_ac_code_length[62] <= 16;
y_ac_code_length[63] <= 16;
y_ac_code_length[64] <= 16;
y_ac_code_length[65] <= 16;
y_ac_code_length[66] <= 16;
y_ac_code_length[67] <= 16;
y_ac_code_length[68] <= 16;
y_ac_code_length[69] <= 16;
y_ac_code_length[70] <= 16;
y_ac_code_length[71] <= 16;
y_ac_code_length[72] <= 16;
y_ac_code_length[73] <= 16;
y_ac_code_length[74] <= 16;
y_ac_code_length[75] <= 16;
y_ac_code_length[76] <= 16;
y_ac_code_length[77] <= 16;
y_ac_code_length[78] <= 16;
y_ac_code_length[79] <= 16;
y_ac_code_length[80] <= 16;
y_ac_code_length[81] <= 16;
y_ac_code_length[82] <= 16;
y_ac_code_length[83] <= 16;
y_ac_code_length[84] <= 16;
y_ac_code_length[85] <= 16;
y_ac_code_length[86] <= 16;
y_ac_code_length[87] <= 16;
y_ac_code_length[88] <= 16;
y_ac_code_length[89] <= 16;
y_ac_code_length[90] <= 16;
y_ac_code_length[91] <= 16;
y_ac_code_length[92] <= 16;
y_ac_code_length[93] <= 16;
y_ac_code_length[94] <= 16;
y_ac_code_length[95] <= 16;
y_ac_code_length[96] <= 16;
y_ac_code_length[97] <= 16;
y_ac_code_length[98] <= 16;
y_ac_code_length[99] <= 16;
y_ac_code_length[100] <= 16;
y_ac_code_length[101] <= 16;
y_ac_code_length[102] <= 16;
y_ac_code_length[103] <= 16;
y_ac_code_length[104] <= 16;
y_ac_code_length[105] <= 16;
y_ac_code_length[106] <= 16;
y_ac_code_length[107] <= 16;
y_ac_code_length[108] <= 16;
y_ac_code_length[109] <= 16;
y_ac_code_length[110] <= 16;
y_ac_code_length[111] <= 16;
y_ac_code_length[112] <= 16;
y_ac_code_length[113] <= 16;
y_ac_code_length[114] <= 16;
y_ac_code_length[115] <= 16;
y_ac_code_length[116] <= 16;
y_ac_code_length[117] <= 16;
y_ac_code_length[118] <= 16;
y_ac_code_length[119] <= 16;
y_ac_code_length[120] <= 16;
y_ac_code_length[121] <= 16;
y_ac_code_length[122] <= 16;
y_ac_code_length[123] <= 16;
y_ac_code_length[124] <= 16;
y_ac_code_length[125] <= 16;
y_ac_code_length[126] <= 16;
y_ac_code_length[127] <= 16;
y_ac_code_length[128] <= 16;
y_ac_code_length[129] <= 16;
y_ac_code_length[130] <= 16;
y_ac_code_length[131] <= 16;
y_ac_code_length[132] <= 16;
y_ac_code_length[133] <= 16;
y_ac_code_length[134] <= 16;
y_ac_code_length[135] <= 16;
y_ac_code_length[136] <= 16;
y_ac_code_length[137] <= 16;
y_ac_code_length[138] <= 16;
y_ac_code_length[139] <= 16;
y_ac_code_length[140] <= 16;
y_ac_code_length[141] <= 16;
y_ac_code_length[142] <= 16;
y_ac_code_length[143] <= 16;
y_ac_code_length[144] <= 16;
y_ac_code_length[145] <= 16;
y_ac_code_length[146] <= 16;
y_ac_code_length[147] <= 16;
y_ac_code_length[148] <= 16;
y_ac_code_length[149] <= 16;
y_ac_code_length[150] <= 16;
y_ac_code_length[151] <= 16;
y_ac_code_length[152] <= 16;
y_ac_code_length[153] <= 16;
y_ac_code_length[154] <= 16;
y_ac_code_length[155] <= 16;
y_ac_code_length[156] <= 16;
y_ac_code_length[157] <= 16;
y_ac_code_length[158] <= 16;
y_ac_code_length[159] <= 16;
y_ac_code_length[160] <= 16;
y_ac_code_length[161] <= 16;
y_ac[0] <= 16'b0000000000000000;
y_ac[1] <= 16'b0100000000000000;
y_ac[2] <= 16'b1000000000000000;
y_ac[3] <= 16'b1010000000000000;
y_ac[4] <= 16'b1011000000000000;
y_ac[5] <= 16'b1100000000000000;
y_ac[6] <= 16'b1101000000000000;
y_ac[7] <= 16'b1101100000000000;
y_ac[8] <= 16'b1110000000000000;
y_ac[9] <= 16'b1110100000000000;
y_ac[10] <= 16'b1110110000000000;
y_ac[11] <= 16'b1111000000000000;
y_ac[12] <= 16'b1111001000000000;
y_ac[13] <= 16'b1111010000000000;
y_ac[14] <= 16'b1111011000000000;
y_ac[15] <= 16'b1111100000000000;
y_ac[16] <= 16'b1111100100000000;
y_ac[17] <= 16'b1111101000000000;
y_ac[18] <= 16'b1111101100000000;
y_ac[19] <= 16'b1111101110000000;
y_ac[20] <= 16'b1111110000000000;
y_ac[21] <= 16'b1111110010000000;
y_ac[22] <= 16'b1111110100000000;
y_ac[23] <= 16'b1111110110000000;
y_ac[24] <= 16'b1111110111000000;
y_ac[25] <= 16'b1111111000000000;
y_ac[26] <= 16'b1111111001000000;
y_ac[27] <= 16'b1111111010000000;
y_ac[28] <= 16'b1111111011000000;
y_ac[29] <= 16'b1111111011100000;
y_ac[30] <= 16'b1111111100000000;
y_ac[31] <= 16'b1111111100100000;
y_ac[32] <= 16'b1111111101000000;
y_ac[33] <= 16'b1111111101010000;
y_ac[34] <= 16'b1111111101100000;
y_ac[35] <= 16'b1111111101110000;
y_ac[36] <= 16'b1111111110000000;
y_ac[37] <= 16'b1111111110000010;
y_ac[38] <= 16'b1111111110000011;
y_ac[39] <= 16'b1111111110000100;
y_ac[40] <= 16'b1111111110000101;
y_ac[41] <= 16'b1111111110000110;
y_ac[42] <= 16'b1111111110000111;
y_ac[43] <= 16'b1111111110001000;
y_ac[44] <= 16'b1111111110001001;
y_ac[45] <= 16'b1111111110001010;
y_ac[46] <= 16'b1111111110001011;
y_ac[47] <= 16'b1111111110001100;
y_ac[48] <= 16'b1111111110001101;
y_ac[49] <= 16'b1111111110001110;
y_ac[50] <= 16'b1111111110001111;
y_ac[51] <= 16'b1111111110010000;
y_ac[52] <= 16'b1111111110010001;
y_ac[53] <= 16'b1111111110010010;
y_ac[54] <= 16'b1111111110010011;
y_ac[55] <= 16'b1111111110010100;
y_ac[56] <= 16'b1111111110010101;
y_ac[57] <= 16'b1111111110010110;
y_ac[58] <= 16'b1111111110010111;
y_ac[59] <= 16'b1111111110011000;
y_ac[60] <= 16'b1111111110011001;
y_ac[61] <= 16'b1111111110011010;
y_ac[62] <= 16'b1111111110011011;
y_ac[63] <= 16'b1111111110011100;
y_ac[64] <= 16'b1111111110011101;
y_ac[65] <= 16'b1111111110011110;
y_ac[66] <= 16'b1111111110011111;
y_ac[67] <= 16'b1111111110100000;
y_ac[68] <= 16'b1111111110100001;
y_ac[69] <= 16'b1111111110100010;
y_ac[70] <= 16'b1111111110100011;
y_ac[71] <= 16'b1111111110100100;
y_ac[72] <= 16'b1111111110100101;
y_ac[73] <= 16'b1111111110100110;
y_ac[74] <= 16'b1111111110100111;
y_ac[75] <= 16'b1111111110101000;
y_ac[76] <= 16'b1111111110101001;
y_ac[77] <= 16'b1111111110101010;
y_ac[78] <= 16'b1111111110101011;
y_ac[79] <= 16'b1111111110101100;
y_ac[80] <= 16'b1111111110101101;
y_ac[81] <= 16'b1111111110101110;
y_ac[82] <= 16'b1111111110101111;
y_ac[83] <= 16'b1111111110110000;
y_ac[84] <= 16'b1111111110110001;
y_ac[85] <= 16'b1111111110110010;
y_ac[86] <= 16'b1111111110110011;
y_ac[87] <= 16'b1111111110110100;
y_ac[88] <= 16'b1111111110110101;
y_ac[89] <= 16'b1111111110110110;
y_ac[90] <= 16'b1111111110110111;
y_ac[91] <= 16'b1111111110111000;
y_ac[92] <= 16'b1111111110111001;
y_ac[93] <= 16'b1111111110111010;
y_ac[94] <= 16'b1111111110111011;
y_ac[95] <= 16'b1111111110111100;
y_ac[96] <= 16'b1111111110111101;
y_ac[97] <= 16'b1111111110111110;
y_ac[98] <= 16'b1111111110111111;
y_ac[99] <= 16'b1111111111000000;
y_ac[100] <= 16'b1111111111000001;
y_ac[101] <= 16'b1111111111000010;
y_ac[102] <= 16'b1111111111000011;
y_ac[103] <= 16'b1111111111000100;
y_ac[104] <= 16'b1111111111000101;
y_ac[105] <= 16'b1111111111000110;
y_ac[106] <= 16'b1111111111000111;
y_ac[107] <= 16'b1111111111001000;
y_ac[108] <= 16'b1111111111001001;
y_ac[109] <= 16'b1111111111001010;
y_ac[110] <= 16'b1111111111001011;
y_ac[111] <= 16'b1111111111001100;
y_ac[112] <= 16'b1111111111001101;
y_ac[113] <= 16'b1111111111001110;
y_ac[114] <= 16'b1111111111001111;
y_ac[115] <= 16'b1111111111010000;
y_ac[116] <= 16'b1111111111010001;
y_ac[117] <= 16'b1111111111010010;
y_ac[118] <= 16'b1111111111010011;
y_ac[119] <= 16'b1111111111010100;
y_ac[120] <= 16'b1111111111010101;
y_ac[121] <= 16'b1111111111010110;
y_ac[122] <= 16'b1111111111010111;
y_ac[123] <= 16'b1111111111011000;
y_ac[124] <= 16'b1111111111011001;
y_ac[125] <= 16'b1111111111011010;
y_ac[126] <= 16'b1111111111011011;
y_ac[127] <= 16'b1111111111011100;
y_ac[128] <= 16'b1111111111011101;
y_ac[129] <= 16'b1111111111011110;
y_ac[130] <= 16'b1111111111011111;
y_ac[131] <= 16'b1111111111100000;
y_ac[132] <= 16'b1111111111100001;
y_ac[133] <= 16'b1111111111100010;
y_ac[134] <= 16'b1111111111100011;
y_ac[135] <= 16'b1111111111100100;
y_ac[136] <= 16'b1111111111100101;
y_ac[137] <= 16'b1111111111100110;
y_ac[138] <= 16'b1111111111100111;
y_ac[139] <= 16'b1111111111101000;
y_ac[140] <= 16'b1111111111101001;
y_ac[141] <= 16'b1111111111101010;
y_ac[142] <= 16'b1111111111101011;
y_ac[143] <= 16'b1111111111101100;
y_ac[144] <= 16'b1111111111101101;
y_ac[145] <= 16'b1111111111101110;
y_ac[146] <= 16'b1111111111101111;
y_ac[147] <= 16'b1111111111110000;
y_ac[148] <= 16'b1111111111110001;
y_ac[149] <= 16'b1111111111110010;
y_ac[150] <= 16'b1111111111110011;
y_ac[151] <= 16'b1111111111110100;
y_ac[152] <= 16'b1111111111110101;
y_ac[153] <= 16'b1111111111110110;
y_ac[154] <= 16'b1111111111110111;
y_ac[155] <= 16'b1111111111111000;
y_ac[156] <= 16'b1111111111111001;
y_ac[157] <= 16'b1111111111111010;
y_ac[158] <= 16'b1111111111111011;
y_ac[159] <= 16'b1111111111111100;
y_ac[160] <= 16'b1111111111111101;
y_ac[161] <= 16'b1111111111111110;
y_ac_run_code[1] <= 0;
y_ac_run_code[2] <= 1;
y_ac_run_code[3] <= 2;
y_ac_run_code[0] <= 3;
y_ac_run_code[4] <= 4;
y_ac_run_code[17] <= 5;
y_ac_run_code[5] <= 6;
y_ac_run_code[18] <= 7;
y_ac_run_code[33] <= 8;
y_ac_run_code[49] <= 9;
y_ac_run_code[65] <= 10;
y_ac_run_code[6] <= 11;
y_ac_run_code[19] <= 12;
y_ac_run_code[81] <= 13;
y_ac_run_code[97] <= 14;
y_ac_run_code[7] <= 15;
y_ac_run_code[34] <= 16;
y_ac_run_code[113] <= 17;
y_ac_run_code[20] <= 18;
y_ac_run_code[50] <= 19;
y_ac_run_code[129] <= 20;
y_ac_run_code[145] <= 21;
y_ac_run_code[161] <= 22;
y_ac_run_code[8] <= 23;
y_ac_run_code[35] <= 24;
y_ac_run_code[66] <= 25;
y_ac_run_code[177] <= 26;
y_ac_run_code[193] <= 27;
y_ac_run_code[21] <= 28;
y_ac_run_code[82] <= 29;
y_ac_run_code[209] <= 30;
y_ac_run_code[240] <= 31;
y_ac_run_code[36] <= 32;
y_ac_run_code[51] <= 33;
y_ac_run_code[98] <= 34;
y_ac_run_code[114] <= 35;
y_ac_run_code[130] <= 36;
y_ac_run_code[9] <= 37;
y_ac_run_code[10] <= 38;
y_ac_run_code[22] <= 39;
y_ac_run_code[23] <= 40;
y_ac_run_code[24] <= 41;
y_ac_run_code[25] <= 42;
y_ac_run_code[26] <= 43;
y_ac_run_code[37] <= 44;
y_ac_run_code[38] <= 45;
y_ac_run_code[39] <= 46;
y_ac_run_code[40] <= 47;
y_ac_run_code[41] <= 48;
y_ac_run_code[42] <= 49;
y_ac_run_code[52] <= 50;
y_ac_run_code[53] <= 51;
y_ac_run_code[54] <= 52;
y_ac_run_code[55] <= 53;
y_ac_run_code[56] <= 54;
y_ac_run_code[57] <= 55;
y_ac_run_code[58] <= 56;
y_ac_run_code[67] <= 57;
y_ac_run_code[68] <= 58;
y_ac_run_code[69] <= 59;
y_ac_run_code[70] <= 60;
y_ac_run_code[71] <= 61;
y_ac_run_code[72] <= 62;
y_ac_run_code[73] <= 63;
y_ac_run_code[74] <= 64;
y_ac_run_code[83] <= 65;
y_ac_run_code[84] <= 66;
y_ac_run_code[85] <= 67;
y_ac_run_code[86] <= 68;
y_ac_run_code[87] <= 69;
y_ac_run_code[88] <= 70;
y_ac_run_code[89] <= 71;
y_ac_run_code[90] <= 72;
y_ac_run_code[99] <= 73;
y_ac_run_code[100] <= 74;
y_ac_run_code[101] <= 75;
y_ac_run_code[102] <= 76;
y_ac_run_code[103] <= 77;
y_ac_run_code[104] <= 78;
y_ac_run_code[105] <= 79;
y_ac_run_code[106] <= 80;
y_ac_run_code[115] <= 81;
y_ac_run_code[116] <= 82;
y_ac_run_code[117] <= 83;
y_ac_run_code[118] <= 84;
y_ac_run_code[119] <= 85;
y_ac_run_code[120] <= 86;
y_ac_run_code[121] <= 87;
y_ac_run_code[122] <= 88;
y_ac_run_code[131] <= 89;
y_ac_run_code[132] <= 90;
y_ac_run_code[133] <= 91;
y_ac_run_code[134] <= 92;
y_ac_run_code[135] <= 93;
y_ac_run_code[136] <= 94;
y_ac_run_code[137] <= 95;
y_ac_run_code[138] <= 96;
y_ac_run_code[146] <= 97;
y_ac_run_code[147] <= 98;
y_ac_run_code[148] <= 99;
y_ac_run_code[149] <= 100;
y_ac_run_code[150] <= 101;
y_ac_run_code[151] <= 102;
y_ac_run_code[152] <= 103;
y_ac_run_code[153] <= 104;
y_ac_run_code[154] <= 105;
y_ac_run_code[162] <= 106;
y_ac_run_code[163] <= 107;
y_ac_run_code[164] <= 108;
y_ac_run_code[165] <= 109;
y_ac_run_code[166] <= 110;
y_ac_run_code[167] <= 111;
y_ac_run_code[168] <= 112;
y_ac_run_code[169] <= 113;
y_ac_run_code[170] <= 114;
y_ac_run_code[178] <= 115;
y_ac_run_code[179] <= 116;
y_ac_run_code[180] <= 117;
y_ac_run_code[181] <= 118;
y_ac_run_code[182] <= 119;
y_ac_run_code[183] <= 120;
y_ac_run_code[184] <= 121;
y_ac_run_code[185] <= 122;
y_ac_run_code[186] <= 123;
y_ac_run_code[194] <= 124;
y_ac_run_code[195] <= 125;
y_ac_run_code[196] <= 126;
y_ac_run_code[197] <= 127;
y_ac_run_code[198] <= 128;
y_ac_run_code[199] <= 129;
y_ac_run_code[200] <= 130;
y_ac_run_code[201] <= 131;
y_ac_run_code[202] <= 132;
y_ac_run_code[210] <= 133;
y_ac_run_code[211] <= 134;
y_ac_run_code[212] <= 135;
y_ac_run_code[213] <= 136;
y_ac_run_code[214] <= 137;
y_ac_run_code[215] <= 138;
y_ac_run_code[216] <= 139;
y_ac_run_code[217] <= 140;
y_ac_run_code[218] <= 141;
y_ac_run_code[225] <= 142;
y_ac_run_code[226] <= 143;
y_ac_run_code[227] <= 144;
y_ac_run_code[228] <= 145;
y_ac_run_code[229] <= 146;
y_ac_run_code[230] <= 147;
y_ac_run_code[231] <= 148;
y_ac_run_code[232] <= 149;
y_ac_run_code[233] <= 150;
y_ac_run_code[234] <= 151;
y_ac_run_code[241] <= 152;
y_ac_run_code[242] <= 153;
y_ac_run_code[243] <= 154;
y_ac_run_code[244] <= 155;
y_ac_run_code[245] <= 156;
y_ac_run_code[246] <= 157;
y_ac_run_code[247] <= 158;
y_ac_run_code[248] <= 159;
y_ac_run_code[249] <= 160;
y_ac_run_code[250] <= 161;
y_ac_run_code[16] <= 0;
y_ac_run_code[32] <= 0;
y_ac_run_code[48] <= 0;
y_ac_run_code[64] <= 0;
y_ac_run_code[80] <= 0;
y_ac_run_code[96] <= 0;
y_ac_run_code[112] <= 0;
y_ac_run_code[128] <= 0;
y_ac_run_code[144] <= 0;
y_ac_run_code[160] <= 0;
y_ac_run_code[176] <= 0;
y_ac_run_code[192] <= 0;
y_ac_run_code[208] <= 0;
y_ac_run_code[224] <= 0;
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[31] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[31] <= jpeg_bs_5[31];
else if (enable_module && orc_8 == 0)
jpeg_bitstream[31] <= jpeg_bs_5[31];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[30] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[30] <= jpeg_bs_5[30];
else if (enable_module && orc_8 <= 1)
jpeg_bitstream[30] <= jpeg_bs_5[30];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[29] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[29] <= jpeg_bs_5[29];
else if (enable_module && orc_8 <= 2)
jpeg_bitstream[29] <= jpeg_bs_5[29];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[28] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[28] <= jpeg_bs_5[28];
else if (enable_module && orc_8 <= 3)
jpeg_bitstream[28] <= jpeg_bs_5[28];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[27] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[27] <= jpeg_bs_5[27];
else if (enable_module && orc_8 <= 4)
jpeg_bitstream[27] <= jpeg_bs_5[27];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[26] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[26] <= jpeg_bs_5[26];
else if (enable_module && orc_8 <= 5)
jpeg_bitstream[26] <= jpeg_bs_5[26];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[25] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[25] <= jpeg_bs_5[25];
else if (enable_module && orc_8 <= 6)
jpeg_bitstream[25] <= jpeg_bs_5[25];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[24] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[24] <= jpeg_bs_5[24];
else if (enable_module && orc_8 <= 7)
jpeg_bitstream[24] <= jpeg_bs_5[24];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[23] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[23] <= jpeg_bs_5[23];
else if (enable_module && orc_8 <= 8)
jpeg_bitstream[23] <= jpeg_bs_5[23];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[22] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[22] <= jpeg_bs_5[22];
else if (enable_module && orc_8 <= 9)
jpeg_bitstream[22] <= jpeg_bs_5[22];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[21] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[21] <= jpeg_bs_5[21];
else if (enable_module && orc_8 <= 10)
jpeg_bitstream[21] <= jpeg_bs_5[21];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[20] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[20] <= jpeg_bs_5[20];
else if (enable_module && orc_8 <= 11)
jpeg_bitstream[20] <= jpeg_bs_5[20];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[19] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[19] <= jpeg_bs_5[19];
else if (enable_module && orc_8 <= 12)
jpeg_bitstream[19] <= jpeg_bs_5[19];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[18] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[18] <= jpeg_bs_5[18];
else if (enable_module && orc_8 <= 13)
jpeg_bitstream[18] <= jpeg_bs_5[18];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[17] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[17] <= jpeg_bs_5[17];
else if (enable_module && orc_8 <= 14)
jpeg_bitstream[17] <= jpeg_bs_5[17];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[16] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[16] <= jpeg_bs_5[16];
else if (enable_module && orc_8 <= 15)
jpeg_bitstream[16] <= jpeg_bs_5[16];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[15] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[15] <= jpeg_bs_5[15];
else if (enable_module && orc_8 <= 16)
jpeg_bitstream[15] <= jpeg_bs_5[15];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[14] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[14] <= jpeg_bs_5[14];
else if (enable_module && orc_8 <= 17)
jpeg_bitstream[14] <= jpeg_bs_5[14];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[13] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[13] <= jpeg_bs_5[13];
else if (enable_module && orc_8 <= 18)
jpeg_bitstream[13] <= jpeg_bs_5[13];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[12] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[12] <= jpeg_bs_5[12];
else if (enable_module && orc_8 <= 19)
jpeg_bitstream[12] <= jpeg_bs_5[12];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[11] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[11] <= jpeg_bs_5[11];
else if (enable_module && orc_8 <= 20)
jpeg_bitstream[11] <= jpeg_bs_5[11];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[10] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[10] <= jpeg_bs_5[10];
else if (enable_module && orc_8 <= 21)
jpeg_bitstream[10] <= jpeg_bs_5[10];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[9] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[9] <= jpeg_bs_5[9];
else if (enable_module && orc_8 <= 22)
jpeg_bitstream[9] <= jpeg_bs_5[9];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[8] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[8] <= jpeg_bs_5[8];
else if (enable_module && orc_8 <= 23)
jpeg_bitstream[8] <= jpeg_bs_5[8];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[7] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[7] <= jpeg_bs_5[7];
else if (enable_module && orc_8 <= 24)
jpeg_bitstream[7] <= jpeg_bs_5[7];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[6] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[6] <= jpeg_bs_5[6];
else if (enable_module && orc_8 <= 25)
jpeg_bitstream[6] <= jpeg_bs_5[6];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[5] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[5] <= jpeg_bs_5[5];
else if (enable_module && orc_8 <= 26)
jpeg_bitstream[5] <= jpeg_bs_5[5];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[4] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[4] <= jpeg_bs_5[4];
else if (enable_module && orc_8 <= 27)
jpeg_bitstream[4] <= jpeg_bs_5[4];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[3] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[3] <= jpeg_bs_5[3];
else if (enable_module && orc_8 <= 28)
jpeg_bitstream[3] <= jpeg_bs_5[3];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[2] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[2] <= jpeg_bs_5[2];
else if (enable_module && orc_8 <= 29)
jpeg_bitstream[2] <= jpeg_bs_5[2];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[1] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[1] <= jpeg_bs_5[1];
else if (enable_module && orc_8 <= 30)
jpeg_bitstream[1] <= jpeg_bs_5[1];
end
always @(posedge clk)
begin
if (rst)
jpeg_bitstream[0] <= 0;
else if (enable_module && rollover_7)
jpeg_bitstream[0] <= jpeg_bs_5[0];
else if (enable_module && orc_8 <= 31)
jpeg_bitstream[0] <= jpeg_bs_5[0];
end
endmodule |
module zipdiv(i_clk, i_reset, i_wr, i_signed, i_numerator, i_denominator,
o_busy, o_valid, o_err, o_quotient, o_flags);
parameter bw=32, lgbw = 5;
input wire i_clk, i_reset;
input wire i_wr, i_signed;
input wire [(bw-1):0] i_numerator, i_denominator;
output reg o_busy, o_valid, o_err;
output reg [(bw-1):0] o_quotient;
output wire [3:0] o_flags;
reg r_busy;
reg [(2*bw-2):0] r_divisor;
reg [(bw-1):0] r_dividend;
wire [(bw):0] diff; assign diff = r_dividend - r_divisor[(bw-1):0];
reg r_sign, pre_sign, r_z, r_c, last_bit;
reg [(lgbw-1):0] r_bit;
reg zero_divisor;
initial r_busy = 1'b0;
always @(posedge i_clk)
if (i_reset)
r_busy <= 1'b0;
else if (i_wr)
r_busy <= 1'b1;
else if ((last_bit)||(zero_divisor))
r_busy <= 1'b0;
initial o_busy = 1'b0;
always @(posedge i_clk)
if (i_reset)
o_busy <= 1'b0;
else if (i_wr)
o_busy <= 1'b1;
else if (((last_bit)&&(!r_sign))||(zero_divisor))
o_busy <= 1'b0;
else if (!r_busy)
o_busy <= 1'b0;
initial zero_divisor = 1'b0;
always @(posedge i_clk)
if (i_reset)
zero_divisor <= 1'b0;
else if (i_wr)
zero_divisor <= (i_denominator == 0);
else if (!r_busy)
zero_divisor <= 1'b0;
initial o_valid = 1'b0;
always @(posedge i_clk)
if (i_reset)
o_valid <= 1'b0;
else if (r_busy)
begin
if ((last_bit)||(zero_divisor))
o_valid <= (zero_divisor)||(!r_sign);
end else if (r_sign)
begin
o_valid <= (!zero_divisor); end else
o_valid <= 1'b0;
initial o_err = 1'b0;
always @(posedge i_clk)
if (i_reset)
o_err <= 1'b0;
else if (o_valid)
o_err <= 1'b0;
else if (((r_busy)||(r_sign))&&(zero_divisor))
o_err <= 1'b1;
else
o_err <= 1'b0;
initial r_bit = 0;
always @(posedge i_clk)
if (i_reset)
r_bit <= 0;
else if ((r_busy)&&(!pre_sign))
r_bit <= r_bit + 1'b1;
else
r_bit <= 0;
initial last_bit = 1'b0;
always @(posedge i_clk)
if (i_reset)
last_bit <= 1'b0;
else if (r_busy)
last_bit <= (r_bit == {(lgbw){1'b1}}-1'b1);
else
last_bit <= 1'b0;
initial pre_sign = 1'b0;
always @(posedge i_clk)
if (i_reset)
pre_sign <= 1'b0;
else if (i_wr)
pre_sign <= (i_signed)&&((i_numerator[bw-1])||(i_denominator[bw-1]));
else
pre_sign <= 1'b0;
initial r_z = 1'b0;
always @(posedge i_clk)
if (i_reset)
r_z <= 1'b0;
else if((r_busy)&&(r_divisor[(2*bw-2):(bw)] == 0)&&(!diff[bw]))
r_z <= 1'b0;
else if (i_wr)
r_z <= 1'b1;
initial r_dividend = 0;
always @(posedge i_clk)
if (i_reset)
r_dividend <= 0;
else if (pre_sign)
begin
if (r_dividend[bw-1])
r_dividend <= -r_dividend;
end else if((r_busy)&&(r_divisor[(2*bw-2):(bw)]==0)&&(!diff[bw]))
r_dividend <= diff[(bw-1):0];
else if (!r_busy)
r_dividend <= i_numerator;
initial r_divisor = 0;
always @(posedge i_clk)
if (i_reset)
r_divisor <= 0;
else if (pre_sign)
begin
if (r_divisor[(2*bw-2)])
r_divisor[(2*bw-2):(bw-1)]
<= -r_divisor[(2*bw-2):(bw-1)];
end else if (r_busy)
r_divisor <= { 1'b0, r_divisor[(2*bw-2):1] };
else
r_divisor <= { i_denominator, {(bw-1){1'b0}} };
initial r_sign = 1'b0;
always @(posedge i_clk)
if (i_reset)
r_sign <= 1'b0;
else if (pre_sign)
r_sign <= ((r_divisor[(2*bw-2)])^(r_dividend[(bw-1)]));
else if (r_busy)
r_sign <= (r_sign)&&(!zero_divisor);
else
r_sign <= 1'b0;
initial o_quotient = 0;
always @(posedge i_clk)
if (i_reset)
o_quotient <= 0;
else if (r_busy)
begin
o_quotient <= { o_quotient[(bw-2):0], 1'b0 };
if ((r_divisor[(2*bw-2):(bw)] == 0)&&(!diff[bw]))
o_quotient[0] <= 1'b1;
end else if (r_sign)
o_quotient <= -o_quotient;
else
o_quotient <= 0;
initial r_c = 1'b0;
always @(posedge i_clk)
if (i_reset)
r_c <= 1'b0;
else
r_c <= (r_busy)&&((diff == 0)||(r_dividend == 0));
wire w_n;
assign w_n = o_quotient[(bw-1)];
assign o_flags = { 1'b0, w_n, r_c, r_z };
`ifdef formal
reg f_past_valid;
initial f_past_valid = 0;
always @(posedge i_clk)
f_past_valid <= 1'b1;
`ifdef div
`define assume assume
`else
`define assume assert
`endif
initial `assume(i_reset);
always @(*)
if (!f_past_valid)
`assume(i_reset);
always @(posedge i_clk)
if ((!f_past_valid)||($past(i_reset)))
begin
assert(!o_busy);
assert(!o_valid);
assert(!o_err);
assert(!r_busy);
assert(!zero_divisor);
assert(r_bit==0);
assert(!last_bit);
assert(!pre_sign);
assert(!r_z);
assert(r_dividend==0);
assert(o_quotient==0);
assert(!r_c);
assert(r_divisor==0);
`assume(!i_wr);
end
always @(*)
if (o_busy)
`assume(!i_wr);
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(i_reset))&&($past(o_busy))&&(!o_busy))
begin
assert(o_valid);
end
always @(*)
if (o_err)
assert(o_valid);
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(i_wr)))
assert(!pre_sign);
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(i_reset))&&($past(i_wr))&&($past(i_signed))
&&(|$past({i_numerator[bw-1],i_denominator[bw-1]})))
assert(pre_sign);
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(i_reset))&&($past(i_wr)))
assert(o_busy);
always @(posedge i_clk)
if ((f_past_valid)&&($past(o_valid)))
assert(!o_valid);
always @(*)
if ((o_valid)&&(!o_err))
assert(r_z == ((o_quotient == 0)? 1'b1:1'b0));
always @(*)
if ((o_valid)&&(!o_err))
assert(w_n == o_quotient[bw-1]);
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(r_busy))&&(!$past(i_wr)))
assert(!o_busy);
always @(posedge i_clk)
assert((!o_busy)||(!o_valid));
always @(posedge i_clk)
if(o_busy) `assume(!i_wr);
always @(*)
if(r_busy) assert(o_busy);
reg [bw:0] f_bits_set;
always @(posedge i_clk)
if (i_reset)
f_bits_set <= 0;
else if (i_wr)
f_bits_set <= 0;
else if ((r_busy)&&(!pre_sign))
f_bits_set <= { f_bits_set[bw-1:0], 1'b1 };
always @(*)
if ((o_valid)&&(!o_err))
assert((!f_bits_set[bw])&&(&f_bits_set[bw-1:0]));
always @(posedge i_clk)
if ((f_past_valid)&&(!$past(i_reset))&&($past(r_busy))
&&($past(r_divisor[2*bw-2:bw])==0))
begin
if ($past(r_divisor) == 0)
assert(o_err);
else if ($past(pre_sign))
begin
if ($past(r_dividend[bw-1]))
assert(r_dividend == -$past(r_dividend));
if ($past(r_divisor[(2*bw-2)]))
begin
assert(r_divisor[(2*bw-2):(bw-1)]
== -$past(r_divisor[(2*bw-2):(bw-1)]));
assert(r_divisor[bw-2:0] == 0);
end
end else begin
if (o_quotient[0])
assert(r_dividend == $past(diff));
else
assert(r_dividend == $past(r_dividend));
assert(r_divisor[2*bw-2]==0);
assert(r_divisor[2*bw-3:0]==$past(r_divisor[2*bw-2:1]));
end
if ($past(r_dividend) >= $past(r_divisor[bw-1:0]))
assert(o_quotient[0]);
else
assert(!o_quotient[0]);
end
`endif
endmodule |
module inverter (
input wire in,
output out );
assign out = !in;
endmodule |
module def_test (
input wire in,
output out,
output tied_to_zero,
output manufacturing_grid_missaligned_pin
);
assign tied_to_zero = 1;
assign manufacturing_grid_missaligned_pin = 1;
assign out = !in;
endmodule |
module counter #(
parameter bits = 32
)(
input clk,
input reset,
input valid,
input [3:0] wstrb,
input [15:0] wdata,
input [bits-1:0] la_write,
input [bits-1:0] la_input,
output ready,
output [15:0] rdata,
output [15:0] count
);
reg ready;
reg [15:0] count;
reg [15:0] rdata;
always @(posedge clk) begin
if (reset) begin
count <= 0;
ready <= 0;
end else begin
ready <= 1'b0;
if (~|la_write) begin
count <= count + 1;
end
if (valid && !ready) begin
ready <= 1'b1;
rdata <= count;
if (wstrb[0]) count[7:0] <= wdata[7:0];
if (wstrb[1]) count[15:8] <= wdata[15:8];
end else if (|la_write) begin
count <= la_write & la_input;
end
end
end
endmodule |
module e203_exu_branchslv(
input cmt_i_valid,
output cmt_i_ready,
input cmt_i_rv32,
input cmt_i_dret, input cmt_i_mret, input cmt_i_fencei, input cmt_i_bjp,
input cmt_i_bjp_prdt, input cmt_i_bjp_rslv, input [`e203_pc_size-1:0] cmt_i_pc,
input [`e203_xlen-1:0] cmt_i_imm,
input [`e203_pc_size-1:0] csr_epc_r,
input [`e203_pc_size-1:0] csr_dpc_r,
input nonalu_excpirq_flush_req_raw,
input brchmis_flush_ack,
output brchmis_flush_req,
output [`e203_pc_size-1:0] brchmis_flush_add_op1,
output [`e203_pc_size-1:0] brchmis_flush_add_op2,
`ifdef e203_timing_boost output [`e203_pc_size-1:0] brchmis_flush_pc,
`endif
output cmt_mret_ena,
output cmt_dret_ena,
output cmt_fencei_ena,
input clk,
input rst_n
);
wire brchmis_flush_ack_pre;
wire brchmis_flush_req_pre;
assign brchmis_flush_req = brchmis_flush_req_pre & (~nonalu_excpirq_flush_req_raw);
assign brchmis_flush_ack_pre = brchmis_flush_ack & (~nonalu_excpirq_flush_req_raw);
wire brchmis_need_flush = (
(cmt_i_bjp & (cmt_i_bjp_prdt ^ cmt_i_bjp_rslv))
| cmt_i_fencei
| cmt_i_mret
| cmt_i_dret
);
wire cmt_i_is_branch = (
cmt_i_bjp
| cmt_i_fencei
| cmt_i_mret
| cmt_i_dret
);
assign brchmis_flush_req_pre = cmt_i_valid & brchmis_need_flush;
assign brchmis_flush_add_op1 = cmt_i_dret ? csr_dpc_r : cmt_i_mret ? csr_epc_r : cmt_i_pc;
assign brchmis_flush_add_op2 = cmt_i_dret ? `e203_pc_size'b0 : cmt_i_mret ? `e203_pc_size'b0 :
(cmt_i_fencei | cmt_i_bjp_prdt) ? (cmt_i_rv32 ? `e203_pc_size'd4 : `e203_pc_size'd2)
: cmt_i_imm[`e203_pc_size-1:0];
`ifdef e203_timing_boost assign brchmis_flush_pc =
(cmt_i_fencei | (cmt_i_bjp & cmt_i_bjp_prdt)) ? (cmt_i_pc + (cmt_i_rv32 ? `e203_pc_size'd4 : `e203_pc_size'd2)) :
(cmt_i_bjp & (~cmt_i_bjp_prdt)) ? (cmt_i_pc + cmt_i_imm[`e203_pc_size-1:0]) :
cmt_i_dret ? csr_dpc_r :
csr_epc_r ; `endif
wire brchmis_flush_hsked = brchmis_flush_req & brchmis_flush_ack;
assign cmt_mret_ena = cmt_i_mret & brchmis_flush_hsked;
assign cmt_dret_ena = cmt_i_dret & brchmis_flush_hsked;
assign cmt_fencei_ena = cmt_i_fencei & brchmis_flush_hsked;
assign cmt_i_ready = (~cmt_i_is_branch) |
(
(brchmis_need_flush ? brchmis_flush_ack_pre : 1'b1)
& (~nonalu_excpirq_flush_req_raw)
);
endmodule |
module axi_register_slice #(
parameter data_width = 32,
parameter forward_register = 0,
parameter backward_register = 0)
(
input clk,
input resetn,
input s_axi_valid,
output s_axi_ready,
input [data_width-1:0] s_axi_data,
output m_axi_valid,
input m_axi_ready,
output [data_width-1:0] m_axi_data
);
wire [data_width-1:0] bwd_data_s;
wire bwd_valid_s;
wire bwd_ready_s;
wire [data_width-1:0] fwd_data_s;
wire fwd_valid_s;
wire fwd_ready_s;
generate if(forward_register == 1)begin
reg fwd_valid = 1'b0;
reg [data_width-1:0] fwd_data = 'h00;
assign fwd_valid_s = fwd_valid;
assign fwd_ready_s = ~fwd_valid | m_axi_ready;
assign fwd_data_s = fwd_data;
always@(posedge clk) begin
if(~fwd_valid | m_axi_ready)begin
fwd_data <= bwd_data_s;
end
end
always@(posedge clk) begin
if(resetn == 0)begin
fwd_valid <= 1'b0;
end
else begin
if(bwd_valid_s)begin
fwd_valid <= 1'b1;
end
else if(m_axi_ready) begin
fwd_valid <= 1'b0;
end
end
end
end
else begin
assign fwd_data_s = bwd_data_s;
assign fwd_valid_s = bwd_valid_s;
assign fwd_ready_s = m_axi_ready;
end
endgenerate
generate if(backward_register == 1)begin
reg bwd_ready = 1'b1;
reg [data_width-1:0] bwd_data = 'h00;
assign bwd_ready_s = bwd_ready;
assign bwd_valid_s = ~bwd_ready | s_axi_valid;
assign bwd_data_s = bwd_ready ? s_axi_data : bwd_data;
always@(posedge clk)begin
if(bwd_ready)begin
bwd_data <= s_axi_data;
end
end
always@(posedge clk)begin
if(resetn == 0)begin
bwd_ready <= 1'b1;
end
else begin
if(fwd_ready_s)begin
bwd_ready <= 1'b1;
end
else if(s_axi_valid)begin
bwd_ready <= 1'b0;
end
end
end
end
else begin
assign bwd_data_s = s_axi_data;
assign bwd_valid_s = s_axi_valid;
assign bwd_ready_s = fwd_ready_s;
end
endgenerate
assign s_axi_ready = bwd_ready_s;
assign m_axi_data = fwd_data_s;
assign m_axi_valid = fwd_valid_s;
endmodule |
module buffer_cell (
input wire in,
output wire out
);
assign out = in;
endmodule |
module and_cell (
input wire a,
input wire b,
output wire out
);
assign out = a & b;
endmodule |
module or_cell (
input wire a,
input wire b,
output wire out
);
assign out = a | b;
endmodule |
module xor_cell (
input wire a,
input wire b,
output wire out
);
assign out = a ^ b;
endmodule |
module nand_cell (
input wire a,
input wire b,
output wire out
);
assign out = !(a&b);
endmodule |
module not_cell (
input wire in,
output wire out
);
assign out = !in;
endmodule |
module mux_cell (
input wire a,
input wire b,
input wire sel,
output wire out
);
assign out = sel ? b : a;
endmodule |
module dff_cell (
input wire clk,
input wire d,
output reg q,
output wire notq
);
assign notq = !q;
always @(posedge clk)
q <= d;
endmodule |
module dffsr_cell (
input wire clk,
input wire d,
input wire s,
input wire r,
output reg q,
output wire notq
);
assign notq = !q;
always @(posedge clk or posedge s or posedge r) begin
if (r)
q <= 0;
else if (s)
q <= 1;
else
q <= d;
end
endmodule |
module vgasyncgen (
output reg io_h_sync,
output reg io_v_sync,
output reg io_activevideo,
output reg [9:0] io_x,
output reg [9:0] io_y,
input clk,
input reset
);
wire [9:0] _zz_h_counter_valuenext;
wire [0:0] _zz_h_counter_valuenext_1;
wire [9:0] _zz_v_counter_valuenext;
wire [0:0] _zz_v_counter_valuenext_1;
reg h_counter_willincrement;
wire h_counter_willclear;
reg [9:0] h_counter_valuenext;
reg [9:0] h_counter_value;
wire h_counter_willoverflowifinc;
wire h_counter_willoverflow;
reg v_counter_willincrement;
wire v_counter_willclear;
reg [9:0] v_counter_valuenext;
reg [9:0] v_counter_value;
wire v_counter_willoverflowifinc;
wire v_counter_willoverflow;
wire when_vgasyncgen_l29;
wire when_vgasyncgen_l36;
wire when_vgasyncgen_l44;
function zz_h_counter_willincrement(input dummy);
begin
zz_h_counter_willincrement = 1'b0; zz_h_counter_willincrement = 1'b1; end
endfunction
wire _zz_1;
assign _zz_h_counter_valuenext_1 = h_counter_willincrement;
assign _zz_h_counter_valuenext = {9'd0, _zz_h_counter_valuenext_1};
assign _zz_v_counter_valuenext_1 = v_counter_willincrement;
assign _zz_v_counter_valuenext = {9'd0, _zz_v_counter_valuenext_1};
assign _zz_1 = zz_h_counter_willincrement(1'b0);
always @(*) h_counter_willincrement = _zz_1;
assign h_counter_willclear = 1'b0; assign h_counter_willoverflowifinc = (h_counter_value == 10'h31f); assign h_counter_willoverflow = (h_counter_willoverflowifinc && h_counter_willincrement); always @(*) begin
if(h_counter_willoverflow) begin
h_counter_valuenext = 10'h0; end else begin
h_counter_valuenext = (h_counter_value + _zz_h_counter_valuenext); end
if(h_counter_willclear) begin
h_counter_valuenext = 10'h0; end
end
always @(*) begin
v_counter_willincrement = 1'b0; if(h_counter_willoverflow) begin
v_counter_willincrement = 1'b1; end
end
assign v_counter_willclear = 1'b0; assign v_counter_willoverflowifinc = (v_counter_value == 10'h20b); assign v_counter_willoverflow = (v_counter_willoverflowifinc && v_counter_willincrement); always @(*) begin
if(v_counter_willoverflow) begin
v_counter_valuenext = 10'h0; end else begin
v_counter_valuenext = (v_counter_value + _zz_v_counter_valuenext); end
if(v_counter_willclear) begin
v_counter_valuenext = 10'h0; end
end
assign when_vgasyncgen_l29 = ((10'h010 <= h_counter_value) && (h_counter_value <= 10'h070)); always @(*) begin
if(when_vgasyncgen_l29) begin
io_h_sync = 1'b0; end else begin
io_h_sync = 1'b1; end
end
assign when_vgasyncgen_l36 = ((10'h00b <= v_counter_value) && (v_counter_value <= 10'h00d)); always @(*) begin
if(when_vgasyncgen_l36) begin
io_v_sync = 1'b0; end else begin
io_v_sync = 1'b1; end
end
assign when_vgasyncgen_l44 = ((10'h0a0 <= h_counter_value) && (10'h02c <= v_counter_value)); always @(*) begin
if(when_vgasyncgen_l44) begin
io_activevideo = 1'b1; end else begin
io_activevideo = 1'b0; end
end
always @(*) begin
if(when_vgasyncgen_l44) begin
io_x = (h_counter_value - 10'h0a0); end else begin
io_x = 10'h0; end
end
always @(*) begin
if(when_vgasyncgen_l44) begin
io_y = (v_counter_value - 10'h02c); end else begin
io_y = 10'h0; end
end
always @(posedge clk or posedge reset) begin
if(reset) begin
h_counter_value <= 10'h0; v_counter_value <= 10'h0; end else begin
h_counter_value <= h_counter_valuenext; v_counter_value <= v_counter_valuenext; end
end
endmodule |
module clockcounters (
output [5:0] io_seconds,
output [5:0] io_minutes,
output [3:0] io_hours,
input clk,
input reset
);
wire [24:0] _zz_c_counter_valuenext;
wire [0:0] _zz_c_counter_valuenext_1;
wire [5:0] _zz_s_counter_valuenext;
wire [0:0] _zz_s_counter_valuenext_1;
wire [5:0] _zz_m_counter_valuenext;
wire [0:0] _zz_m_counter_valuenext_1;
wire [3:0] _zz_h_counter_valuenext;
wire [0:0] _zz_h_counter_valuenext_1;
reg c_counter_willincrement;
wire c_counter_willclear;
reg [24:0] c_counter_valuenext;
reg [24:0] c_counter_value;
wire c_counter_willoverflowifinc;
wire c_counter_willoverflow;
reg s_counter_willincrement;
wire s_counter_willclear;
reg [5:0] s_counter_valuenext;
reg [5:0] s_counter_value;
wire s_counter_willoverflowifinc;
wire s_counter_willoverflow;
reg m_counter_willincrement;
wire m_counter_willclear;
reg [5:0] m_counter_valuenext;
reg [5:0] m_counter_value;
wire m_counter_willoverflowifinc;
wire m_counter_willoverflow;
reg h_counter_willincrement;
wire h_counter_willclear;
reg [3:0] h_counter_valuenext;
reg [3:0] h_counter_value;
wire h_counter_willoverflowifinc;
wire h_counter_willoverflow;
function zz_c_counter_willincrement(input dummy);
begin
zz_c_counter_willincrement = 1'b0; zz_c_counter_willincrement = 1'b1; end
endfunction
wire _zz_1;
assign _zz_c_counter_valuenext_1 = c_counter_willincrement;
assign _zz_c_counter_valuenext = {24'd0, _zz_c_counter_valuenext_1};
assign _zz_s_counter_valuenext_1 = s_counter_willincrement;
assign _zz_s_counter_valuenext = {5'd0, _zz_s_counter_valuenext_1};
assign _zz_m_counter_valuenext_1 = m_counter_willincrement;
assign _zz_m_counter_valuenext = {5'd0, _zz_m_counter_valuenext_1};
assign _zz_h_counter_valuenext_1 = h_counter_willincrement;
assign _zz_h_counter_valuenext = {3'd0, _zz_h_counter_valuenext_1};
assign _zz_1 = zz_c_counter_willincrement(1'b0);
always @(*) c_counter_willincrement = _zz_1;
assign c_counter_willclear = 1'b0; assign c_counter_willoverflowifinc = (c_counter_value == 25'h17d783f); assign c_counter_willoverflow = (c_counter_willoverflowifinc && c_counter_willincrement); always @(*) begin
if(c_counter_willoverflow) begin
c_counter_valuenext = 25'h0; end else begin
c_counter_valuenext = (c_counter_value + _zz_c_counter_valuenext); end
if(c_counter_willclear) begin
c_counter_valuenext = 25'h0; end
end
always @(*) begin
s_counter_willincrement = 1'b0; if(c_counter_willoverflow) begin
s_counter_willincrement = 1'b1; end
end
assign s_counter_willclear = 1'b0; assign s_counter_willoverflowifinc = (s_counter_value == 6'h3b); assign s_counter_willoverflow = (s_counter_willoverflowifinc && s_counter_willincrement); always @(*) begin
if(s_counter_willoverflow) begin
s_counter_valuenext = 6'h0; end else begin
s_counter_valuenext = (s_counter_value + _zz_s_counter_valuenext); end
if(s_counter_willclear) begin
s_counter_valuenext = 6'h0; end
end
always @(*) begin
m_counter_willincrement = 1'b0; if(s_counter_willoverflow) begin
m_counter_willincrement = 1'b1; end
end
assign m_counter_willclear = 1'b0; assign m_counter_willoverflowifinc = (m_counter_value == 6'h3b); assign m_counter_willoverflow = (m_counter_willoverflowifinc && m_counter_willincrement); always @(*) begin
if(m_counter_willoverflow) begin
m_counter_valuenext = 6'h0; end else begin
m_counter_valuenext = (m_counter_value + _zz_m_counter_valuenext); end
if(m_counter_willclear) begin
m_counter_valuenext = 6'h0; end
end
always @(*) begin
h_counter_willincrement = 1'b0; if(m_counter_willoverflow) begin
h_counter_willincrement = 1'b1; end
end
assign h_counter_willclear = 1'b0; assign h_counter_willoverflowifinc = (h_counter_value == 4'b1011); assign h_counter_willoverflow = (h_counter_willoverflowifinc && h_counter_willincrement); always @(*) begin
if(h_counter_willoverflow) begin
h_counter_valuenext = 4'b0000; end else begin
h_counter_valuenext = (h_counter_value + _zz_h_counter_valuenext); end
if(h_counter_willclear) begin
h_counter_valuenext = 4'b0000; end
end
assign io_seconds = s_counter_value; assign io_minutes = m_counter_value; assign io_hours = h_counter_value; always @(posedge clk or posedge reset) begin
if(reset) begin
c_counter_value <= 25'h0; s_counter_value <= 6'h0; m_counter_value <= 6'h0; h_counter_value <= 4'b0000; end else begin
c_counter_value <= c_counter_valuenext; s_counter_value <= s_counter_valuenext; m_counter_value <= m_counter_valuenext; h_counter_value <= h_counter_valuenext; end
end
endmodule |
module e203_exu_longpwbck(
input lsu_wbck_i_valid, output lsu_wbck_i_ready, input [`e203_xlen-1:0] lsu_wbck_i_wdat,
input [`e203_itag_width -1:0] lsu_wbck_i_itag,
input lsu_wbck_i_err , input lsu_cmt_i_buserr ,
input [`e203_addr_size -1:0] lsu_cmt_i_badaddr,
input lsu_cmt_i_ld,
input lsu_cmt_i_st,
output longp_wbck_o_valid, input longp_wbck_o_ready, output [`e203_flen-1:0] longp_wbck_o_wdat,
output [5-1:0] longp_wbck_o_flags,
output [`e203_rfidx_width -1:0] longp_wbck_o_rdidx,
output longp_wbck_o_rdfpu,
output longp_excp_o_valid,
input longp_excp_o_ready,
output longp_excp_o_insterr,
output longp_excp_o_ld,
output longp_excp_o_st,
output longp_excp_o_buserr , output [`e203_addr_size-1:0] longp_excp_o_badaddr,
output [`e203_pc_size -1:0] longp_excp_o_pc,
input oitf_empty,
input [`e203_itag_width -1:0] oitf_ret_ptr,
input [`e203_rfidx_width-1:0] oitf_ret_rdidx,
input [`e203_pc_size-1:0] oitf_ret_pc,
input oitf_ret_rdwen,
input oitf_ret_rdfpu,
output oitf_ret_ena,
input clk,
input rst_n
);
wire wbck_ready4lsu = (lsu_wbck_i_itag == oitf_ret_ptr) & (~oitf_empty);
wire wbck_sel_lsu = lsu_wbck_i_valid & wbck_ready4lsu;
assign {
longp_excp_o_insterr
,longp_excp_o_ld
,longp_excp_o_st
,longp_excp_o_buserr
,longp_excp_o_badaddr } =
({`e203_addr_size+4{wbck_sel_lsu}} &
{
1'b0,
lsu_cmt_i_ld,
lsu_cmt_i_st,
lsu_cmt_i_buserr,
lsu_cmt_i_badaddr
})
;
wire wbck_i_ready;
wire wbck_i_valid;
wire [`e203_flen-1:0] wbck_i_wdat;
wire [5-1:0] wbck_i_flags;
wire [`e203_rfidx_width-1:0] wbck_i_rdidx;
wire [`e203_pc_size-1:0] wbck_i_pc;
wire wbck_i_rdwen;
wire wbck_i_rdfpu;
wire wbck_i_err ;
assign lsu_wbck_i_ready = wbck_ready4lsu & wbck_i_ready;
assign wbck_i_valid = ({1{wbck_sel_lsu}} & lsu_wbck_i_valid)
;
`ifdef e203_flen_is_32 wire [`e203_flen-1:0] lsu_wbck_i_wdat_exd = lsu_wbck_i_wdat;
`else wire [`e203_flen-1:0] lsu_wbck_i_wdat_exd = {{`e203_flen-`e203_xlen{1'b0}},lsu_wbck_i_wdat};
`endif assign wbck_i_wdat = ({`e203_flen{wbck_sel_lsu}} & lsu_wbck_i_wdat_exd )
;
assign wbck_i_flags = 5'b0
;
assign wbck_i_err = wbck_sel_lsu & lsu_wbck_i_err
;
assign wbck_i_pc = oitf_ret_pc;
assign wbck_i_rdidx = oitf_ret_rdidx;
assign wbck_i_rdwen = oitf_ret_rdwen;
assign wbck_i_rdfpu = oitf_ret_rdfpu;
wire need_wbck = wbck_i_rdwen & (~wbck_i_err);
wire need_excp = wbck_i_err;
assign wbck_i_ready =
(need_wbck ? longp_wbck_o_ready : 1'b1)
& (need_excp ? longp_excp_o_ready : 1'b1);
assign longp_wbck_o_valid = need_wbck & wbck_i_valid & (need_excp ? longp_excp_o_ready : 1'b1);
assign longp_excp_o_valid = need_excp & wbck_i_valid & (need_wbck ? longp_wbck_o_ready : 1'b1);
assign longp_wbck_o_wdat = wbck_i_wdat ;
assign longp_wbck_o_flags = wbck_i_flags ;
assign longp_wbck_o_rdfpu = wbck_i_rdfpu ;
assign longp_wbck_o_rdidx = wbck_i_rdidx;
assign longp_excp_o_pc = wbck_i_pc;
assign oitf_ret_ena = wbck_i_valid & wbck_i_ready;
endmodule |
module e203_exu_wbck(
input alu_wbck_i_valid, output alu_wbck_i_ready, input [`e203_xlen-1:0] alu_wbck_i_wdat,
input [`e203_rfidx_width-1:0] alu_wbck_i_rdidx,
input longp_wbck_i_valid, output longp_wbck_i_ready, input [`e203_flen-1:0] longp_wbck_i_wdat,
input [5-1:0] longp_wbck_i_flags,
input [`e203_rfidx_width-1:0] longp_wbck_i_rdidx,
input longp_wbck_i_rdfpu,
output rf_wbck_o_ena,
output [`e203_xlen-1:0] rf_wbck_o_wdat,
output [`e203_rfidx_width-1:0] rf_wbck_o_rdidx,
input clk,
input rst_n
);
wire wbck_ready4alu = (~longp_wbck_i_valid);
wire wbck_sel_alu = alu_wbck_i_valid & wbck_ready4alu;
wire wbck_ready4longp = 1'b1;
wire wbck_sel_longp = longp_wbck_i_valid & wbck_ready4longp;
wire rf_wbck_o_ready = 1'b1;
wire wbck_i_ready;
wire wbck_i_valid;
wire [`e203_flen-1:0] wbck_i_wdat;
wire [5-1:0] wbck_i_flags;
wire [`e203_rfidx_width-1:0] wbck_i_rdidx;
wire wbck_i_rdfpu;
assign alu_wbck_i_ready = wbck_ready4alu & wbck_i_ready;
assign longp_wbck_i_ready = wbck_ready4longp & wbck_i_ready;
assign wbck_i_valid = wbck_sel_alu ? alu_wbck_i_valid : longp_wbck_i_valid;
`ifdef e203_flen_is_32 assign wbck_i_wdat = wbck_sel_alu ? alu_wbck_i_wdat : longp_wbck_i_wdat;
`else assign wbck_i_wdat = wbck_sel_alu ? {{`e203_flen-`e203_xlen{1'b0}},alu_wbck_i_wdat} : longp_wbck_i_wdat;
`endif assign wbck_i_flags = wbck_sel_alu ? 5'b0 : longp_wbck_i_flags;
assign wbck_i_rdidx = wbck_sel_alu ? alu_wbck_i_rdidx : longp_wbck_i_rdidx;
assign wbck_i_rdfpu = wbck_sel_alu ? 1'b0 : longp_wbck_i_rdfpu;
assign wbck_i_ready = rf_wbck_o_ready;
wire rf_wbck_o_valid = wbck_i_valid;
wire wbck_o_ena = rf_wbck_o_valid & rf_wbck_o_ready;
assign rf_wbck_o_ena = wbck_o_ena & (~wbck_i_rdfpu);
assign rf_wbck_o_wdat = wbck_i_wdat[`e203_xlen-1:0];
assign rf_wbck_o_rdidx = wbck_i_rdidx;
endmodule |
module e203_irq_sync #(
parameter master = 1
) (
input clk,
input rst_n,
input ext_irq_a,
input sft_irq_a,
input tmr_irq_a,
input dbg_irq_a,
output ext_irq_r,
output sft_irq_r,
output tmr_irq_r,
output dbg_irq_r
);
generate
if(master == 1) begin:master_gen
`ifndef e203_has_lockstep `ifdef e203_irq_need_sync sirv_gnrl_sync # (
.dp(`e203_async_ff_levels),
.dw(1)
) u_dbg_irq_sync(
.din_a (dbg_irq_a),
.dout (dbg_irq_r),
.clk (clk ),
.rst_n (rst_n)
);
sirv_gnrl_sync # (
.dp(`e203_async_ff_levels),
.dw(1)
) u_ext_irq_sync(
.din_a (ext_irq_a),
.dout (ext_irq_r),
.clk (clk ),
.rst_n (rst_n)
);
sirv_gnrl_sync # (
.dp(`e203_async_ff_levels),
.dw(1)
) u_sft_irq_sync(
.din_a (sft_irq_a),
.dout (sft_irq_r),
.clk (clk ),
.rst_n (rst_n)
);
sirv_gnrl_sync # (
.dp(`e203_async_ff_levels),
.dw(1)
) u_tmr_irq_sync(
.din_a (tmr_irq_a),
.dout (tmr_irq_r),
.clk (clk ),
.rst_n (rst_n)
);
`else assign ext_irq_r = ext_irq_a;
assign sft_irq_r = sft_irq_a;
assign tmr_irq_r = tmr_irq_a;
assign dbg_irq_r = dbg_irq_a;
`endif `endif
end
else begin:slave_gen
assign ext_irq_r = ext_irq_a;
assign sft_irq_r = sft_irq_a;
assign tmr_irq_r = tmr_irq_a;
assign dbg_irq_r = dbg_irq_a;
end
endgenerate
endmodule |
module memory#(
parameter bits = 32
)(
input clk,
input rst,
input read_e,
input write_e,
input [31:0] data_in,
input [31:0] addr_in,
output reg ready,
output reg [575:0] ram_data_o
);
reg [575:0] enc_data;
reg [5:0] counter = 0;
always @(posedge clk)
begin
if(rst)
begin
ram_data_o <= 32'b0;
enc_data <= 32'b0;
counter <= 6'b0;
ready <= 0;
end
else
begin
if (read_e & !write_e & ready)
begin
if (addr_in == 32'h55)
begin
ram_data_o <= enc_data;
end
end
end
end
always @(posedge clk)
begin
if (!read_e & write_e & !ready & !rst)
begin
if (addr_in == 32'h55)
begin
if (counter<18)
begin
if (counter == 0)
enc_data[31:0] <= data_in[31:0];
else if (counter == 1)
enc_data[63:32] <= data_in[31:0];
else if (counter == 2)
enc_data[95:64] <= data_in[31:0];
else if (counter == 3)
enc_data[127:96] <= data_in[31:0];
else if (counter == 4)
enc_data[159:128] <= data_in[31:0];
else if (counter == 5)
enc_data[191:160] <= data_in[31:0];
else if (counter == 6)
enc_data[223:192] <= data_in[31:0];
else if (counter == 7)
enc_data[255:224] <= data_in[31:0];
else if (counter == 8)
enc_data[287:256] <= data_in[31:0];
else if (counter == 9)
enc_data[319:288] <= data_in[31:0];
else if (counter == 10)
enc_data[351:320] <= data_in[31:0];
else if (counter == 11)
enc_data[383:352] <= data_in[31:0];
else if (counter == 12)
enc_data[415:384] <= data_in[31:0];
else if (counter == 13)
enc_data[447:416] <= data_in[31:0];
else if (counter == 14)
enc_data[479:448] <= data_in[31:0];
else if (counter == 15)
enc_data[511:480] <= data_in[31:0];
else if (counter == 16)
enc_data[543:512] <= data_in[31:0];
else if (counter == 17)
begin
enc_data[575:544] <= data_in[31:0];
ready <= 1;
end
counter = counter + 1;
end
else
ready <= 1;
end
end
end
endmodule |
module theta_rho_pi_chi_iota(
input clk,
input rst,
input [1023:0] c_in,
input [575:0] x_data_in,
output reg [575:0] r_o,
output reg ready
);
reg [63:0] cube [4:0][4:0];
reg [2:0] step = 0;
reg [4:0] round;
reg [2:0] rst_counter = 0;
reg [2:0] rst_counter_1 = 0;
reg [2:0] rst_counter_2 = 0;
reg [2:0] rst_counter_3 = 0;
reg [2:0] rst_counter_4 = 0;
reg [63:0] b [4:0][4:0];
reg [63:0] c [4:0];
reg [63:0] d [4:0];
reg [2:0] c_counter = 0;
reg [2:0] d_counter = 0;
reg [2:0] a_counter = 0;
always @ (posedge clk)
begin
if(rst)
begin
r_o <= 0;
step <= 0;
round <= 0;
ready <= 0;
for(rst_counter_4=0; rst_counter_4<=4; rst_counter_4=rst_counter_4+1)
begin
c[rst_counter_4] <= 0;
d[rst_counter_4] <= 0;
end
for(rst_counter=0; rst_counter<=4; rst_counter=rst_counter+1)
begin
for(rst_counter_3=0; rst_counter_3<=4; rst_counter_3=rst_counter_3+1)
begin
b[rst_counter][rst_counter_3] <= 0;
end
end
for(rst_counter_1=0; rst_counter_1<=4; rst_counter_1=rst_counter_1+1)
begin
for(rst_counter_2=0; rst_counter_2<=4; rst_counter_2=rst_counter_2+1)
begin
cube[rst_counter_1][rst_counter_2] <= 0;
end
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step==0)
begin
ready <= 0;
cube[0][0] <= x_data_in[63:0];
cube[0][1] <= x_data_in[127:64];
cube[0][2] <= x_data_in[191:128];
cube[0][3] <= x_data_in[255:192];
cube[0][4] <= x_data_in[319:256];
cube[1][0] <= x_data_in[383:320];
cube[1][1] <= x_data_in[447:384];
cube[1][2] <= x_data_in[511:448];
cube[1][3] <= x_data_in[575:512];
cube[1][4] <= c_in[63:0];
cube[2][0] <= c_in[127:64];
cube[2][1] <= c_in[191:128];
cube[2][2] <= c_in[255:192];
cube[2][3] <= c_in[319:256];
cube[2][4] <= c_in[383:320];
cube[3][0] <= c_in[447:384];
cube[3][1] <= c_in[511:448];
cube[3][2] <= c_in[575:512];
cube[3][3] <= c_in[639:576];
cube[3][4] <= c_in[703:640];
cube[4][0] <= c_in[767:704];
cube[4][1] <= c_in[831:768];
cube[4][2] <= c_in[895:832];
cube[4][3] <= c_in[959:896];
cube[4][4] <= c_in[1023:960];
step <= 1;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 1)
begin
for(c_counter=0; c_counter<=4; c_counter=c_counter+1)
begin
c[c_counter] <= cube[c_counter][0] ^ cube[c_counter][1] ^ cube[c_counter][2] ^ cube[c_counter][3];
end
step <= 2;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 2)
begin
d[0] <= ({c[1][0],c[1][63:1]}) ^ c[4];
d[1] <= ({c[2][0],c[2][63:1]}) ^ c[0];
d[2] <= ({c[3][0],c[3][63:1]}) ^ c[1];
d[3] <= ({c[4][0],c[4][63:1]}) ^ c[2];
d[4] <= ({c[0][0],c[0][63:1]}) ^ c[3];
step <= 3;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 3)
begin
for(a_counter=0; a_counter<=4; a_counter=a_counter+1)
begin
for(d_counter=0; d_counter<=4; d_counter=d_counter+1)
begin
cube[a_counter][d_counter] <= cube[a_counter][d_counter] ^ d[a_counter];
end
end
step <= 4;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step==4)
begin
b[0][0] <= cube[0][0];
b[0][1] <= {cube[3][0][27:0],cube[3][0][63:28]};
b[0][2] <= {cube[1][0][0],cube[1][0][63:1]};
b[0][3] <= {cube[4][0][26:0],cube[4][0][63:27]};
b[0][4] <= {cube[2][0][61:0],cube[2][0][63:62]};
b[1][0] <= {cube[1][1][43:0],cube[1][1][63:44]};
b[1][1] <= {cube[4][1][19:0],cube[4][1][63:20]};
b[1][2] <= {cube[2][1][5:0],cube[2][1][63:6]};
b[1][3] <= {cube[0][1][35:0],cube[0][1][63:36]};
b[1][4] <= {cube[3][1][54:0],cube[3][1][63:55]};
b[2][0] <= {cube[2][2][42:0],cube[2][2][63:43]};
b[2][1] <= {cube[0][2][2:0],cube[0][2][63:3]};
b[2][2] <= {cube[3][2][24:0],cube[3][2][63:25]};
b[2][3] <= {cube[1][2][9:0],cube[1][2][63:10]};
b[2][4] <= {cube[4][2][38:0],cube[4][2][63:39]};
b[3][0] <= {cube[3][3][20:0],cube[3][3][63:21]};
b[3][1] <= {cube[1][3][44:0],cube[1][3][63:45]};
b[3][2] <= {cube[4][3][7:0],cube[4][3][63:8]};
b[3][3] <= {cube[2][3][14:0],cube[2][3][63:14]};
b[3][4] <= {cube[0][3][40:0],cube[0][3][63:41]};
b[4][0] <= {cube[4][4][13:0],cube[4][4][63:14]};
b[4][1] <= {cube[2][4][60:0],cube[2][4][63:61]};
b[4][2] <= {cube[0][4][17:0],cube[0][1][63:18]};
b[4][3] <= {cube[3][4][55:0],cube[3][4][63:56]};
b[4][4] <= {cube[1][4][1:0],cube[1][4][63:2]};
step <= 5;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 5)
begin
cube[0][0] <= b[0][0] ^ (~b[1][0] & b[2][0]);
cube[0][1] <= b[0][1] ^ (~b[1][1] & b[2][1]);
cube[0][2] <= b[0][2] ^ (~b[1][2] & b[2][2]);
cube[0][3] <= b[0][3] ^ (~b[1][3] & b[2][3]);
cube[0][4] <= b[0][4] ^ (~b[1][4] & b[2][4]);
cube[1][0] <= b[1][0] ^ (~b[2][0] & b[3][0]);
cube[1][1] <= b[1][1] ^ (~b[2][1] & b[3][1]);
cube[1][2] <= b[1][2] ^ (~b[2][2] & b[3][2]);
cube[1][3] <= b[1][3] ^ (~b[2][3] & b[3][3]);
cube[1][4] <= b[1][4] ^ (~b[2][4] & b[3][4]);
cube[2][0] <= b[2][0] ^ (~b[3][0] & b[4][0]);
cube[2][1] <= b[2][1] ^ (~b[3][1] & b[4][1]);
cube[2][2] <= b[2][2] ^ (~b[3][2] & b[4][2]);
cube[2][3] <= b[2][3] ^ (~b[3][3] & b[4][3]);
cube[2][4] <= b[2][4] ^ (~b[3][4] & b[4][4]);
cube[3][0] <= b[3][0] ^ (~b[4][0] & b[0][0]);
cube[3][1] <= b[3][1] ^ (~b[4][1] & b[0][1]);
cube[3][2] <= b[3][2] ^ (~b[4][2] & b[0][2]);
cube[3][3] <= b[3][3] ^ (~b[4][3] & b[0][3]);
cube[3][4] <= b[3][4] ^ (~b[4][4] & b[0][4]);
cube[4][0] <= b[4][0] ^ (~b[0][0] & b[1][0]);
cube[4][1] <= b[4][1] ^ (~b[0][1] & b[1][1]);
cube[4][2] <= b[4][2] ^ (~b[0][2] & b[1][2]);
cube[4][3] <= b[4][3] ^ (~b[0][3] & b[1][3]);
cube[4][4] <= b[4][4] ^ (~b[0][4] & b[1][4]);
step <= 6;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 6)
begin
if (round == 0)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000000000001;
end
else if(round==1)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000000008082;
end
else if(round==2)
begin
cube[0][0] <= cube[0][0] ^ 64'h800000000000808a;
end
else if(round==3)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000080008000;
end
else if(round==4)
begin
cube[0][0] <= cube[0][0] ^ 64'h000000000000808b;
end
else if(round==5)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000080000001;
end
else if(round==6)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000080008081;
end
else if(round==7)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000008009;
end
else if(round==8)
begin
cube[0][0] <= cube[0][0] ^ 64'h000000000000008a;
end
else if(round==9)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000000000088;
end
else if(round==10)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000080008009;
end
else if(round==11)
begin
cube[0][0] <= cube[0][0] ^ 64'h000000008000000a;
end
else if(round==12)
begin
cube[0][0] <= cube[0][0] ^ 64'h000000008000808b;
end
else if(round==13)
begin
cube[0][0] <= cube[0][0] ^ 64'h800000000000008b;
end
else if(round==14)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000008089;
end
else if(round==15)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000008003;
end
else if(round==16)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000008002;
end
else if(round==17)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000000080;
end
else if(round==18)
begin
cube[0][0] <= cube[0][0] ^ 64'h000000000000800a;
end
else if(round==19)
begin
cube[0][0] <= cube[0][0] ^ 64'h800000008000000a;
end
else if(round==20)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000080008081;
end
else if(round==21)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000000008080;
end
else if(round==22)
begin
cube[0][0] <= cube[0][0] ^ 64'h0000000080000001;
end
else if(round==23)
begin
cube[0][0] <= cube[0][0] ^ 64'h8000000080008008;
end
else
begin
cube[0][0] <= 0;
end
step <= 7;
end
end
end
always @(posedge clk)
begin
if(!rst)
begin
if(step == 7)
begin
if (round < 23)
begin
step <= 1;
round <= round + 1;
end
else
begin
r_o[63:0] <= cube[0][0];
r_o[127:64] <= cube[0][1];
r_o[191:128] <= cube[0][2];
r_o[255:192] <= cube[0][3];
r_o[319:256] <= cube[0][4];
r_o[383:320] <= cube[1][0];
r_o[447:384] <= cube[1][1];
r_o[511:448] <= cube[1][2];
r_o[575:512] <= cube[1][3];
ready <= 1;
end
end
end
end
endmodule |
module x_o(
input clk,
input rst,
input [575:0] data_in,
input [575:0] r_in,
output reg [575:0] x_data_o
);
always @ (posedge clk)
begin
if (rst)
x_data_o <= 0;
else if (!rst)
x_data_o <= (r_in ^ data_in);
end
endmodule |
module e203_clkgate (
input clk_in,
input test_mode,
input clock_en,
output clk_out
);
`ifdef fpga_source assign clk_out = clk_in;
`endif
`ifndef fpga_source
reg enb;
always@(*)
if (!clk_in)
enb = (clock_en | test_mode);
assign clk_out = enb & clk_in;
`endif
endmodule |
module e203_extend_csr(
input nice_csr_valid,
output nice_csr_ready,
input [31:0] nice_csr_addr,
input nice_csr_wr,
input [31:0] nice_csr_wdata,
output [31:0] nice_csr_rdata,
input clk,
input rst_n
);
assign nice_csr_ready = 1'b1;
assign nice_csr_rdata = 32'b0;
endmodule |
module e203_srams(
`ifdef e203_has_itcm input itcm_ram_sd,
input itcm_ram_ds,
input itcm_ram_ls,
input itcm_ram_cs,
input itcm_ram_we,
input [`e203_itcm_ram_aw-1:0] itcm_ram_addr,
input [`e203_itcm_ram_mw-1:0] itcm_ram_wem,
input [`e203_itcm_ram_dw-1:0] itcm_ram_din,
output [`e203_itcm_ram_dw-1:0] itcm_ram_dout,
input clk_itcm_ram,
input rst_itcm,
`endif
`ifdef e203_has_dtcm input dtcm_ram_sd,
input dtcm_ram_ds,
input dtcm_ram_ls,
input dtcm_ram_cs,
input dtcm_ram_we,
input [`e203_dtcm_ram_aw-1:0] dtcm_ram_addr,
input [`e203_dtcm_ram_mw-1:0] dtcm_ram_wem,
input [`e203_dtcm_ram_dw-1:0] dtcm_ram_din,
output [`e203_dtcm_ram_dw-1:0] dtcm_ram_dout,
input clk_dtcm_ram,
input rst_dtcm,
`endif
input test_mode
);
`ifdef e203_has_itcm wire [`e203_itcm_ram_dw-1:0] itcm_ram_dout_pre;
e203_itcm_ram u_e203_itcm_ram (
.sd (itcm_ram_sd),
.ds (itcm_ram_ds),
.ls (itcm_ram_ls),
.cs (itcm_ram_cs ),
.we (itcm_ram_we ),
.addr (itcm_ram_addr ),
.wem (itcm_ram_wem ),
.din (itcm_ram_din ),
.dout (itcm_ram_dout_pre ),
.rst_n(rst_itcm ),
.clk (clk_itcm_ram )
);
assign itcm_ram_dout = itcm_ram_dout_pre;
`endif
`ifdef e203_has_dtcm wire [`e203_dtcm_ram_dw-1:0] dtcm_ram_dout_pre;
e203_dtcm_ram u_e203_dtcm_ram (
.sd (dtcm_ram_sd),
.ds (dtcm_ram_ds),
.ls (dtcm_ram_ls),
.cs (dtcm_ram_cs ),
.we (dtcm_ram_we ),
.addr (dtcm_ram_addr ),
.wem (dtcm_ram_wem ),
.din (dtcm_ram_din ),
.dout (dtcm_ram_dout_pre ),
.rst_n(rst_dtcm ),
.clk (clk_dtcm_ram )
);
assign dtcm_ram_dout = dtcm_ram_dout_pre;
`endif
endmodule |
module sirv_debug_rom(
input [7-1:2] rom_addr,
output [32-1:0] rom_dout
);
wire [31:0] debug_rom [0:28];
assign rom_dout = debug_rom[rom_addr];
assign debug_rom[ 0][7 : 0] = 8'h6f;
assign debug_rom[ 0][15: 8] = 8'h00;
assign debug_rom[ 0][23:16] = 8'hc0;
assign debug_rom[ 0][31:24] = 8'h03;
assign debug_rom[ 1][7 : 0] = 8'h6f;
assign debug_rom[ 1][15: 8] = 8'h00;
assign debug_rom[ 1][23:16] = 8'hc0;
assign debug_rom[ 1][31:24] = 8'h00;
assign debug_rom[ 2][7 : 0] = 8'h13;
assign debug_rom[ 2][15: 8] = 8'h04;
assign debug_rom[ 2][23:16] = 8'hf0;
assign debug_rom[ 2][31:24] = 8'hff;
assign debug_rom[ 3][7 : 0] = 8'h6f;
assign debug_rom[ 3][15: 8] = 8'h00;
assign debug_rom[ 3][23:16] = 8'h80;
assign debug_rom[ 3][31:24] = 8'h00;
assign debug_rom[ 4][7 : 0] = 8'h13;
assign debug_rom[ 4][15: 8] = 8'h04;
assign debug_rom[ 4][23:16] = 8'h00;
assign debug_rom[ 4][31:24] = 8'h00;
assign debug_rom[ 5][7 : 0] = 8'h0f;
assign debug_rom[ 5][15: 8] = 8'h00;
assign debug_rom[ 5][23:16] = 8'hf0;
assign debug_rom[ 5][31:24] = 8'h0f;
assign debug_rom[ 6][7 : 0] = 8'h83;
assign debug_rom[ 6][15: 8] = 8'h24;
assign debug_rom[ 6][23:16] = 8'h80;
assign debug_rom[ 6][31:24] = 8'h41;
assign debug_rom[ 7][7 : 0] = 8'h23;
assign debug_rom[ 7][15: 8] = 8'h2c;
assign debug_rom[ 7][23:16] = 8'h80;
assign debug_rom[ 7][31:24] = 8'h40;
assign debug_rom[ 8][7 : 0] = 8'h73;
assign debug_rom[ 8][15: 8] = 8'h24;
assign debug_rom[ 8][23:16] = 8'h40;
assign debug_rom[ 8][31:24] = 8'hf1;
assign debug_rom[ 9][7 : 0] = 8'h23;
assign debug_rom[ 9][15: 8] = 8'h20;
assign debug_rom[ 9][23:16] = 8'h80;
assign debug_rom[ 9][31:24] = 8'h10;
assign debug_rom[10][7 : 0] = 8'h73;
assign debug_rom[10][15: 8] = 8'h24;
assign debug_rom[10][23:16] = 8'h00;
assign debug_rom[10][31:24] = 8'h7b;
assign debug_rom[11][7 : 0] = 8'h13;
assign debug_rom[11][15: 8] = 8'h74;
assign debug_rom[11][23:16] = 8'h84;
assign debug_rom[11][31:24] = 8'h00;
assign debug_rom[12][7 : 0] = 8'h63;
assign debug_rom[12][15: 8] = 8'h1a;
assign debug_rom[12][23:16] = 8'h04;
assign debug_rom[12][31:24] = 8'h02;
assign debug_rom[13][7 : 0] = 8'h73;
assign debug_rom[13][15: 8] = 8'h24;
assign debug_rom[13][23:16] = 8'h20;
assign debug_rom[13][31:24] = 8'h7b;
assign debug_rom[14][7 : 0] = 8'h73;
assign debug_rom[14][15: 8] = 8'h00;
assign debug_rom[14][23:16] = 8'h20;
assign debug_rom[14][31:24] = 8'h7b;
assign debug_rom[15][7 : 0] = 8'h73;
assign debug_rom[15][15: 8] = 8'h10;
assign debug_rom[15][23:16] = 8'h24;
assign debug_rom[15][31:24] = 8'h7b;
assign debug_rom[16][7 : 0] = 8'h73;
assign debug_rom[16][15: 8] = 8'h24;
assign debug_rom[16][23:16] = 8'h00;
assign debug_rom[16][31:24] = 8'h7b;
assign debug_rom[17][7 : 0] = 8'h13;
assign debug_rom[17][15: 8] = 8'h74;
assign debug_rom[17][23:16] = 8'h04;
assign debug_rom[17][31:24] = 8'h1c;
assign debug_rom[18][7 : 0] = 8'h13;
assign debug_rom[18][15: 8] = 8'h04;
assign debug_rom[18][23:16] = 8'h04;
assign debug_rom[18][31:24] = 8'hf4;
assign debug_rom[19][7 : 0] = 8'h63;
assign debug_rom[19][15: 8] = 8'h16;
assign debug_rom[19][23:16] = 8'h04;
assign debug_rom[19][31:24] = 8'h00;
assign debug_rom[20][7 : 0] = 8'h23;
assign debug_rom[20][15: 8] = 8'h2c;
assign debug_rom[20][23:16] = 8'h90;
assign debug_rom[20][31:24] = 8'h40;
assign debug_rom[21][7 : 0] = 8'h67;
assign debug_rom[21][15: 8] = 8'h00;
assign debug_rom[21][23:16] = 8'h00;
assign debug_rom[21][31:24] = 8'h40;
assign debug_rom[22][7 : 0] = 8'h73;
assign debug_rom[22][15: 8] = 8'h24;
assign debug_rom[22][23:16] = 8'h40;
assign debug_rom[22][31:24] = 8'hf1;
assign debug_rom[23][7 : 0] = 8'h23;
assign debug_rom[23][15: 8] = 8'h26;
assign debug_rom[23][23:16] = 8'h80;
assign debug_rom[23][31:24] = 8'h10;
assign debug_rom[24][7 : 0] = 8'h73;
assign debug_rom[24][15: 8] = 8'h60;
assign debug_rom[24][23:16] = 8'h04;
assign debug_rom[24][31:24] = 8'h7b;
assign debug_rom[25][7 : 0] = 8'h73;
assign debug_rom[25][15: 8] = 8'h24;
assign debug_rom[25][23:16] = 8'h00;
assign debug_rom[25][31:24] = 8'h7b;
assign debug_rom[26][7 : 0] = 8'h13;
assign debug_rom[26][15: 8] = 8'h74;
assign debug_rom[26][23:16] = 8'h04;
assign debug_rom[26][31:24] = 8'h02;
assign debug_rom[27][7 : 0] = 8'he3;
assign debug_rom[27][15: 8] = 8'h0c;
assign debug_rom[27][23:16] = 8'h04;
assign debug_rom[27][31:24] = 8'hfe;
assign debug_rom[28][7 : 0] = 8'h6f;
assign debug_rom[28][15: 8] = 8'hf0;
assign debug_rom[28][23:16] = 8'h1f;
assign debug_rom[28][31:24] = 8'hfe;
endmodule |
module sirv_gnrl_dffrs # (
parameter dw = 32
) (
input [dw-1:0] dnxt,
output [dw-1:0] qout,
input clk,
input rst_n
);
reg [dw-1:0] qout_r;
always @(posedge clk or negedge rst_n)
begin : dffrs_proc
if (rst_n == 1'b0)
qout_r <= {dw{1'b1}};
else
qout_r <= #1 dnxt;
end
assign qout = qout_r;
endmodule |
module sirv_gnrl_dffr # (
parameter dw = 32
) (
input [dw-1:0] dnxt,
output [dw-1:0] qout,
input clk,
input rst_n
);
reg [dw-1:0] qout_r;
always @(posedge clk or negedge rst_n)
begin : dffr_proc
if (rst_n == 1'b0)
qout_r <= {dw{1'b0}};
else
qout_r <= #1 dnxt;
end
assign qout = qout_r;
endmodule |
module sirv_sim_ram
#(parameter dp = 512,
parameter force_x2zero = 0,
parameter dw = 32,
parameter mw = 4,
parameter aw = 32
)
(
input clk,
input [dw-1 :0] din,
input [aw-1 :0] addr,
input cs,
input we,
input [mw-1:0] wem,
output [dw-1:0] dout
);
reg [dw-1:0] mem_r [0:dp-1];
reg [aw-1:0] addr_r;
wire [mw-1:0] wen;
wire ren;
assign ren = cs & (~we);
assign wen = ({mw{cs & we}} & wem);
genvar i;
always @(posedge clk)
begin
if (ren) begin
addr_r <= addr;
end
end
generate
for (i = 0; i < mw; i = i+1) begin :mem
if((8*i+8) > dw ) begin: last
always @(posedge clk) begin
if (wen[i]) begin
mem_r[addr][dw-1:8*i] <= din[dw-1:8*i];
end
end
end
else begin: non_last
always @(posedge clk) begin
if (wen[i]) begin
mem_r[addr][8*i+7:8*i] <= din[8*i+7:8*i];
end
end
end
end
endgenerate
wire [dw-1:0] dout_pre;
assign dout_pre = mem_r[addr_r];
generate
if(force_x2zero == 1) begin: force_x_to_zero
for (i = 0; i < dw; i = i+1) begin:force_x_gen
`ifndef synthesis assign dout[i] = (dout_pre[i] === 1'bx) ? 1'b0 : dout_pre[i];
`else assign dout[i] = dout_pre[i];
`endif end
end
else begin:no_force_x_to_zero
assign dout = dout_pre;
end
endgenerate
endmodule |
module sirv_mrom # (
parameter aw = 12,
parameter dw = 32,
parameter dp = 1024
)(
input [aw-1:2] rom_addr,
output [dw-1:0] rom_dout
);
wire [31:0] mask_rom [0:dp-1];
assign rom_dout = mask_rom[rom_addr];
genvar i;
generate
if(1) begin: jump_to_ram_gen
for (i=0;i<1024;i=i+1) begin: rom_gen
if(i==0) begin: rom0_gen
assign mask_rom[i] = 32'h7ffff297; end
else if(i==1) begin: rom1_gen
assign mask_rom[i] = 32'h00028067; end
else begin: rom_non01_gen
assign mask_rom[i] = 32'h00000000;
end
end
end
else begin: jump_to_non_ram_gen
for (i=0;i<1024;i=i+1) begin: rom_gen
if(i==0) begin: rom0_gen
assign mask_rom[i] = 32'h100006f;
end
else if(i==1) begin: rom1_gen
assign mask_rom[i] = 32'h13;
end
else if(i==2) begin: rom1_gen
assign mask_rom[i] = 32'h13;
end
else if(i==3) begin: rom1_gen
assign mask_rom[i] = 32'h6661; end
else if(i==4) begin: rom1_gen
assign mask_rom[i] = 32'h20400000 | 32'h000002b7;
end
else if(i==5) begin: rom1_gen
assign mask_rom[i] = 32'h28067;
end
else begin: rom_non01_gen
assign mask_rom[i] = 32'h00000000;
end
end
end
endgenerate
endmodule |
module sirv_aon_porrst(
output porrst_n
);
`ifdef fpga_source assign porrst_n = 1'b1;
`else assign porrst_n = 1'b1;
`endif
endmodule |
module sirv_asyncresetreg (
input d,
output reg q,
input en,
input clk,
input rst);
always @(posedge clk or posedge rst) begin
if (rst) begin
q <= 1'b0;
end else if (en) begin
q <= d;
end
end
endmodule |
module sirv_clint(
input clock,
input reset,
output io_in_0_a_ready,
input io_in_0_a_valid,
input [2:0] io_in_0_a_bits_opcode,
input [2:0] io_in_0_a_bits_param,
input [2:0] io_in_0_a_bits_size,
input [4:0] io_in_0_a_bits_source,
input [25:0] io_in_0_a_bits_address,
input [3:0] io_in_0_a_bits_mask,
input [31:0] io_in_0_a_bits_data,
input io_in_0_b_ready,
output io_in_0_b_valid,
output [2:0] io_in_0_b_bits_opcode,
output [1:0] io_in_0_b_bits_param,
output [2:0] io_in_0_b_bits_size,
output [4:0] io_in_0_b_bits_source,
output [25:0] io_in_0_b_bits_address,
output [3:0] io_in_0_b_bits_mask,
output [31:0] io_in_0_b_bits_data,
output io_in_0_c_ready,
input io_in_0_c_valid,
input [2:0] io_in_0_c_bits_opcode,
input [2:0] io_in_0_c_bits_param,
input [2:0] io_in_0_c_bits_size,
input [4:0] io_in_0_c_bits_source,
input [25:0] io_in_0_c_bits_address,
input [31:0] io_in_0_c_bits_data,
input io_in_0_c_bits_error,
input io_in_0_d_ready,
output io_in_0_d_valid,
output [2:0] io_in_0_d_bits_opcode,
output [1:0] io_in_0_d_bits_param,
output [2:0] io_in_0_d_bits_size,
output [4:0] io_in_0_d_bits_source,
output io_in_0_d_bits_sink,
output [1:0] io_in_0_d_bits_addr_lo,
output [31:0] io_in_0_d_bits_data,
output io_in_0_d_bits_error,
output io_in_0_e_ready,
input io_in_0_e_valid,
input io_in_0_e_bits_sink,
output io_tiles_0_mtip,
output io_tiles_0_msip,
input io_rtctick
);
reg [31:0] time_0;
reg [31:0] gen_62;
reg [31:0] time_1;
reg [31:0] gen_63;
wire [63:0] t_904;
wire [64:0] t_906;
wire [63:0] t_907;
wire [31:0] t_909;
wire [63:0] gen_6;
wire [31:0] gen_7;
reg [31:0] timecmp_0_0;
reg [31:0] gen_64;
reg [31:0] timecmp_0_1;
reg [31:0] gen_65;
reg ipi_0;
reg [31:0] gen_66;
wire [63:0] t_915;
wire t_916;
wire t_940_ready;
wire t_940_valid;
wire t_940_bits_read;
wire [13:0] t_940_bits_index;
wire [31:0] t_940_bits_data;
wire [3:0] t_940_bits_mask;
wire [9:0] t_940_bits_extra;
wire t_957;
wire [23:0] t_958;
wire [1:0] t_959;
wire [6:0] t_960;
wire [9:0] t_961;
wire t_979_ready;
wire t_979_valid;
wire t_979_bits_read;
wire [31:0] t_979_bits_data;
wire [9:0] t_979_bits_extra;
wire t_1015_ready;
wire t_1015_valid;
wire t_1015_bits_read;
wire [13:0] t_1015_bits_index;
wire [31:0] t_1015_bits_data;
wire [3:0] t_1015_bits_mask;
wire [9:0] t_1015_bits_extra;
wire t_1058_0;
wire t_1058_1;
wire t_1058_2;
wire t_1058_3;
wire t_1058_4;
wire t_1063_0;
wire t_1063_1;
wire t_1063_2;
wire t_1063_3;
wire t_1063_4;
wire t_1068_0;
wire t_1068_1;
wire t_1068_2;
wire t_1068_3;
wire t_1068_4;
wire t_1073_0;
wire t_1073_1;
wire t_1073_2;
wire t_1073_3;
wire t_1073_4;
wire t_1078_0;
wire t_1078_1;
wire t_1078_2;
wire t_1078_3;
wire t_1078_4;
wire t_1083_0;
wire t_1083_1;
wire t_1083_2;
wire t_1083_3;
wire t_1083_4;
wire t_1088_0;
wire t_1088_1;
wire t_1088_2;
wire t_1088_3;
wire t_1088_4;
wire t_1093_0;
wire t_1093_1;
wire t_1093_2;
wire t_1093_3;
wire t_1093_4;
wire t_1135;
wire t_1136;
wire t_1137;
wire t_1138;
wire [7:0] t_1142;
wire [7:0] t_1146;
wire [7:0] t_1150;
wire [7:0] t_1154;
wire [15:0] t_1155;
wire [15:0] t_1156;
wire [31:0] t_1157;
wire [31:0] t_1185;
wire t_1187;
wire t_1200;
wire [31:0] gen_8;
wire [31:0] t_1219;
wire t_1240;
wire [31:0] gen_9;
wire t_1280;
wire [63:0] gen_10;
wire t_1320;
wire [31:0] gen_11;
wire t_1360;
wire [31:0] gen_12;
wire t_1421_0;
wire t_1421_1;
wire t_1421_2;
wire t_1421_3;
wire t_1421_4;
wire t_1421_5;
wire t_1421_6;
wire t_1421_7;
wire t_1472_0;
wire t_1472_1;
wire t_1472_2;
wire t_1472_3;
wire t_1472_4;
wire t_1472_5;
wire t_1472_6;
wire t_1472_7;
wire t_1523_0;
wire t_1523_1;
wire t_1523_2;
wire t_1523_3;
wire t_1523_4;
wire t_1523_5;
wire t_1523_6;
wire t_1523_7;
wire t_1574_0;
wire t_1574_1;
wire t_1574_2;
wire t_1574_3;
wire t_1574_4;
wire t_1574_5;
wire t_1574_6;
wire t_1574_7;
wire t_1585;
wire t_1586;
wire t_1597;
wire [1:0] t_1599;
wire [2:0] t_1600;
wire gen_0;
wire gen_13;
wire gen_14;
wire gen_15;
wire gen_16;
wire gen_17;
wire gen_18;
wire gen_19;
wire gen_1;
wire gen_20;
wire gen_21;
wire gen_22;
wire gen_23;
wire gen_24;
wire gen_25;
wire gen_26;
wire t_1619;
wire gen_2;
wire gen_27;
wire gen_28;
wire gen_29;
wire gen_30;
wire gen_31;
wire gen_32;
wire gen_33;
wire gen_3;
wire gen_34;
wire gen_35;
wire gen_36;
wire gen_37;
wire gen_38;
wire gen_39;
wire gen_40;
wire t_1622;
wire t_1623;
wire t_1624;
wire t_1625;
wire t_1626;
wire [7:0] t_1628;
wire t_1647;
wire t_1648;
wire t_1649;
wire t_1650;
wire t_1653;
wire t_1654;
wire t_1656;
wire t_1657;
wire t_1658;
wire t_1660;
wire t_1664;
wire t_1666;
wire t_1689;
wire t_1690;
wire t_1696;
wire t_1700;
wire t_1706;
wire t_1709;
wire t_1710;
wire t_1716;
wire t_1720;
wire t_1726;
wire t_1729;
wire t_1730;
wire t_1736;
wire t_1740;
wire t_1746;
wire t_1749;
wire t_1750;
wire t_1756;
wire t_1760;
wire t_1766;
wire t_1838_0;
wire t_1838_1;
wire t_1838_2;
wire t_1838_3;
wire t_1838_4;
wire t_1838_5;
wire t_1838_6;
wire t_1838_7;
wire [31:0] t_1861_0;
wire [31:0] t_1861_1;
wire [31:0] t_1861_2;
wire [31:0] t_1861_3;
wire [31:0] t_1861_4;
wire [31:0] t_1861_5;
wire [31:0] t_1861_6;
wire [31:0] t_1861_7;
wire gen_4;
wire gen_41;
wire gen_42;
wire gen_43;
wire gen_44;
wire gen_45;
wire gen_46;
wire gen_47;
wire [31:0] gen_5;
wire [31:0] gen_48;
wire [31:0] gen_49;
wire [31:0] gen_50;
wire [31:0] gen_51;
wire [31:0] gen_52;
wire [31:0] gen_53;
wire [31:0] gen_54;
wire [31:0] t_1874;
wire [1:0] t_1875;
wire [4:0] t_1877;
wire [2:0] t_1878;
wire [2:0] t_1889_opcode;
wire [1:0] t_1889_param;
wire [2:0] t_1889_size;
wire [4:0] t_1889_source;
wire t_1889_sink;
wire [1:0] t_1889_addr_lo;
wire [31:0] t_1889_data;
wire t_1889_error;
wire [2:0] gen_55 = 3'b0;
reg [31:0] gen_67;
wire [1:0] gen_56 = 2'b0;
reg [31:0] gen_68;
wire [2:0] gen_57 = 3'b0;
reg [31:0] gen_69;
wire [4:0] gen_58 = 5'b0;
reg [31:0] gen_70;
wire [25:0] gen_59 = 26'b0;
reg [31:0] gen_71;
wire [3:0] gen_60 = 4'b0;
reg [31:0] gen_72;
wire [31:0] gen_61 = 32'b0;
reg [31:0] gen_73;
assign io_in_0_a_ready = t_940_ready;
assign io_in_0_b_valid = 1'h0;
assign io_in_0_b_bits_opcode = gen_55;
assign io_in_0_b_bits_param = gen_56;
assign io_in_0_b_bits_size = gen_57;
assign io_in_0_b_bits_source = gen_58;
assign io_in_0_b_bits_address = gen_59;
assign io_in_0_b_bits_mask = gen_60;
assign io_in_0_b_bits_data = gen_61;
assign io_in_0_c_ready = 1'h1;
assign io_in_0_d_valid = t_979_valid;
assign io_in_0_d_bits_opcode = {{2'd0}, t_979_bits_read};
assign io_in_0_d_bits_param = t_1889_param;
assign io_in_0_d_bits_size = t_1889_size;
assign io_in_0_d_bits_source = t_1889_source;
assign io_in_0_d_bits_sink = t_1889_sink;
assign io_in_0_d_bits_addr_lo = t_1889_addr_lo;
assign io_in_0_d_bits_data = t_979_bits_data;
assign io_in_0_d_bits_error = t_1889_error;
assign io_in_0_e_ready = 1'h1;
assign io_tiles_0_mtip = t_916;
assign io_tiles_0_msip = ipi_0;
assign t_904 = {time_1,time_0};
assign t_906 = t_904 + 64'h1;
assign t_907 = t_906[63:0];
assign t_909 = t_907[63:32];
assign gen_6 = io_rtctick ? t_907 : {{32'd0}, time_0};
assign gen_7 = io_rtctick ? t_909 : time_1;
assign t_915 = {timecmp_0_1,timecmp_0_0};
assign t_916 = t_904 >= t_915;
assign t_940_ready = t_1623;
assign t_940_valid = io_in_0_a_valid;
assign t_940_bits_read = t_957;
assign t_940_bits_index = t_958[13:0];
assign t_940_bits_data = io_in_0_a_bits_data;
assign t_940_bits_mask = io_in_0_a_bits_mask;
assign t_940_bits_extra = t_961;
assign t_957 = io_in_0_a_bits_opcode == 3'h4;
assign t_958 = io_in_0_a_bits_address[25:2];
assign t_959 = io_in_0_a_bits_address[1:0];
assign t_960 = {t_959,io_in_0_a_bits_source};
assign t_961 = {t_960,io_in_0_a_bits_size};
assign t_979_ready = io_in_0_d_ready;
assign t_979_valid = t_1626;
assign t_979_bits_read = t_1015_bits_read;
assign t_979_bits_data = t_1874;
assign t_979_bits_extra = t_1015_bits_extra;
assign t_1015_ready = t_1625;
assign t_1015_valid = t_1624;
assign t_1015_bits_read = t_940_bits_read;
assign t_1015_bits_index = t_940_bits_index;
assign t_1015_bits_data = t_940_bits_data;
assign t_1015_bits_mask = t_940_bits_mask;
assign t_1015_bits_extra = t_940_bits_extra;
assign t_1058_0 = t_1650;
assign t_1058_1 = t_1750;
assign t_1058_2 = t_1690;
assign t_1058_3 = t_1710;
assign t_1058_4 = t_1730;
assign t_1063_0 = t_1656;
assign t_1063_1 = t_1756;
assign t_1063_2 = t_1696;
assign t_1063_3 = t_1716;
assign t_1063_4 = t_1736;
assign t_1068_0 = 1'h1;
assign t_1068_1 = 1'h1;
assign t_1068_2 = 1'h1;
assign t_1068_3 = 1'h1;
assign t_1068_4 = 1'h1;
assign t_1073_0 = 1'h1;
assign t_1073_1 = 1'h1;
assign t_1073_2 = 1'h1;
assign t_1073_3 = 1'h1;
assign t_1073_4 = 1'h1;
assign t_1078_0 = 1'h1;
assign t_1078_1 = 1'h1;
assign t_1078_2 = 1'h1;
assign t_1078_3 = 1'h1;
assign t_1078_4 = 1'h1;
assign t_1083_0 = 1'h1;
assign t_1083_1 = 1'h1;
assign t_1083_2 = 1'h1;
assign t_1083_3 = 1'h1;
assign t_1083_4 = 1'h1;
assign t_1088_0 = t_1660;
assign t_1088_1 = t_1760;
assign t_1088_2 = t_1700;
assign t_1088_3 = t_1720;
assign t_1088_4 = t_1740;
assign t_1093_0 = t_1666;
assign t_1093_1 = t_1766;
assign t_1093_2 = t_1706;
assign t_1093_3 = t_1726;
assign t_1093_4 = t_1746;
assign t_1135 = t_1015_bits_mask[0];
assign t_1136 = t_1015_bits_mask[1];
assign t_1137 = t_1015_bits_mask[2];
assign t_1138 = t_1015_bits_mask[3];
assign t_1142 = t_1135 ? 8'hff : 8'h0;
assign t_1146 = t_1136 ? 8'hff : 8'h0;
assign t_1150 = t_1137 ? 8'hff : 8'h0;
assign t_1154 = t_1138 ? 8'hff : 8'h0;
assign t_1155 = {t_1146,t_1142};
assign t_1156 = {t_1154,t_1150};
assign t_1157 = {t_1156,t_1155};
assign t_1185 = ~ t_1157;
assign t_1187 = t_1185 == 32'h0;
assign t_1200 = t_1093_0 & t_1187;
assign gen_8 = t_1200 ? t_1015_bits_data : {{31'd0}, ipi_0};
assign t_1219 = {{31'd0}, ipi_0};
assign t_1240 = t_1093_1 & t_1187;
assign gen_9 = t_1240 ? t_1015_bits_data : timecmp_0_1;
assign t_1280 = t_1093_2 & t_1187;
assign gen_10 = t_1280 ? {{32'd0}, t_1015_bits_data} : gen_6;
assign t_1320 = t_1093_3 & t_1187;
assign gen_11 = t_1320 ? t_1015_bits_data : gen_7;
assign t_1360 = t_1093_4 & t_1187;
assign gen_12 = t_1360 ? t_1015_bits_data : timecmp_0_0;
assign t_1421_0 = t_1068_0;
assign t_1421_1 = 1'h1;
assign t_1421_2 = t_1068_2;
assign t_1421_3 = t_1068_3;
assign t_1421_4 = t_1068_4;
assign t_1421_5 = t_1068_1;
assign t_1421_6 = 1'h1;
assign t_1421_7 = 1'h1;
assign t_1472_0 = t_1073_0;
assign t_1472_1 = 1'h1;
assign t_1472_2 = t_1073_2;
assign t_1472_3 = t_1073_3;
assign t_1472_4 = t_1073_4;
assign t_1472_5 = t_1073_1;
assign t_1472_6 = 1'h1;
assign t_1472_7 = 1'h1;
assign t_1523_0 = t_1078_0;
assign t_1523_1 = 1'h1;
assign t_1523_2 = t_1078_2;
assign t_1523_3 = t_1078_3;
assign t_1523_4 = t_1078_4;
assign t_1523_5 = t_1078_1;
assign t_1523_6 = 1'h1;
assign t_1523_7 = 1'h1;
assign t_1574_0 = t_1083_0;
assign t_1574_1 = 1'h1;
assign t_1574_2 = t_1083_2;
assign t_1574_3 = t_1083_3;
assign t_1574_4 = t_1083_4;
assign t_1574_5 = t_1083_1;
assign t_1574_6 = 1'h1;
assign t_1574_7 = 1'h1;
assign t_1585 = t_1015_bits_index[0];
assign t_1586 = t_1015_bits_index[1];
assign t_1597 = t_1015_bits_index[12];
assign t_1599 = {t_1597,t_1586};
assign t_1600 = {t_1599,t_1585};
assign gen_0 = gen_19;
assign gen_13 = 3'h1 == t_1600 ? t_1421_1 : t_1421_0;
assign gen_14 = 3'h2 == t_1600 ? t_1421_2 : gen_13;
assign gen_15 = 3'h3 == t_1600 ? t_1421_3 : gen_14;
assign gen_16 = 3'h4 == t_1600 ? t_1421_4 : gen_15;
assign gen_17 = 3'h5 == t_1600 ? t_1421_5 : gen_16;
assign gen_18 = 3'h6 == t_1600 ? t_1421_6 : gen_17;
assign gen_19 = 3'h7 == t_1600 ? t_1421_7 : gen_18;
assign gen_1 = gen_26;
assign gen_20 = 3'h1 == t_1600 ? t_1472_1 : t_1472_0;
assign gen_21 = 3'h2 == t_1600 ? t_1472_2 : gen_20;
assign gen_22 = 3'h3 == t_1600 ? t_1472_3 : gen_21;
assign gen_23 = 3'h4 == t_1600 ? t_1472_4 : gen_22;
assign gen_24 = 3'h5 == t_1600 ? t_1472_5 : gen_23;
assign gen_25 = 3'h6 == t_1600 ? t_1472_6 : gen_24;
assign gen_26 = 3'h7 == t_1600 ? t_1472_7 : gen_25;
assign t_1619 = t_1015_bits_read ? gen_0 : gen_1;
assign gen_2 = gen_33;
assign gen_27 = 3'h1 == t_1600 ? t_1523_1 : t_1523_0;
assign gen_28 = 3'h2 == t_1600 ? t_1523_2 : gen_27;
assign gen_29 = 3'h3 == t_1600 ? t_1523_3 : gen_28;
assign gen_30 = 3'h4 == t_1600 ? t_1523_4 : gen_29;
assign gen_31 = 3'h5 == t_1600 ? t_1523_5 : gen_30;
assign gen_32 = 3'h6 == t_1600 ? t_1523_6 : gen_31;
assign gen_33 = 3'h7 == t_1600 ? t_1523_7 : gen_32;
assign gen_3 = gen_40;
assign gen_34 = 3'h1 == t_1600 ? t_1574_1 : t_1574_0;
assign gen_35 = 3'h2 == t_1600 ? t_1574_2 : gen_34;
assign gen_36 = 3'h3 == t_1600 ? t_1574_3 : gen_35;
assign gen_37 = 3'h4 == t_1600 ? t_1574_4 : gen_36;
assign gen_38 = 3'h5 == t_1600 ? t_1574_5 : gen_37;
assign gen_39 = 3'h6 == t_1600 ? t_1574_6 : gen_38;
assign gen_40 = 3'h7 == t_1600 ? t_1574_7 : gen_39;
assign t_1622 = t_1015_bits_read ? gen_2 : gen_3;
assign t_1623 = t_1015_ready & t_1619;
assign t_1624 = t_940_valid & t_1619;
assign t_1625 = t_979_ready & t_1622;
assign t_1626 = t_1015_valid & t_1622;
assign t_1628 = 8'h1 << t_1600;
assign t_1647 = t_940_valid & t_1015_ready;
assign t_1648 = t_1647 & t_1015_bits_read;
assign t_1649 = t_1628[0];
assign t_1650 = t_1648 & t_1649;
assign t_1653 = t_1015_bits_read == 1'h0;
assign t_1654 = t_1647 & t_1653;
assign t_1656 = t_1654 & t_1649;
assign t_1657 = t_1015_valid & t_979_ready;
assign t_1658 = t_1657 & t_1015_bits_read;
assign t_1660 = t_1658 & t_1649;
assign t_1664 = t_1657 & t_1653;
assign t_1666 = t_1664 & t_1649;
assign t_1689 = t_1628[2];
assign t_1690 = t_1648 & t_1689;
assign t_1696 = t_1654 & t_1689;
assign t_1700 = t_1658 & t_1689;
assign t_1706 = t_1664 & t_1689;
assign t_1709 = t_1628[3];
assign t_1710 = t_1648 & t_1709;
assign t_1716 = t_1654 & t_1709;
assign t_1720 = t_1658 & t_1709;
assign t_1726 = t_1664 & t_1709;
assign t_1729 = t_1628[4];
assign t_1730 = t_1648 & t_1729;
assign t_1736 = t_1654 & t_1729;
assign t_1740 = t_1658 & t_1729;
assign t_1746 = t_1664 & t_1729;
assign t_1749 = t_1628[5];
assign t_1750 = t_1648 & t_1749;
assign t_1756 = t_1654 & t_1749;
assign t_1760 = t_1658 & t_1749;
assign t_1766 = t_1664 & t_1749;
assign t_1838_0 = 1'h1;
assign t_1838_1 = 1'h1;
assign t_1838_2 = 1'h1;
assign t_1838_3 = 1'h1;
assign t_1838_4 = 1'h1;
assign t_1838_5 = 1'h1;
assign t_1838_6 = 1'h1;
assign t_1838_7 = 1'h1;
assign t_1861_0 = t_1219;
assign t_1861_1 = 32'h0;
assign t_1861_2 = time_0;
assign t_1861_3 = time_1;
assign t_1861_4 = timecmp_0_0;
assign t_1861_5 = timecmp_0_1;
assign t_1861_6 = 32'h0;
assign t_1861_7 = 32'h0;
assign gen_4 = gen_47;
assign gen_41 = 3'h1 == t_1600 ? t_1838_1 : t_1838_0;
assign gen_42 = 3'h2 == t_1600 ? t_1838_2 : gen_41;
assign gen_43 = 3'h3 == t_1600 ? t_1838_3 : gen_42;
assign gen_44 = 3'h4 == t_1600 ? t_1838_4 : gen_43;
assign gen_45 = 3'h5 == t_1600 ? t_1838_5 : gen_44;
assign gen_46 = 3'h6 == t_1600 ? t_1838_6 : gen_45;
assign gen_47 = 3'h7 == t_1600 ? t_1838_7 : gen_46;
assign gen_5 = gen_54;
assign gen_48 = 3'h1 == t_1600 ? t_1861_1 : t_1861_0;
assign gen_49 = 3'h2 == t_1600 ? t_1861_2 : gen_48;
assign gen_50 = 3'h3 == t_1600 ? t_1861_3 : gen_49;
assign gen_51 = 3'h4 == t_1600 ? t_1861_4 : gen_50;
assign gen_52 = 3'h5 == t_1600 ? t_1861_5 : gen_51;
assign gen_53 = 3'h6 == t_1600 ? t_1861_6 : gen_52;
assign gen_54 = 3'h7 == t_1600 ? t_1861_7 : gen_53;
assign t_1874 = gen_4 ? gen_5 : 32'h0;
assign t_1875 = t_979_bits_extra[9:8];
assign t_1877 = t_979_bits_extra[7:3];
assign t_1878 = t_979_bits_extra[2:0];
assign t_1889_opcode = 3'h0;
assign t_1889_param = 2'h0;
assign t_1889_size = t_1878;
assign t_1889_source = t_1877;
assign t_1889_sink = 1'h0;
assign t_1889_addr_lo = t_1875;
assign t_1889_data = 32'h0;
assign t_1889_error = 1'h0;
always @(posedge clock or posedge reset) begin
if (reset) begin
time_0 <= 32'h0;
end else begin
time_0 <= gen_10[31:0];
end
end
always @(posedge clock or posedge reset) begin
if (reset) begin
time_1 <= 32'h0;
end else begin
if (t_1320) begin
time_1 <= t_1015_bits_data;
end else begin
if (io_rtctick) begin
time_1 <= t_909;
end
end
end
end
always @(posedge clock or posedge reset) begin
if (reset) begin
timecmp_0_0 <= 32'hffff_ffff;
end
else if (t_1360) begin
timecmp_0_0 <= t_1015_bits_data;
end
end
always @(posedge clock or posedge reset) begin
if (reset) begin
timecmp_0_1 <= 32'hffff_ffff;
end
else if (t_1240) begin
timecmp_0_1 <= t_1015_bits_data;
end
end
always @(posedge clock or posedge reset) begin
if (reset) begin
ipi_0 <= 1'h0;
end else begin
ipi_0 <= gen_8[0];
end
end
endmodule |
module sirv_deglitchshiftregister(
input clock,
input reset,
input io_d,
output io_q
);
reg t_8;
reg [31:0] gen_0;
reg t_9;
reg [31:0] gen_1;
reg sync;
reg [31:0] gen_2;
reg last;
reg [31:0] gen_3;
wire t_12;
assign io_q = t_12;
assign t_12 = sync & last;
always @(posedge clock) begin t_8 <= io_d;
t_9 <= t_8;
sync <= t_9;
last <= sync;
end
endmodule |
module sirv_expl_axi_slv #(
parameter aw = 32,
parameter dw = 32
)(
input axi_arvalid,
output axi_arready,
input [aw-1:0] axi_araddr,
input [3:0] axi_arcache,
input [2:0] axi_arprot,
input [1:0] axi_arlock,
input [1:0] axi_arburst,
input [3:0] axi_arlen,
input [2:0] axi_arsize,
input axi_awvalid,
output axi_awready,
input [aw-1:0] axi_awaddr,
input [3:0] axi_awcache,
input [2:0] axi_awprot,
input [1:0] axi_awlock,
input [1:0] axi_awburst,
input [3:0] axi_awlen,
input [2:0] axi_awsize,
output axi_rvalid,
input axi_rready,
output [dw-1:0] axi_rdata,
output [1:0] axi_rresp,
output axi_rlast,
input axi_wvalid,
output axi_wready,
input [dw-1:0] axi_wdata,
input [(dw/8)-1:0] axi_wstrb,
input axi_wlast,
output axi_bvalid,
input axi_bready,
output [1:0] axi_bresp,
input clk,
input rst_n
);
assign axi_rvalid = axi_arvalid;
assign axi_arready = axi_rready;
assign axi_rdata = {dw{1'b0}};
assign axi_rresp = 2'b0;
assign axi_rlast = 1'b1;
assign axi_bvalid = axi_wvalid;
assign axi_wready = axi_bready;
assign axi_bresp = 2'b0;
assign axi_awready = 1'b1;
endmodule |
module sirv_jtaggpioport(
input clock,
input reset,
output io_jtag_tck,
output io_jtag_tms,
output io_jtag_tdi,
input io_jtag_tdo,
output io_jtag_trst,
input io_jtag_drv_tdo,
input io_pins_tck_i_ival,
output io_pins_tck_o_oval,
output io_pins_tck_o_oe,
output io_pins_tck_o_ie,
output io_pins_tck_o_pue,
output io_pins_tck_o_ds,
input io_pins_tms_i_ival,
output io_pins_tms_o_oval,
output io_pins_tms_o_oe,
output io_pins_tms_o_ie,
output io_pins_tms_o_pue,
output io_pins_tms_o_ds,
input io_pins_tdi_i_ival,
output io_pins_tdi_o_oval,
output io_pins_tdi_o_oe,
output io_pins_tdi_o_ie,
output io_pins_tdi_o_pue,
output io_pins_tdi_o_ds,
input io_pins_tdo_i_ival,
output io_pins_tdo_o_oval,
output io_pins_tdo_o_oe,
output io_pins_tdo_o_ie,
output io_pins_tdo_o_pue,
output io_pins_tdo_o_ds,
input io_pins_trst_n_i_ival,
output io_pins_trst_n_o_oval,
output io_pins_trst_n_o_oe,
output io_pins_trst_n_o_ie,
output io_pins_trst_n_o_pue,
output io_pins_trst_n_o_ds
);
wire t_101;
wire t_117;
assign io_jtag_tck = t_101;
assign io_jtag_tms = io_pins_tms_i_ival;
assign io_jtag_tdi = io_pins_tdi_i_ival;
assign io_jtag_trst = t_117;
assign io_pins_tck_o_oval = 1'h0;
assign io_pins_tck_o_oe = 1'h0;
assign io_pins_tck_o_ie = 1'h1;
assign io_pins_tck_o_pue = 1'h1;
assign io_pins_tck_o_ds = 1'h0;
assign io_pins_tms_o_oval = 1'h0;
assign io_pins_tms_o_oe = 1'h0;
assign io_pins_tms_o_ie = 1'h1;
assign io_pins_tms_o_pue = 1'h1;
assign io_pins_tms_o_ds = 1'h0;
assign io_pins_tdi_o_oval = 1'h0;
assign io_pins_tdi_o_oe = 1'h0;
assign io_pins_tdi_o_ie = 1'h1;
assign io_pins_tdi_o_pue = 1'h1;
assign io_pins_tdi_o_ds = 1'h0;
assign io_pins_tdo_o_oval = io_jtag_tdo;
assign io_pins_tdo_o_oe = io_jtag_drv_tdo;
assign io_pins_tdo_o_ie = 1'h0;
assign io_pins_tdo_o_pue = 1'h0;
assign io_pins_tdo_o_ds = 1'h0;
assign io_pins_trst_n_o_oval = 1'h0;
assign io_pins_trst_n_o_oe = 1'h0;
assign io_pins_trst_n_o_ie = 1'h1;
assign io_pins_trst_n_o_pue = 1'h1;
assign io_pins_trst_n_o_ds = 1'h0;
assign t_101 = $unsigned(io_pins_tck_i_ival);
assign t_117 = ~ io_pins_trst_n_i_ival;
endmodule |
module sirv_levelgateway(
input clock,
input reset,
input io_interrupt,
output io_plic_valid,
input io_plic_ready,
input io_plic_complete
);
reg inflight;
reg [31:0] gen_2;
wire t_12;
wire gen_0;
wire gen_1;
wire t_16;
wire t_17;
assign io_plic_valid = t_17;
assign t_12 = io_interrupt & io_plic_ready;
assign gen_0 = t_12 ? 1'h1 : inflight;
assign gen_1 = io_plic_complete ? 1'h0 : gen_0;
assign t_16 = inflight == 1'h0;
assign t_17 = io_interrupt & t_16;
always @(posedge clock or posedge reset) begin
if (reset) begin
inflight <= 1'h0;
end else begin
if (io_plic_complete) begin
inflight <= 1'h0;
end else begin
if (t_12) begin
inflight <= 1'h1;
end
end
end
end
endmodule |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 62