mirror of https://github.com/openXC7/prjxray.git
275 lines
7.1 KiB
Verilog
275 lines
7.1 KiB
Verilog
//move some stuff to minitests/ncy0
|
|
|
|
module top(input clk, stb, di, output do);
|
|
localparam integer DIN_N = 256;
|
|
localparam integer DOUT_N = 256;
|
|
|
|
reg [DIN_N-1:0] din;
|
|
wire [DOUT_N-1:0] dout;
|
|
|
|
reg [DIN_N-1:0] din_shr;
|
|
reg [DOUT_N-1:0] dout_shr;
|
|
|
|
always @(posedge clk) begin
|
|
din_shr <= {din_shr, di};
|
|
dout_shr <= {dout_shr, din_shr[DIN_N-1]};
|
|
if (stb) begin
|
|
din <= din_shr;
|
|
dout_shr <= dout;
|
|
end
|
|
end
|
|
|
|
assign do = dout_shr[DOUT_N-1];
|
|
|
|
roi roi (
|
|
.clk(clk),
|
|
.din(din),
|
|
.dout(dout)
|
|
);
|
|
endmodule
|
|
|
|
module roi(input clk, input [255:0] din, output [255:0] dout);
|
|
parameter N=3;
|
|
|
|
//ok
|
|
clb_NOUTMUX_CY #(.LOC("SLICE_X18Y100"), .N(N))
|
|
clb_NOUTMUX_CY (.clk(clk), .din(din[ 8 +: 8]), .dout(dout[ 8 +: 8]));
|
|
//ok
|
|
generate
|
|
if (N != 3) begin
|
|
clb_NOUTMUX_F78 #(.LOC("SLICE_X18Y101"), .N(N))
|
|
clb_NOUTMUX_F78 (.clk(clk), .din(din[ 16 +: 8]), .dout(dout[ 16 +: 8]));
|
|
end
|
|
endgenerate
|
|
//ok
|
|
clb_NOUTMUX_O5 #(.LOC("SLICE_X18Y102"), .N(N))
|
|
clb_NOUTMUX_O5 (.clk(clk), .din(din[ 32 +: 8]), .dout(dout[ 32 +: 8]));
|
|
//clb_NOUTMUX_O6 #(.LOC("SLICE_X18Y103"), .N(N))
|
|
// clb_NOUTMUX_O6 (.clk(clk), .din(din[ 24 +: 8]), .dout(dout[ 24 +: 8]));
|
|
//FIXME
|
|
clb_NOUTMUX_XOR #(.LOC("SLICE_X18Y104"), .N(N))
|
|
clb_NOUTMUX_XOR (.clk(clk), .din(din[ 56 +: 8]), .dout(dout[ 56 +: 8 ]));
|
|
//ok
|
|
clb_NOUTMUX_B5Q #(.LOC("SLICE_X18Y105"), .N(N))
|
|
clb_NOUTMUX_B5Q (.clk(clk), .din(din[ 48 +: 8]), .dout(dout[ 48 +: 8 ]));
|
|
endmodule
|
|
|
|
module myLUT8 (input clk, input [7:0] din,
|
|
output lut8o, output lut7bo, output lut7ao,
|
|
//caro: XOR additional result (main output)
|
|
//carco: CLA result (carry module additional output)
|
|
output caro, output carco,
|
|
output bo5, output bo6,
|
|
//Note: b5ff_q requires the mux and will conflict with other wires
|
|
//Otherwise this FF drops out
|
|
output wire ff_q);
|
|
//output wire [3:0] n5ff_q);
|
|
parameter N=-1;
|
|
parameter LOC="SLICE_FIXME";
|
|
|
|
wire [3:0] caro_all;
|
|
assign caro = caro_all[N];
|
|
wire [3:0] carco_all;
|
|
assign carco = carco_all[N];
|
|
|
|
wire [3:0] lutno6;
|
|
assign bo6 = lutno6[N];
|
|
wire [3:0] lutno5;
|
|
assign bo5 = lutno5[N];
|
|
|
|
//Outputs does not have to be used, will stay without it
|
|
(* LOC=LOC, BEL="F8MUX", KEEP, DONT_TOUCH *)
|
|
MUXF8 mux8 (.O(lut8o), .I0(lut7bo), .I1(lut7ao), .S(din[6]));
|
|
(* LOC=LOC, BEL="F7BMUX", KEEP, DONT_TOUCH *)
|
|
MUXF7 mux7b (.O(lut7bo), .I0(lutno6[3]), .I1(lutno6[2]), .S(din[6]));
|
|
(* LOC=LOC, BEL="F7AMUX", KEEP, DONT_TOUCH *)
|
|
MUXF7 mux7a (.O(lut7ao), .I0(lutno6[1]), .I1(lutno6[0]), .S(din[6]));
|
|
|
|
(* LOC=LOC, BEL="D6LUT", KEEP, DONT_TOUCH *)
|
|
LUT6_2 #(
|
|
.INIT(64'h8000_DEAD_0000_0001)
|
|
) lutd (
|
|
.I0(din[0]),
|
|
.I1(din[1]),
|
|
.I2(din[2]),
|
|
.I3(din[3]),
|
|
.I4(din[4]),
|
|
.I5(din[5]),
|
|
.O5(lutno5[3]),
|
|
.O6(lutno6[3]));
|
|
|
|
(* LOC=LOC, BEL="C6LUT", KEEP, DONT_TOUCH *)
|
|
LUT6_2 #(
|
|
.INIT(64'h8000_BEEF_0000_0001)
|
|
) lutc (
|
|
.I0(din[0]),
|
|
.I1(din[1]),
|
|
.I2(din[2]),
|
|
.I3(din[3]),
|
|
.I4(din[4]),
|
|
.I5(din[5]),
|
|
.O5(lutno5[2]),
|
|
.O6(lutno6[2]));
|
|
|
|
(* LOC=LOC, BEL="B6LUT", KEEP, DONT_TOUCH *)
|
|
LUT6_2 #(
|
|
.INIT(64'h8000_CAFE_0000_0001)
|
|
) lutb (
|
|
.I0(din[0]),
|
|
.I1(din[1]),
|
|
.I2(din[2]),
|
|
.I3(din[3]),
|
|
.I4(din[4]),
|
|
.I5(din[5]),
|
|
.O5(lutno5[1]),
|
|
.O6(lutno6[1]));
|
|
|
|
(* LOC=LOC, BEL="A6LUT", KEEP, DONT_TOUCH *)
|
|
LUT6_2 #(
|
|
.INIT(64'h8000_1CE0_0000_0001)
|
|
) luta (
|
|
.I0(din[0]),
|
|
.I1(din[1]),
|
|
.I2(din[2]),
|
|
.I3(din[3]),
|
|
.I4(din[4]),
|
|
.I5(din[5]),
|
|
.O5(lutno5[0]),
|
|
.O6(lutno6[0]));
|
|
|
|
//Outputs do not have to be used, will stay without them
|
|
(* LOC=LOC, KEEP, DONT_TOUCH *)
|
|
CARRY4 carry4(.O(caro_all), .CO(carco_all), .DI(lutno5), .S(lutno6), .CYINIT(1'b0), .CI());
|
|
|
|
generate
|
|
if (N == 3) begin
|
|
(* LOC=LOC, BEL="D5FF", KEEP, DONT_TOUCH *)
|
|
FDPE d5ff (
|
|
.C(clk),
|
|
.Q(ff_q),
|
|
.CE(1'b1),
|
|
.PRE(1'b0),
|
|
.D(lutno5[3]));
|
|
end
|
|
if (N == 2) begin
|
|
(* LOC=LOC, BEL="C5FF", KEEP, DONT_TOUCH *)
|
|
FDPE c5ff (
|
|
.C(clk),
|
|
.Q(ff_q),
|
|
.CE(1'b1),
|
|
.PRE(1'b0),
|
|
.D(lutno5[2]));
|
|
end
|
|
if (N == 1) begin
|
|
(* LOC=LOC, BEL="B5FF", KEEP, DONT_TOUCH *)
|
|
FDPE b5ff (
|
|
.C(clk),
|
|
.Q(ff_q),
|
|
.CE(1'b1),
|
|
.PRE(1'b0),
|
|
.D(lutno5[1]));
|
|
end
|
|
if (N == 0) begin
|
|
(* LOC=LOC, BEL="A5FF", KEEP, DONT_TOUCH *)
|
|
FDPE a5ff (
|
|
.C(clk),
|
|
.Q(ff_q),
|
|
.CE(1'b1),
|
|
.PRE(1'b0),
|
|
.D(lutno5[0]));
|
|
end
|
|
endgenerate
|
|
endmodule
|
|
|
|
//******************************************************************************
|
|
//BOUTMUX tests
|
|
|
|
module clb_NOUTMUX_CY (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din), .lut8o(),
|
|
.caro(), .carco(dout[0]),
|
|
.bo5(), .bo6(),
|
|
.ff_q());
|
|
endmodule
|
|
|
|
//clb_NOUTMUX_F78: already have above as clb_LUT8
|
|
module clb_NOUTMUX_F78 (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
wire lut8o, lut7bo, lut7ao;
|
|
/*
|
|
D: N/A (no such mux position)
|
|
C: F7B:O
|
|
B: F8:O
|
|
A: F7A:O
|
|
*/
|
|
generate
|
|
if (N == 3) begin
|
|
//No muxes, so this is undefined
|
|
invalid_configuration invalid_configuration3();
|
|
end else if (N == 2) begin
|
|
assign dout[0] = lut7bo;
|
|
end else if (N == 1) begin
|
|
assign dout[0] = lut8o;
|
|
end else if (N == 0) begin
|
|
assign dout[0] = lut7ao;
|
|
end
|
|
endgenerate
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din),
|
|
.lut8o(lut8o), .lut7bo(lut7bo), .lut7ao(lut7ao),
|
|
.caro(), .carco(),
|
|
.bo5(), .bo6(),
|
|
.ff_q());
|
|
endmodule
|
|
|
|
module clb_NOUTMUX_O5 (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din), .lut8o(),
|
|
.caro(), .carco(),
|
|
.bo5(dout[0]), .bo6(),
|
|
.ff_q());
|
|
endmodule
|
|
|
|
/*
|
|
//FIXME: need to force it to use both X and O6
|
|
module clb_NOUTMUX_O6 (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din), .lut8o(), .co(), .carco(), .bo5(), .bo6());
|
|
endmodule
|
|
*/
|
|
|
|
module clb_NOUTMUX_XOR (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din), .lut8o(),
|
|
.caro(dout[0]), .carco(),
|
|
.bo5(), .bo6(),
|
|
.ff_q());
|
|
endmodule
|
|
|
|
module clb_NOUTMUX_B5Q (input clk, input [7:0] din, output [7:0] dout);
|
|
parameter LOC="SLICE_FIXME";
|
|
parameter N=1;
|
|
|
|
myLUT8 #(.LOC(LOC), .N(N))
|
|
myLUT8(.clk(clk), .din(din),
|
|
.lut8o(),
|
|
.caro(), .carco(),
|
|
.bo5(), .bo6(),
|
|
.ff_q(dout[0]));
|
|
endmodule
|
|
|