mor1kx-bemicrocv/ip/altera/ddr3/altdq_dqs2_acv_connect_to_h...

2458 lines
60 KiB
Systemverilog

// (C) 2001-2015 Altera Corporation. All rights reserved.
// Your use of Altera Corporation's design tools, logic functions and other
// software and tools, and its AMPP partner logic functions, and any output
// files any of the foregoing (including device programming or simulation
// files), and any associated documentation or information are expressly subject
// to the terms and conditions of the Altera Program License Subscription
// Agreement, Altera MegaCore Function License Agreement, or other applicable
// license agreement, including, without limitation, that your use is for the
// sole purpose of programming logic devices manufactured by Altera and sold by
// Altera or its authorized distributors. Please refer to the applicable
// agreement for further details.
// altera message_off 10034 10036 10030 10858
`timescale 1 ps / 1 ps
(* altera_attribute = "-name MESSAGE_DISABLE 12010; -name MESSAGE_DISABLE 12161" *)
module altdq_dqs2_acv_connect_to_hard_phy_cyclonev (
dll_delayctrl_in,
dll_offsetdelay_in,
capture_strobe_in,
capture_strobe_n_in,
capture_strobe_ena,
capture_strobe_out,
output_strobe_ena,
output_strobe_out,
output_strobe_n_out,
oct_ena_in,
strobe_io,
strobe_n_io,
core_clock_in,
fr_clock_in,
hr_clock_in,
dr_clock_in,
strobe_ena_hr_clock_in,
write_strobe_clock_in,
write_strobe,
reset_n_core_clock_in,
parallelterminationcontrol_in,
seriesterminationcontrol_in,
read_data_in,
write_data_out,
read_write_data_io,
write_oe_in,
read_data_out,
write_data_in,
extra_write_data_in,
extra_write_data_out,
capture_strobe_tracking,
lfifo_rdata_en,
lfifo_rdata_en_full,
lfifo_rd_latency,
lfifo_reset_n,
lfifo_rdata_valid,
vfifo_qvld,
vfifo_inc_wr_ptr,
vfifo_reset_n,
rfifo_reset_n,
config_data_in,
config_dqs_ena,
config_io_ena,
config_extra_io_ena,
config_dqs_io_ena,
config_update,
config_clock_in
);
parameter PIN_WIDTH = 8;
parameter PIN_TYPE = "bidir";
parameter USE_INPUT_PHASE_ALIGNMENT = "false";
parameter USE_OUTPUT_PHASE_ALIGNMENT = "false";
parameter USE_HALF_RATE_INPUT = "false";
parameter USE_HALF_RATE_OUTPUT = "false";
parameter DIFFERENTIAL_CAPTURE_STROBE = "false";
parameter SEPARATE_CAPTURE_STROBE = "false";
parameter INPUT_FREQ = 0.0;
parameter INPUT_FREQ_PS = "0 ps";
parameter DELAY_CHAIN_BUFFER_MODE = "high";
parameter DQS_PHASE_SETTING = 3;
parameter DQS_PHASE_SHIFT = 9000;
localparam DQS_DELAYCHAIN_BYPASS = (DQS_PHASE_SHIFT == 0) ? "true" : "false";
parameter DQS_ENABLE_PHASE_SETTING = 2;
parameter USE_DYNAMIC_CONFIG = "true";
parameter INVERT_CAPTURE_STROBE = "false";
parameter SWAP_CAPTURE_STROBE_POLARITY = "false";
parameter USE_TERMINATION_CONTROL = "false";
parameter USE_OCT_ENA_IN_FOR_OCT = "false";
parameter USE_DQS_ENABLE = "false";
parameter USE_IO_CONFIG = "false";
parameter USE_DQS_CONFIG = "false";
parameter USE_OFFSET_CTRL = "false";
parameter HR_DDIO_OUT_HAS_THREE_REGS = "true";
parameter USE_OUTPUT_STROBE = "true";
parameter DIFFERENTIAL_OUTPUT_STROBE = "false";
parameter USE_OUTPUT_STROBE_RESET = "true";
parameter USE_BIDIR_STROBE = "false";
parameter REVERSE_READ_WORDS = "false";
parameter NATURAL_ALIGNMENT = "false";
parameter EXTRA_OUTPUT_WIDTH = 0;
parameter PREAMBLE_TYPE = "none";
parameter USE_DATA_OE_FOR_OCT = "false";
parameter DQS_ENABLE_WIDTH = 1;
parameter EMIF_UNALIGNED_PREAMBLE_SUPPORT = "false";
parameter EMIF_BYPASS_OCT_DDIO = "false";
parameter USE_2X_FF = "false";
parameter USE_DQS_TRACKING = "false";
parameter SEPERATE_LDC_FOR_WRITE_STROBE = "false";
localparam rate_mult_in = (USE_HALF_RATE_INPUT == "true") ? 4 : 2;
localparam rate_mult_out = (USE_HALF_RATE_OUTPUT == "true") ? 4 : 2;
localparam fpga_width_in = PIN_WIDTH * rate_mult_in;
localparam fpga_width_out = PIN_WIDTH * rate_mult_out;
localparam extra_fpga_width_out = EXTRA_OUTPUT_WIDTH * rate_mult_out;
localparam OS_ENA_WIDTH = rate_mult_out / 2;
localparam WRITE_OE_WIDTH = PIN_WIDTH * rate_mult_out / 2;
parameter DQS_ENABLE_PHASECTRL = "true";
parameter DYNAMIC_MODE = "dynamic";
parameter OCT_SERIES_TERM_CONTROL_WIDTH = 16;
parameter OCT_PARALLEL_TERM_CONTROL_WIDTH = 16;
parameter DLL_WIDTH = 6;
parameter REGULAR_WRITE_BUS_ORDERING = "true";
parameter ALTERA_ALTDQ_DQS2_FAST_SIM_MODEL = 0;
parameter USE_HARD_FIFOS = "false";
parameter CALIBRATION_SUPPORT = "false";
parameter USE_DQSIN_FOR_VFIFO_READ = "false";
parameter HHP_HPS = "false";
localparam READ_FIFO_MODE = (USE_HALF_RATE_OUTPUT == "true") ? "hrate_mode" : "frate_mode";
localparam DATA_RATE = 1;
localparam DELAY_CHAIN_WIDTH = 5;
localparam OUTPUT_ALIGNMENT_DELAY = "two_cycle";
input [DLL_WIDTH-1:0] dll_delayctrl_in;
input [DLL_WIDTH-1:0] dll_offsetdelay_in;
input core_clock_in;
input fr_clock_in;
input hr_clock_in;
input strobe_ena_hr_clock_in;
input write_strobe_clock_in;
input [3:0] write_strobe;
input [PIN_WIDTH-1:0] read_data_in;
output [PIN_WIDTH-1:0] write_data_out;
inout [PIN_WIDTH-1:0] read_write_data_io;
input capture_strobe_in;
input capture_strobe_n_in;
input [DQS_ENABLE_WIDTH-1:0] capture_strobe_ena;
input reset_n_core_clock_in;
parameter USE_LDC_AS_LOW_SKEW_CLOCK = "false";
parameter DLL_USE_2X_CLK = "false";
parameter DQS_ENABLE_AFTER_T7 = "true";
input [OS_ENA_WIDTH-1:0] output_strobe_ena;
output output_strobe_out;
output output_strobe_n_out;
input [1:0] oct_ena_in;
inout strobe_io;
inout strobe_n_io;
output [fpga_width_out-1:0] read_data_out;
input [fpga_width_out-1:0] write_data_in;
input [WRITE_OE_WIDTH-1:0] write_oe_in;
output capture_strobe_out;
input [extra_fpga_width_out-1:0] extra_write_data_in;
output [EXTRA_OUTPUT_WIDTH-1:0] extra_write_data_out;
output capture_strobe_tracking;
parameter LFIFO_OCT_EN_MASK = 4294967295;
input [(rate_mult_out / 2)-1:0] lfifo_rdata_en;
input [(rate_mult_out / 2)-1:0] lfifo_rdata_en_full;
localparam LFIFO_RD_LATENCY_WIDTH = 5;
input [LFIFO_RD_LATENCY_WIDTH-1:0] lfifo_rd_latency;
input lfifo_reset_n;
output lfifo_rdata_valid;
input [(rate_mult_out / 2)-1:0] vfifo_qvld;
input [(rate_mult_out / 2)-1:0] vfifo_inc_wr_ptr;
input vfifo_reset_n;
input rfifo_reset_n;
input dr_clock_in;
input [OCT_PARALLEL_TERM_CONTROL_WIDTH-1:0] parallelterminationcontrol_in;
input [OCT_SERIES_TERM_CONTROL_WIDTH-1:0] seriesterminationcontrol_in;
input config_data_in;
input config_update;
input config_dqs_ena;
input [PIN_WIDTH-1:0] config_io_ena;
input [EXTRA_OUTPUT_WIDTH-1:0] config_extra_io_ena;
input config_dqs_io_ena;
input config_clock_in;
wire [DLL_WIDTH-1:0] dll_delay_value;
assign dll_delay_value = dll_delayctrl_in;
wire dqsbusout;
wire dqsnbusout;
wire capture_strobe;
wire [1:0] inputclkdelaysetting;
wire [1:0] inputclkndelaysetting;
wire [4:0] dqs_outputdelaysetting;
wire [4:0] dqs_outputenabledelaysetting;
wire [DELAY_CHAIN_WIDTH-1:0] dqs_outputdelaysetting_dlc;
wire [DELAY_CHAIN_WIDTH-1:0] dqs_outputenabledelaysetting_dlc;
`ifndef FAMILY_HAS_NO_DYNCONF
generate
if (USE_DYNAMIC_CONFIG =="true" && (USE_OUTPUT_STROBE == "true" || PIN_TYPE =="input" || PIN_TYPE == "bidir"))
begin
cyclonev_io_config dqs_io_config_1 (
.outputhalfratebypass(),
.readfiforeadclockselect(),
.readfifomode(),
.padtoinputregisterdelaysetting(),
.datain(config_data_in),
.clk(config_clock_in),
.ena(config_dqs_io_ena),
.update(config_update),
.outputregdelaysetting(dqs_outputdelaysetting),
.outputenabledelaysetting(dqs_outputenabledelaysetting),
.dataout()
);
assign dqs_outputdelaysetting_dlc = dqs_outputdelaysetting;
assign dqs_outputenabledelaysetting_dlc = dqs_outputenabledelaysetting;
/*
cyclonev_io_config dqsn_io_config_1 (
.datain(config_data_in),
.clk(config_clock_in),
.ena(config_dqs_io_ena),
.update(config_update),
.outputregdelaysetting(dqsn_outputdelaysetting),
.outputenabledelaysetting(dqsn_outputenabledelaysetting),
.padtoinputregisterdelaysetting(dqsn_inputdelaysetting),
.dataout()
);
*/
end
endgenerate
`endif
wire [1:0] oct_ena;
wire fr_term;
wire [1:0] oct_source;
generate
if (USE_DATA_OE_FOR_OCT == "true")
begin
assign oct_source = ~write_oe_in;
end
else
begin
assign oct_source = ~output_strobe_ena;
end
endgenerate
generate
if (USE_HARD_FIFOS == "true")
begin
if (USE_HALF_RATE_OUTPUT == "true")
begin
if (USE_OCT_ENA_IN_FOR_OCT == "true")
begin
assign oct_ena = oct_ena_in;
end
else
begin
assign oct_ena = oct_source;
end
end
else
begin
if (USE_OCT_ENA_IN_FOR_OCT == "true")
begin
assign fr_term = oct_ena_in[0];
end
else
begin
assign fr_term = oct_source[0];
end
end
end
else
begin
if (USE_HALF_RATE_OUTPUT == "true")
begin : oct_ena_hr_gen
if (USE_OCT_ENA_IN_FOR_OCT == "true")
begin
assign oct_ena = oct_ena_in;
end
else
begin
reg oct_ena_hr_reg;
always @(posedge hr_clock_in)
oct_ena_hr_reg <= oct_source[1];
assign oct_ena[1] = ~oct_source[1];
assign oct_ena[0] = ~(oct_ena_hr_reg | oct_source[1]);
end
end
else
begin : oct_ena_fr_gen
if (USE_OCT_ENA_IN_FOR_OCT == "true")
begin
assign fr_term = oct_ena_in[0];
end
else
begin
reg oct_ena_fr_reg;
initial
oct_ena_fr_reg = 0;
always @(posedge hr_clock_in)
oct_ena_fr_reg <= oct_source[0];
assign fr_term = ~(oct_source[0] | oct_ena_fr_reg);
end
end
end
endgenerate
localparam PINS_PER_DQS_CONFIG = 6;
localparam NUM_STROBES = (DIFFERENTIAL_CAPTURE_STROBE == "true" || SEPARATE_CAPTURE_STROBE == "true") ? 2 : 1;
localparam DQS_CONFIGS = (PIN_WIDTH + EXTRA_OUTPUT_WIDTH + NUM_STROBES) / PINS_PER_DQS_CONFIG;
wire dividerphasesetting [DQS_CONFIGS:0];
wire dqoutputphaseinvert [DQS_CONFIGS:0];
wire [1:0] dqoutputphasesetting [DQS_CONFIGS:0];
wire [4:0] dqsbusoutdelaysetting [DQS_CONFIGS:0];
wire [1:0] dqsoutputphasesetting [DQS_CONFIGS:0];
wire [1:0] resyncinputphasesetting [DQS_CONFIGS:0];
wire [4:0] dqsenabledelaysetting [DQS_CONFIGS:0];
wire [4:0] dqsdisabledelaysetting [DQS_CONFIGS:0];
wire dqshalfratebypass [DQS_CONFIGS:0];
wire [1:0] dqsinputphasesetting [DQS_CONFIGS:0];
wire [1:0] dqsenablectrlphasesetting [DQS_CONFIGS:0];
wire dqoutputpowerdown [DQS_CONFIGS:0];
wire dqsoutputpowerdown [DQS_CONFIGS:0];
wire resyncinputpowerdown [DQS_CONFIGS:0];
wire dqsenablectrlpowerdown [DQS_CONFIGS:0];
wire [1:0] dq2xoutputphasesetting [DQS_CONFIGS:0];
wire dq2xoutputphaseinvert [DQS_CONFIGS:0];
wire [1:0] dqs2xoutputphasesetting [DQS_CONFIGS:0];
wire dqs2xoutputphaseinvert [DQS_CONFIGS:0];
wire dqsbusoutfinedelaysetting [DQS_CONFIGS:0];
wire dqsenablectrlphaseinvert [DQS_CONFIGS:0];
wire dqsenablefinedelaysetting [DQS_CONFIGS:0];
wire dqsoutputphaseinvert [DQS_CONFIGS:0];
wire enadataoutbypass [DQS_CONFIGS:0];
wire enadqsenablephasetransferreg [DQS_CONFIGS:0];
wire enainputcycledelaysetting [DQS_CONFIGS:0];
wire enainputphasetransferreg [DQS_CONFIGS:0];
wire enaoctphasetransferreg [DQS_CONFIGS:0];
wire enaoutputphasetransferreg [DQS_CONFIGS:0];
wire enadqsphasetransferreg [DQS_CONFIGS:0];
wire [2:0] enadqscycledelaysetting [DQS_CONFIGS:0];
wire [2:0] enaoctcycledelaysetting [DQS_CONFIGS:0];
wire [2:0] enaoutputcycledelaysetting [DQS_CONFIGS:0];
wire [4:0] octdelaysetting1 [DQS_CONFIGS:0];
wire resyncinputphaseinvert [DQS_CONFIGS:0];
wire [DELAY_CHAIN_WIDTH-1:0] dqsbusoutdelaysetting_dlc[DQS_CONFIGS:0];
wire [DELAY_CHAIN_WIDTH-1:0] dqsenabledelaysetting_dlc[DQS_CONFIGS:0];
wire [DELAY_CHAIN_WIDTH-1:0] dqsdisabledelaysetting_dlc[DQS_CONFIGS:0];
wire [DELAY_CHAIN_WIDTH-1:0] octdelaysetting1_dlc[DQS_CONFIGS:0];
`ifndef FAMILY_HAS_NO_DYNCONF
generate
if (USE_DYNAMIC_CONFIG == "true")
begin
genvar c_num;
for (c_num = 0; c_num <= DQS_CONFIGS; c_num = c_num + 1)
begin :dqs_config_gen
cyclonev_dqs_config dqs_config_inst
(
.clk(config_clock_in),
.datain(config_data_in),
.dataout(),
.ena(config_dqs_ena),
.update(config_update),
.postamblephasesetting(dqsenablectrlphasesetting[c_num]),
.postamblephaseinvert(dqsenablectrlphaseinvert[c_num]),
.dqsenablegatingdelaysetting(dqsenabledelaysetting[c_num]),
.dqsenableungatingdelaysetting(dqsdisabledelaysetting[c_num]),
.dqshalfratebypass(dqshalfratebypass[c_num]),
.enadqsenablephasetransferreg(enadqsenablephasetransferreg[c_num]),
.octdelaysetting(octdelaysetting1[c_num]),
.dqsbusoutdelaysetting(dqsbusoutdelaysetting[c_num])
);
assign dqsbusoutdelaysetting_dlc[c_num] = dqsbusoutdelaysetting[c_num];
assign dqsenabledelaysetting_dlc[c_num] = dqsenabledelaysetting[c_num];
assign dqsdisabledelaysetting_dlc[c_num] = dqsdisabledelaysetting[c_num];
assign octdelaysetting1_dlc[c_num] = octdelaysetting1[c_num];
end
end
endgenerate
`endif
generate
if (USE_BIDIR_STROBE == "true")
begin
assign output_strobe_out = 1'b0;
assign output_strobe_n_out = 1'b1;
end
else
begin
assign strobe_io = 1'b0;
assign strobe_n_io = 1'b1;
end
endgenerate
wire dq_dr_clock;
wire dqs_dr_clock;
wire dq_shifted_clock;
wire dqs_shifted_clock;
wire write_strobe_clock;
wire hr_seq_clock;
wire ena_clock;
wire ena_zero_phase_clock;
wire phy_clk_dqs_2x;
wire phy_clk_dqs;
wire phy_clk_dq;
wire phy_clk_hr;
generate
if (HHP_HPS == "true") begin
assign phy_clk_hr = hr_clock_in;
assign phy_clk_dq = fr_clock_in;
assign phy_clk_dqs = write_strobe_clock_in;
assign phy_clk_dqs_2x = dr_clock_in;
end else begin
cyclonev_phy_clkbuf phy_clkbuf (
.inclk ({hr_clock_in, fr_clock_in, write_strobe_clock_in, dr_clock_in}),
.outclk ({phy_clk_hr, phy_clk_dq, phy_clk_dqs, phy_clk_dqs_2x})
);
end
endgenerate
wire [3:0] leveled_dqs_clocks;
wire [3:0] leveled_dq_clocks;
wire [3:0] leveled_hr_clocks;
cyclonev_leveling_delay_chain leveling_delay_chain_dqs (
.clkin (phy_clk_dqs),
.delayctrlin (dll_delay_value),
.clkout(leveled_dqs_clocks)
);
defparam leveling_delay_chain_dqs.physical_clock_source = "DQS";
cyclonev_clk_phase_select clk_phase_select_dqs (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(),
.clkin (leveled_dqs_clocks[0]),
.clkout (dqs_shifted_clock)
);
defparam clk_phase_select_dqs.physical_clock_source = "DQS";
defparam clk_phase_select_dqs.use_phasectrlin = "false";
defparam clk_phase_select_dqs.phase_setting = 0;
generate
if (SEPERATE_LDC_FOR_WRITE_STROBE == "true") begin
wire extra_phy_clk_dqs_2x;
wire extra_phy_clk_dqs;
wire extra_phy_clk_dq;
wire extra_phy_clk_hr;
cyclonev_phy_clkbuf phy_clkbuf (
.inclk ({hr_clock_in, fr_clock_in, write_strobe_clock_in, dr_clock_in}),
.outclk ({extra_phy_clk_hr, extra_phy_clk_dq, extra_phy_clk_dqs, extra_phy_clk_dqs_2x})
);
wire [3:0] extra_leveled_dqs_clocks;
cyclonev_leveling_delay_chain leveling_delay_chain_dqs (
.clkin (extra_phy_clk_dqs),
.delayctrlin (dll_delay_value),
.clkout(extra_leveled_dqs_clocks)
);
defparam leveling_delay_chain_dqs.physical_clock_source = "DQS";
cyclonev_clk_phase_select clk_phase_select_dqs (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(),
.clkin (extra_leveled_dqs_clocks[0]),
.clkout (write_strobe_clock)
);
defparam clk_phase_select_dqs.physical_clock_source = "DQS";
defparam clk_phase_select_dqs.use_phasectrlin = "false";
defparam clk_phase_select_dqs.phase_setting = 0;
end else begin
assign write_strobe_clock = dqs_shifted_clock;
end
endgenerate
cyclonev_clk_phase_select clk_phase_select_pst_0p (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(dqsbusout),
.clkin (leveled_dqs_clocks[0]),
.clkout (ena_zero_phase_clock)
);
defparam clk_phase_select_pst_0p.physical_clock_source = "PST_0P";
defparam clk_phase_select_pst_0p.use_phasectrlin = "false";
defparam clk_phase_select_pst_0p.phase_setting = 0;
defparam clk_phase_select_pst_0p.use_dqs_input = USE_DQSIN_FOR_VFIFO_READ;
generate
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_clk_phase_select clk_phase_select_pst (
.clkin (leveled_dqs_clocks),
.phasectrlin(dqsenablectrlphasesetting[0]),
.phaseinvertctrl(dqsenablectrlphaseinvert[0]),
.clkout (ena_clock),
.dqsin()
);
defparam clk_phase_select_pst.physical_clock_source = "PST";
defparam clk_phase_select_pst.invert_phase = "dynamic";
end
else
begin
cyclonev_clk_phase_select clk_phase_select_pst (
.clkin (leveled_dqs_clocks),
.phasectrlin(),
.phaseinvertctrl(),
.clkout (ena_clock),
.dqsin()
);
defparam clk_phase_select_pst.physical_clock_source = "PST";
defparam clk_phase_select_pst.use_phasectrlin = "false";
end
endgenerate
cyclonev_leveling_delay_chain leveling_delay_chain_dq (
.clkin (phy_clk_dq),
.delayctrlin (),
.clkout(leveled_dq_clocks)
);
defparam leveling_delay_chain_dq.physical_clock_source = "DQ";
cyclonev_clk_phase_select clk_phase_select_dq (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(),
.clkin (leveled_dq_clocks[0]),
.clkout (dq_shifted_clock)
);
defparam clk_phase_select_dq.physical_clock_source = "DQ";
defparam clk_phase_select_dq.use_phasectrlin = "false";
defparam clk_phase_select_dq.phase_setting = 0;
cyclonev_leveling_delay_chain leveling_delay_chain_hr (
.clkin (phy_clk_hr),
.delayctrlin (),
.clkout(leveled_hr_clocks)
);
defparam leveling_delay_chain_hr.physical_clock_source = "HR";
cyclonev_clk_phase_select clk_phase_select_hr (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(),
.clkin (leveled_hr_clocks[0]),
.clkout (hr_seq_clock)
);
defparam clk_phase_select_hr.physical_clock_source = "HR";
defparam clk_phase_select_hr.use_phasectrlin = "false";
defparam clk_phase_select_hr.phase_setting = 0;
generate
if (USE_2X_FF == "true")
begin
wire [3:0] leveled_dqs_2x_clocks;
cyclonev_leveling_delay_chain leveling_delay_chain_dqs_2x (
.clkin (phy_clk_dqs_2x),
.delayctrlin (),
.clkout(leveled_dqs_2x_clocks)
);
defparam leveling_delay_chain_dqs_2x.physical_clock_source = "DQS_2X";
cyclonev_clk_phase_select clk_phase_select_dqs_2x (
.phasectrlin(),
.phaseinvertctrl(),
.dqsin(),
.clkin (leveled_dqs_2x_clocks[0]),
.clkout (dqs_dr_clock)
);
defparam clk_phase_select_dqs_2x.physical_clock_source = "DQS_2X";
defparam clk_phase_select_dqs_2x.use_phasectrlin = "false";
defparam clk_phase_select_dqs_2x.phase_setting = 0;
assign dq_dr_clock = dqs_dr_clock;
end
endgenerate
generate
wire vfifo_capture_strobe_ena;
wire lfifo_rden;
wire lfifo_oct;
if (USE_HARD_FIFOS == "true" && (PIN_TYPE == "input" || PIN_TYPE == "bidir"))
begin
wire vfifo_qvld_fr;
wire vfifo_inc_wr_ptr_fr;
wire lfifo_rdata_en_fr;
wire lfifo_rdata_en_full_fr;
if (USE_HALF_RATE_OUTPUT == "true")
begin
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_vfifo_qvld (
.datainhi(vfifo_qvld[0]),
.datainlo(vfifo_qvld[1]),
.dataout(vfifo_qvld_fr),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dqshalfratebypass[0]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_vfifo_inc_wr_ptr (
.datainhi(vfifo_inc_wr_ptr[0]),
.datainlo(vfifo_inc_wr_ptr[1]),
.dataout(vfifo_inc_wr_ptr_fr),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dqshalfratebypass[0]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_lfifo_rdata_en (
.datainhi(lfifo_rdata_en[0]),
.datainlo(lfifo_rdata_en[1]),
.dataout(lfifo_rdata_en_fr),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dqshalfratebypass[0]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_lfifo_rdata_en_full (
.datainhi(lfifo_rdata_en_full[0]),
.datainlo(lfifo_rdata_en_full[1]),
.dataout(lfifo_rdata_en_full_fr),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dqshalfratebypass[0]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
end
else
begin
assign vfifo_qvld_fr = vfifo_qvld[0];
assign vfifo_inc_wr_ptr_fr = vfifo_inc_wr_ptr[0];
assign lfifo_rdata_en_fr = lfifo_rdata_en[0];
assign lfifo_rdata_en_full_fr = lfifo_rdata_en_full[0];
end
cyclonev_vfifo
vfifo (
.rstn (vfifo_reset_n),
.qvldin (vfifo_qvld_fr),
.qvldreg (vfifo_capture_strobe_ena),
.incwrptr (vfifo_inc_wr_ptr_fr),
.wrclk (dqs_shifted_clock),
.rdclk (ena_zero_phase_clock)
);
wire [LFIFO_RD_LATENCY_WIDTH-1:0] lfifo_rd_latency_full_rate;
assign lfifo_rd_latency_full_rate = lfifo_rd_latency << (DATA_RATE-1);
cyclonev_lfifo
#(
.oct_lfifo_enable(LFIFO_OCT_EN_MASK)
) lfifo (
.rdataen (lfifo_rdata_en_fr),
.rdataenfull (lfifo_rdata_en_full_fr),
.rdlatency (lfifo_rd_latency_full_rate),
.rstn (lfifo_reset_n),
.clk (dqs_shifted_clock),
.rden (lfifo_rden),
.rdatavalid(lfifo_rdata_valid),
.octlfifo(lfifo_oct)
);
end
else
begin
assign vfifo_capture_strobe_ena = 1'b0;
assign lfifo_rden = 1'b0;
assign lfifo_rdata_valid = 1'b0;
assign lfifo_oct = 1'b0;
end
endgenerate
wire delayed_oct;
generate
wire fr_os_oct;
wire aligned_os_oct;
if (USE_HALF_RATE_OUTPUT == "true")
begin
if (EMIF_BYPASS_OCT_DDIO == "true")
begin
assign fr_os_oct = oct_ena[0];
end
else
begin
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_os_oct (
.datainhi(oct_ena[0]),
.datainlo(oct_ena[1]),
.dataout(fr_os_oct),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dqshalfratebypass[0]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
end
end
else
begin
assign fr_os_oct = fr_term;
end
if (USE_HARD_FIFOS == "true")
begin
if (EMIF_BYPASS_OCT_DDIO == "true")
begin
assign aligned_os_oct = fr_os_oct;
end
else
begin
cyclonev_ddio_oe # (
.disable_second_level_register("true")
) os_oct_ddio_oe (
.clk (dqs_shifted_clock),
.oe (fr_os_oct),
.octreadcontrol (lfifo_oct),
.dataout (aligned_os_oct),
.ena (1'b1),
.areset (),
.sreset (),
.dfflo (),
.dffhi (),
.devpor (),
.devclrn ()
);
end
end
else
begin
reg oct_oe_reg;
always @(posedge dqs_shifted_clock) oct_oe_reg <= fr_os_oct;
assign aligned_os_oct = oct_oe_reg;
end
wire predelayed_os_oct;
if (USE_2X_FF == "true")
begin
reg dd_os_oct;
always @(posedge dqs_dr_clock)
begin
dd_os_oct <= aligned_os_oct;
end
assign predelayed_os_oct = dd_os_oct;
end
else
begin
assign predelayed_os_oct = aligned_os_oct;
end
if (USE_DYNAMIC_CONFIG == "true")
begin
if (EMIF_BYPASS_OCT_DDIO == "true")
begin
assign delayed_oct = predelayed_os_oct;
end
else
begin
cyclonev_delay_chain # (
.sim_intrinsic_rising_delay(0),
.sim_intrinsic_falling_delay(0)
) oct_delay (
.datain (predelayed_os_oct),
.delayctrlin (octdelaysetting1_dlc[0]),
.dataout (delayed_oct)
);
end
end
else
begin
assign delayed_oct = predelayed_os_oct;
end
endgenerate
generate
if (PIN_TYPE == "input" || PIN_TYPE == "bidir")
begin
assign capture_strobe = dqsbusout;
wire dqsin;
wire capture_strobe_ibuf_i;
wire capture_strobe_ibuf_ibar;
if (USE_BIDIR_STROBE == "true")
begin
if (SWAP_CAPTURE_STROBE_POLARITY == "true") begin
assign capture_strobe_ibuf_i = strobe_n_io;
assign capture_strobe_ibuf_ibar = strobe_io;
end else begin
assign capture_strobe_ibuf_i = strobe_io;
assign capture_strobe_ibuf_ibar = strobe_n_io;
end
end
else
begin
if (SWAP_CAPTURE_STROBE_POLARITY == "true") begin
assign capture_strobe_ibuf_i = capture_strobe_n_in;
assign capture_strobe_ibuf_ibar = capture_strobe_in;
end else begin
assign capture_strobe_ibuf_i = capture_strobe_in;
assign capture_strobe_ibuf_ibar = capture_strobe_n_in;
end
end
if (DIFFERENTIAL_CAPTURE_STROBE == "true")
begin
cyclonev_io_ibuf
#(
.differential_mode(DIFFERENTIAL_CAPTURE_STROBE),
.bus_hold("false")
) strobe_in (
.i(capture_strobe_ibuf_i),
.ibar(capture_strobe_ibuf_ibar),
.o(dqsin),
.dynamicterminationcontrol(1'b0)
);
end
else
begin
cyclonev_io_ibuf
#(
.bus_hold("false")
) strobe_in (
.i(capture_strobe_ibuf_i),
.o(dqsin),
.ibar(),
.dynamicterminationcontrol(1'b0)
);
end
wire capture_strobe_ena_fr;
if (USE_HARD_FIFOS == "true")
begin
assign capture_strobe_ena_fr = vfifo_capture_strobe_ena;
end
else
begin
if (DQS_ENABLE_WIDTH > 1)
begin
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_ena (
.datainhi(capture_strobe_ena[0]),
.datainlo(capture_strobe_ena[1]),
.dataout(capture_strobe_ena_fr),
.clkhi (strobe_ena_hr_clock_in),
.clklo (strobe_ena_hr_clock_in),
.hrbypass(dqshalfratebypass[0]),
.muxsel (strobe_ena_hr_clock_in)
);
end
else
begin
assign capture_strobe_ena_fr = capture_strobe_ena;
end
end
wire dqs_enable_shifted;
wire dqs_shifted;
wire dqs_enable_int;
wire dqs_disable_int;
if (USE_BIDIR_STROBE == "true")
begin
wire dqs_pre_delayed;
assign dqs_pre_delayed = capture_strobe_ena_fr;
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_dqs_enable_ctrl
#(
.add_phase_transfer_reg(DYNAMIC_MODE),
.delay_dqs_enable("one_and_half_cycle")
) dqs_enable_ctrl (
.dqsenablein (dqs_pre_delayed),
.zerophaseclk (ena_zero_phase_clock),
.levelingclk (ena_clock),
.dqsenableout (dqs_enable_shifted),
.enaphasetransferreg(enadqsenablephasetransferreg[0]),
.rstn(),
.dffin()
);
end
else
begin
cyclonev_dqs_enable_ctrl
#(
.delay_dqs_enable("one_and_half_cycle")
) dqs_enable_ctrl (
.dqsenablein (dqs_pre_delayed),
.zerophaseclk (ena_zero_phase_clock),
.levelingclk (ena_clock),
.dqsenableout (dqs_enable_shifted),
.rstn(),
.dffin()
);
end
cyclonev_dqs_delay_chain
#(
.dqs_period(INPUT_FREQ_PS),
.dqs_phase_shift(DQS_PHASE_SHIFT),
.dqs_delay_chain_bypass(DQS_DELAYCHAIN_BYPASS)
)
dqs_delay_chain (
.dqsin (dqsin),
.delayctrlin (dll_delay_value),
.dqsenable (dqs_enable_int),
.dqsdisablen (dqs_disable_int),
.dqsbusout (dqs_shifted),
.dqsupdateen(),
.testin(),
.dffin()
);
end
else
begin
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_dqs_delay_chain
#(
.dqs_period(INPUT_FREQ_PS),
.dqs_phase_shift(DQS_PHASE_SHIFT),
.dqs_delay_chain_bypass(DQS_DELAYCHAIN_BYPASS)
) dqs_delay_chain (
.dqsin (dqsin),
.delayctrlin (dll_delay_value),
.dqsbusout (dqs_shifted),
.dqsenable (),
.dqsdisablen (),
.dqsupdateen(),
.testin(),
.dffin()
);
end
else
begin
cyclonev_dqs_delay_chain
#(
.dqs_period(INPUT_FREQ_PS),
.dqs_phase_shift(DQS_PHASE_SHIFT),
.dqs_delay_chain_bypass(DQS_DELAYCHAIN_BYPASS)
) dqs_delay_chain (
.dqsin (dqsin),
.delayctrlin (dll_delay_value),
.dqsbusout (dqs_shifted),
.dqsenable (),
.dqsdisablen (),
.dqsupdateen(),
.testin(),
.dffin()
);
end
end
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_in_delay_1(
.datain (dqs_shifted),
.delayctrlin (dqsbusoutdelaysetting_dlc[0]),
.dataout (dqsbusout)
);
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_ena_delay_1(
.datain (dqs_enable_shifted),
.delayctrlin (dqsenabledelaysetting_dlc[0]),
.dataout (dqs_enable_int)
);
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_dis_delay_1(
.datain (dqs_enable_shifted),
.delayctrlin (dqsdisabledelaysetting_dlc[0]),
.dataout (dqs_disable_int)
);
end
else
begin
assign dqsbusout = dqs_shifted;
assign dqs_enable_int = dqs_enable_shifted;
assign dqs_disable_int = dqs_enable_shifted;
end
if (USE_DQS_TRACKING == "true")
begin
reg dqs_ff;
always @(negedge dqs_enable_int)
dqs_ff <= dqsin;
assign capture_strobe_tracking = dqs_ff;
end
if (SEPARATE_CAPTURE_STROBE == "true")
begin
wire dqsnin;
cyclonev_io_ibuf
#(
.bus_hold("false")
) strobe_n_in (
.i(capture_strobe_ibuf_ibar),
.o(dqsnin)
);
wire dqsn_enable_int;
wire dqsn_disable_int;
wire dqsn_enable_shifted;
wire dqsn_shifted;
if (USE_BIDIR_STROBE == "true")
begin
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_dqs_enable_ctrl
#(
.add_phase_transfer_reg(DYNAMIC_MODE),
.delay_dqs_enable("one_and_half_cycle")
) dqs_enable_n_ctrl (
.dqsenablein (capture_strobe_ena_fr),
.zerophaseclk (ena_zero_phase_clock),
.levelingclk (ena_clock),
.dqsenableout (dqsn_enable_shifted),
.enaphasetransferreg(enadqsenablephasetransferreg[0])
);
end
else
begin
cyclonev_dqs_enable_ctrl
#(
.add_phase_transfer_reg("false"),
.delay_dqs_enable("one_and_half_cycle")
) dqs_enable_n_ctrl (
.dqsenablein (capture_strobe_ena_fr),
.zerophaseclk (ena_zero_phase_clock),
.levelingclk (ena_clock),
.dqsenableout (dqsn_enable_shifted)
);
end
cyclonev_dqs_delay_chain
#(
.dqs_period(INPUT_FREQ_PS),
.dqs_phase_shift(DQS_PHASE_SHIFT),
.dqs_delay_chain_bypass(DQS_DELAYCHAIN_BYPASS)
) dqs_n_delay_chain (
.dqsin (dqsnin),
.delayctrlin (dll_delay_value),
.dqsenable (dqsn_enable_int),
.dqsdisablen (dqsn_disable_int),
.dqsbusout (dqsn_shifted)
);
end
else
begin
cyclonev_dqs_delay_chain
#(
.dqs_period(INPUT_FREQ_PS),
.dqs_phase_shift(DQS_PHASE_SHIFT),
.dqs_delay_chain_bypass(DQS_DELAYCHAIN_BYPASS)
) dqs_n_delay_chain (
.dqsin (dqsnin),
.delayctrlin (dll_delay_value),
.dqsbusout (dqsn_shifted)
);
end
if (USE_DYNAMIC_CONFIG == "true")
begin
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_n_delay_1(
.datain (dqsn_shifted),
.delayctrlin (dqsbusoutdelaysetting_dlc[0]),
.dataout (dqsnbusout)
);
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_n_ena_delay_1(
.datain (dqsn_enable_shifted),
.delayctrlin (dqsenabledelaysetting_dlc[0]),
.dataout (dqsn_enable_int)
);
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_n_dis_delay_1(
.datain (dqsn_enable_shifted),
.delayctrlin (dqsdisabledelaysetting_dlc[0]),
.dataout (dqsn_disable_int)
);
end
else
begin
assign dqsnbusout = dqsn_shifted;
assign dqsn_enable_int = dqsn_enable_shifted;
assign dqsn_disable_int = dqsn_enable_shifted;
end
end
end
endgenerate
generate
if (USE_OUTPUT_STROBE == "true")
begin
wire os;
wire os_bar;
wire os_dtc;
wire os_dtc_bar;
wire os_delayed1;
wire os_delayed2;
wire fr_os_oe;
wire aligned_os_oe;
wire aligned_strobe;
wire fr_os_hi;
wire fr_os_lo;
if (USE_HALF_RATE_OUTPUT == "true")
begin
if (USE_BIDIR_STROBE == "true")
begin
wire clk_gate_hi;
wire clk_gate_lo;
if (PREAMBLE_TYPE == "low")
begin
if (EMIF_UNALIGNED_PREAMBLE_SUPPORT != "true")
begin
assign clk_gate_hi = output_strobe_ena[0];
assign clk_gate_lo = output_strobe_ena[0];
end
else
begin
reg [1:0] os_ena_reg;
reg [1:0] os_ena_preamble;
always @(posedge core_clock_in)
begin
os_ena_reg[1:0] <= output_strobe_ena[1:0];
end
always @(*)
begin
case ({os_ena_reg[0], os_ena_reg[1],
output_strobe_ena[0], output_strobe_ena[1]})
4'b00_00: os_ena_preamble[1:0] <= 2'b00;
4'b00_01: os_ena_preamble[1:0] <= 2'b00;
4'b00_10: os_ena_preamble[1:0] <= 2'b00;
4'b00_11: os_ena_preamble[1:0] <= 2'b01;
4'b01_00: os_ena_preamble[1:0] <= 2'b00;
4'b01_01: os_ena_preamble[1:0] <= 2'b00;
4'b01_10: os_ena_preamble[1:0] <= 2'b10;
4'b01_11: os_ena_preamble[1:0] <= 2'b11;
4'b10_00: os_ena_preamble[1:0] <= 2'b00;
4'b10_01: os_ena_preamble[1:0] <= 2'b00;
4'b10_10: os_ena_preamble[1:0] <= 2'b00;
4'b10_11: os_ena_preamble[1:0] <= 2'b01;
4'b11_00: os_ena_preamble[1:0] <= 2'b00;
4'b11_01: os_ena_preamble[1:0] <= 2'b00;
4'b11_10: os_ena_preamble[1:0] <= 2'b10;
4'b11_11: os_ena_preamble[1:0] <= 2'b11;
default: os_ena_preamble[1:0] <= 2'b00;
endcase
end
assign clk_gate_hi = os_ena_preamble[1];
assign clk_gate_lo = os_ena_preamble[0];
end
end
else
begin
assign clk_gate_hi = 1'b1;
assign clk_gate_lo = 1'b1;
end
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_os_hi (
.hrbypass(1'b1),
.datainhi(write_strobe[0]),
.datainlo(write_strobe[2]),
.dataout(fr_os_hi),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_os_lo (
.hrbypass(1'b1),
.datainhi(write_strobe[1]),
.datainlo(write_strobe[3]),
.dataout(fr_os_lo),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_os_oe (
.hrbypass(1'b1),
.datainhi(~output_strobe_ena [0]),
.datainlo(~output_strobe_ena [1]),
.dataout(fr_os_oe),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
end
else
begin
wire gnd_lut /* synthesis keep = 1*/;
assign gnd_lut = 1'b0;
assign fr_os_lo = gnd_lut;
assign fr_os_oe = 1'b0;
if (USE_OUTPUT_STROBE_RESET == "true") begin
reg clk_h /* synthesis dont_merge */;
always @(posedge write_strobe_clock_in or negedge reset_n_core_clock_in)
begin
if (~reset_n_core_clock_in)
clk_h <= 1'b0;
else
clk_h <= 1'b1;
end
assign fr_os_hi = clk_h;
end else begin
assign fr_os_hi = 1'b1;
end
end
end
else
begin
if (USE_BIDIR_STROBE == "true")
begin
assign fr_os_oe = ~output_strobe_ena[0];
wire gnd_lut /* synthesis keep = 1*/;
assign gnd_lut = 1'b0;
assign fr_os_lo = gnd_lut;
if (PREAMBLE_TYPE == "low")
begin
reg os_ena_reg1;
initial
os_ena_reg1 = 0;
always @(posedge core_clock_in)
os_ena_reg1 <= output_strobe_ena[0];
assign fr_os_hi = os_ena_reg1 & output_strobe_ena[0];
end
else
begin
wire vcc_lut /* synthesis keep = 1*/;
assign vcc_lut = 1'b1;
assign fr_os_hi = vcc_lut;
end
end
else
begin
wire gnd_lut /* synthesis keep = 1*/;
assign gnd_lut = 1'b0;
assign fr_os_lo = gnd_lut;
assign fr_os_oe = 1'b0;
if (USE_OUTPUT_STROBE_RESET == "true") begin
reg clk_h /* synthesis dont_merge */;
always @(posedge write_strobe_clock_in or negedge reset_n_core_clock_in)
begin
if (~reset_n_core_clock_in)
clk_h <= 1'b0;
else
clk_h <= 1'b1;
end
assign fr_os_hi = clk_h;
end else begin
assign fr_os_hi = 1'b1;
end
end
end
if (USE_OUTPUT_PHASE_ALIGNMENT == "true")
begin
end
else
begin
/*
cyclonev_ddio_oe
os_oe_ddio_oe (
.clk (write_strobe_clock_in),
.oe (fr_os_oe),
.dataout (aligned_os_oe)
);
*/
reg os_oe_reg;
always @(posedge write_strobe_clock) os_oe_reg <= fr_os_oe;
assign aligned_os_oe = os_oe_reg;
cyclonev_ddio_out
#(
.half_rate_mode("false"),
.use_new_clocking_model("true"),
.async_mode("none")
) phase_align_os (
.datainhi(fr_os_hi),
.datainlo(fr_os_lo),
.dataout(aligned_strobe),
.clkhi (write_strobe_clock),
.clklo (write_strobe_clock),
.muxsel (write_strobe_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn(),
.hrbypass()
);
end
wire delayed_os_oe;
wire predelayed_os;
wire predelayed_os_oe;
if (USE_2X_FF == "true")
begin
reg dd_os;
reg dd_os_oe;
always @(posedge dqs_dr_clock)
begin
dd_os <= aligned_strobe;
dd_os_oe <= aligned_os_oe;
end
assign predelayed_os = dd_os;
assign predelayed_os_oe = dd_os_oe;
end
else
begin
assign predelayed_os = aligned_strobe;
assign predelayed_os_oe = aligned_os_oe;
end
if (USE_DYNAMIC_CONFIG == "true")
begin
`ifndef FAMILY_HAS_NO_DYNCONF
wire delayed_os_oe_1;
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
dqs_out_delay_1(
.datain (predelayed_os),
.delayctrlin (dqs_outputdelaysetting_dlc),
.dataout (os_delayed1)
);
assign os_delayed2 = os_delayed1;
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
oe_delay_1(
.datain (predelayed_os_oe),
.delayctrlin (dqs_outputenabledelaysetting_dlc),
.dataout (delayed_os_oe_1)
);
assign delayed_os_oe = delayed_os_oe_1;
`endif
end
else
begin
assign os_delayed2 = aligned_strobe;
assign delayed_os_oe = aligned_os_oe;
end
wire diff_oe;
wire diff_oe_bar;
wire diff_dtc;
wire diff_dtc_bar;
if (DIFFERENTIAL_OUTPUT_STROBE=="true")
begin
if (USE_BIDIR_STROBE == "true")
begin
cyclonev_pseudo_diff_out pseudo_diffa_0
(
.oein(delayed_os_oe),
.dtcin(delayed_oct),
.oeout(diff_oe),
.oebout(diff_oe_bar),
.dtc(diff_dtc),
.dtcbar(diff_dtc_bar),
.i(os_delayed2),
.o(os),
.obar(os_bar)
);
cyclonev_io_obuf
#(
.sim_dynamic_termination_control_is_connected("true"),
.bus_hold("false"),
.open_drain_output("false")
) obuf_os_bar_0
(
.i(os_bar),
.o(strobe_n_io),
.obar(),
.oe(~diff_oe_bar),
.parallelterminationcontrol (parallelterminationcontrol_in),
.dynamicterminationcontrol (diff_dtc_bar),
.seriesterminationcontrol (seriesterminationcontrol_in),
.devoe()
);
end
else
begin
cyclonev_pseudo_diff_out pseudo_diffa_0
(
.oein(1'b0),
.oeout(diff_oe),
.oebout(diff_oe_bar),
.i(os_delayed2),
.o(os),
.obar(os_bar),
.dtcin(),
.dtc(),
.dtcbar()
);
cyclonev_io_obuf
#(
.bus_hold("false"),
.open_drain_output("false")
) obuf_os_bar_0
(
.i(os_bar),
.o(output_strobe_n_out),
.obar(),
.oe(~diff_oe_bar),
.dynamicterminationcontrol(1'b0),
.seriesterminationcontrol(),
.parallelterminationcontrol(),
.devoe()
);
end
end
else
begin
assign os = os_delayed2;
assign diff_dtc = delayed_oct;
assign diff_oe = delayed_os_oe;
end
if (USE_BIDIR_STROBE == "true")
begin
cyclonev_io_obuf
#(
.sim_dynamic_termination_control_is_connected("true"),
.bus_hold("false"),
.open_drain_output("false")
) obuf_os_0
(
.i(os),
.o(strobe_io),
.obar(),
.oe(~diff_oe),
.parallelterminationcontrol (parallelterminationcontrol_in),
.dynamicterminationcontrol (diff_dtc),
.seriesterminationcontrol (seriesterminationcontrol_in),
.devoe()
);
end
else
begin
cyclonev_io_obuf
#(
.bus_hold("false"),
.open_drain_output("false")
) obuf_os_0
(
.i(os),
.o(output_strobe_out),
.obar(),
.oe(~diff_oe),
.parallelterminationcontrol (),
.dynamicterminationcontrol (1'b0),
.seriesterminationcontrol (),
.devoe()
);
end
end
endgenerate
wire [PIN_WIDTH-1:0] aligned_oe ;
wire [PIN_WIDTH-1:0] aligned_data;
wire [PIN_WIDTH-1:0] ddr_data;
wire [PIN_WIDTH-1:0] dq_outputhalfratebypass;
wire [PIN_WIDTH*2-1:0] rfifo_clock_select;
wire [PIN_WIDTH*3-1:0] rfifo_mode;
generate
if (PIN_TYPE == "output" || PIN_TYPE == "bidir")
begin
genvar opin_num;
for (opin_num = 0; opin_num < PIN_WIDTH; opin_num = opin_num + 1)
begin :output_path_gen
wire fr_data_hi;
wire fr_data_lo;
wire fr_oe;
if (USE_HALF_RATE_OUTPUT == "true")
begin
wire hr_data_t0;
wire hr_data_t1;
wire hr_data_t2;
wire hr_data_t3;
wire write_oe_hi;
wire write_oe_lo;
if (NATURAL_ALIGNMENT == "true")
begin
assign hr_data_t0 = write_data_in [opin_num * rate_mult_out];
assign hr_data_t1 = write_data_in [opin_num * rate_mult_out + 1];
assign hr_data_t2 = write_data_in [opin_num * rate_mult_out + 2];
assign hr_data_t3 = write_data_in [opin_num * rate_mult_out + 3];
assign write_oe_hi = write_oe_in [2*opin_num + 0];
assign write_oe_lo = write_oe_in [2*opin_num + 1];
end
else if (REGULAR_WRITE_BUS_ORDERING == "true")
begin
assign hr_data_t0 = write_data_in [opin_num + 0*PIN_WIDTH];
assign hr_data_t1 = write_data_in [opin_num + 1*PIN_WIDTH];
assign hr_data_t2 = write_data_in [opin_num + 2*PIN_WIDTH];
assign hr_data_t3 = write_data_in [opin_num + 3*PIN_WIDTH];
assign write_oe_hi = write_oe_in [opin_num + 0];
assign write_oe_lo = write_oe_in [opin_num + PIN_WIDTH];
end
else
begin
assign hr_data_t0 = write_data_in [opin_num + 1*PIN_WIDTH];
assign hr_data_t1 = write_data_in [opin_num + 0*PIN_WIDTH];
assign hr_data_t2 = write_data_in [opin_num + 3*PIN_WIDTH];
assign hr_data_t3 = write_data_in [opin_num + 2*PIN_WIDTH];
assign write_oe_hi = write_oe_in [opin_num + 0];
assign write_oe_lo = write_oe_in [opin_num + PIN_WIDTH];
end
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_hi (
.datainhi(hr_data_t0),
.datainlo(hr_data_t2),
.dataout(fr_data_hi),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dq_outputhalfratebypass[opin_num]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_lo (
.datainhi(hr_data_t1),
.datainlo(hr_data_t3),
.dataout(fr_data_lo),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dq_outputhalfratebypass[opin_num]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true")
) hr_to_fr_oe (
.datainhi(~write_oe_hi),
.datainlo(~write_oe_lo),
.dataout(fr_oe),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(dq_outputhalfratebypass[opin_num]),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
end
else
begin
if (NATURAL_ALIGNMENT == "true")
begin
assign fr_data_lo = write_data_in [opin_num * rate_mult_out + 1];
assign fr_data_hi = write_data_in [opin_num * rate_mult_out];
end
else
begin
assign fr_data_lo = write_data_in [opin_num+PIN_WIDTH];
assign fr_data_hi = write_data_in [opin_num];
end
assign fr_oe = ~write_oe_in [opin_num];
end
if (USE_OUTPUT_PHASE_ALIGNMENT == "true")
begin
end
else
begin
cyclonev_ddio_out
#(
.async_mode("none"),
.half_rate_mode("false"),
.sync_mode("none"),
.use_new_clocking_model("true")
) ddio_out (
.datainhi(fr_data_hi),
.datainlo(fr_data_lo),
.dataout(aligned_data[opin_num]),
.clkhi (dq_shifted_clock),
.clklo (dq_shifted_clock),
.muxsel (dq_shifted_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn(),
.hrbypass()
);
/*
cyclonev_ddio_oe
dq_oe_ddio_oe (
.clk (fr_clock_in),
.oe (fr_oe),
.dataout (aligned_oe [opin_num])
);
*/
reg oe_reg /* synthesis dont_merge altera_attribute="FAST_OUTPUT_ENABLE_REGISTER=on" */;
always @(posedge dq_shifted_clock) oe_reg <= fr_oe;
assign aligned_oe[opin_num] = oe_reg;
end
end
end
endgenerate
generate
if (PIN_TYPE == "input" || PIN_TYPE == "bidir")
begin
genvar ipin_num;
for (ipin_num = 0; ipin_num < PIN_WIDTH; ipin_num = ipin_num + 1)
begin :input_path_gen
wire [1:0] sdr_data;
wire [1:0] aligned_input;
wire dqsbusout_to_ddio_in;
wire dqsnbusout_to_ddio_in;
if (INVERT_CAPTURE_STROBE == "true") begin
assign dqsbusout_to_ddio_in = ~dqsbusout;
if (SEPARATE_CAPTURE_STROBE == "true") begin
assign dqsnbusout_to_ddio_in = ~dqsnbusout;
end
end else begin
assign dqsbusout_to_ddio_in = dqsbusout;
if (SEPARATE_CAPTURE_STROBE == "true") begin
assign dqsnbusout_to_ddio_in = dqsnbusout;
end
end
if (SEPARATE_CAPTURE_STROBE == "true") begin
cyclonev_ddio_in
#(
.use_clkn("true"),
.async_mode("none"),
.sync_mode("none")
) capture_reg(
.datain(ddr_data[ipin_num]),
.clk (dqsbusout_to_ddio_in),
.clkn (dqsnbusout_to_ddio_in),
.regouthi(sdr_data[1]),
.regoutlo(sdr_data[0]),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.devpor(),
.devclrn()
);
end else begin
cyclonev_ddio_in
#(
.use_clkn("false"),
.async_mode("none"),
.sync_mode("none")
) capture_reg(
.datain(ddr_data[ipin_num]),
.clk (dqsbusout_to_ddio_in),
.regouthi(sdr_data[1]),
.regoutlo(sdr_data[0]),
.clkn(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.devpor(),
.devclrn()
);
end
if (USE_INPUT_PHASE_ALIGNMENT == "true")
begin
end
else
begin
assign aligned_input = sdr_data;
end
wire [3:0] read_fifo_out;
if (USE_HARD_FIFOS == "true")
begin
wire wren;
if (USE_BIDIR_STROBE == "true")
begin
assign wren = 1'b1;
end
else
begin
assign wren = vfifo_capture_strobe_ena;
end
wire rfifo_rd_clk;
if(USE_DYNAMIC_CONFIG == "true") begin
cyclonev_read_fifo_read_clock_select
read_fifo_clk_sel
(
.clkin({hr_seq_clock, dqs_shifted_clock, 1'b0}),
.clksel(rfifo_clock_select[(ipin_num+1)*2-1:ipin_num*2]),
.clkout (rfifo_rd_clk)
);
end
else begin
if (USE_HALF_RATE_OUTPUT == "true") begin
assign rfifo_rd_clk = hr_seq_clock;
end
else begin
assign rfifo_rd_clk = dqs_shifted_clock;
end
end
wire writeclk;
// in skip-cal mode, the read_fifo writeclk cannot be x otherwise we pick up an
// extra edge at the beginning and there is no calibration to reset things after the first edge
// synthesis translate_off
assign writeclk = (dqsbusout_to_ddio_in === 1'b0) ? 1'b0 : 1'b1;
// synthesis translate_on
// synthesis read_comments_as_HDL on
// assign writeclk = dqsbusout_to_ddio_in;
// synthesis read_comments_as_HDL off
localparam READ_FIFO_MODE = (USE_HALF_RATE_OUTPUT == "true") ? "hrate_mode" : "frate_mode";
cyclonev_ir_fifo_userdes
read_fifo
(
.rstn (rfifo_reset_n),
.dinfiforx (aligned_input),
.writeclk (writeclk),
.writeenable (wren),
.dout (read_fifo_out),
.readclk (rfifo_rd_clk),
.dynfifomode(rfifo_mode[(ipin_num+1)*3-1:ipin_num*3]),
.readenable(lfifo_rden),
.tstclk(),
.regscanovrd(),
.bslipin(),
.txin(),
.loaden(),
.bslipctl(),
.regscan(),
.scanin(),
.lvdsmodeen(),
.lvdstxsel(),
.txout(),
.rxout(),
.bslipout(),
.bslipmax(),
.scanout(),
.observableout(),
.observablefout1(),
.observablefout2(),
.observablefout3(),
.observablefout4(),
.observablewaddrcnt(),
.observableraddrcnt()
);
defparam read_fifo.a_use_dynamic_fifo_mode = USE_DYNAMIC_CONFIG;
defparam read_fifo.a_rb_fifo_mode = READ_FIFO_MODE;
defparam read_fifo.a_sim_wclk_pre_delay = 10;
defparam read_fifo.a_sim_readenable_pre_delay = 10;
end
else
begin
assign read_fifo_out = aligned_input;
end
if (REVERSE_READ_WORDS == "true")
begin
if (USE_HALF_RATE_OUTPUT == "true")
begin
assign read_data_out [ipin_num] = read_fifo_out [3];
assign read_data_out [PIN_WIDTH +ipin_num] = read_fifo_out [2];
assign read_data_out [PIN_WIDTH*2 +ipin_num] = read_fifo_out [1];
assign read_data_out [PIN_WIDTH*3 +ipin_num] = read_fifo_out [0];
end
else
begin
assign read_data_out [ipin_num] = read_fifo_out [1];
assign read_data_out [PIN_WIDTH +ipin_num] = read_fifo_out [0];
end
end
else if (NATURAL_ALIGNMENT == "true")
begin
assign read_data_out [ipin_num*rate_mult_out] = read_fifo_out [0];
assign read_data_out [ipin_num*rate_mult_out + 1] = read_fifo_out [1];
if (USE_HALF_RATE_OUTPUT == "true")
begin
assign read_data_out [ipin_num*rate_mult_out + 2] = read_fifo_out [2];
assign read_data_out [ipin_num*rate_mult_out + 3] = read_fifo_out [3];
end
end
else
begin
assign read_data_out [ipin_num] = read_fifo_out [0];
assign read_data_out [PIN_WIDTH +ipin_num] = read_fifo_out [1];
if (USE_HALF_RATE_OUTPUT == "true")
begin
assign read_data_out [PIN_WIDTH*2 +ipin_num] = read_fifo_out [2];
assign read_data_out [PIN_WIDTH*3 +ipin_num] = read_fifo_out [3];
end
end
end
end
endgenerate
generate
genvar pin_num;
for (pin_num = 0; pin_num < PIN_WIDTH; pin_num = pin_num + 1)
begin :pad_gen
if (PIN_TYPE == "bidir")
begin
assign write_data_out [pin_num] = 1'b0;
end
else
begin
assign read_write_data_io [pin_num] = 1'b0;
end
wire delayed_data_in;
wire delayed_data_out;
wire delayed_oe;
wire [4:0] dq_outputdelaysetting;
wire [4:0] dq_outputenabledelaysetting;
wire [4:0] dq_inputdelaysetting;
wire [DELAY_CHAIN_WIDTH-1:0] dq_outputdelaysetting_dlc;
wire [DELAY_CHAIN_WIDTH-1:0] dq_outputenabledelaysetting_dlc;
wire [DELAY_CHAIN_WIDTH-1:0] dq_inputdelaysetting_dlc;
if (USE_DYNAMIC_CONFIG == "true")
begin
`ifndef FAMILY_HAS_NO_DYNCONF
cyclonev_io_config config_1 (
.datain(config_data_in),
.clk(config_clock_in),
.ena(config_io_ena[pin_num]),
.update(config_update),
.outputregdelaysetting(dq_outputdelaysetting),
.outputenabledelaysetting(dq_outputenabledelaysetting),
.outputhalfratebypass(dq_outputhalfratebypass[pin_num]),
.readfiforeadclockselect(rfifo_clock_select[(pin_num+1)*2-1:pin_num*2]),
.readfifomode(rfifo_mode[(pin_num+1)*3-1:pin_num*3]),
.padtoinputregisterdelaysetting(dq_inputdelaysetting),
.dataout()
);
`endif
assign dq_outputdelaysetting_dlc = dq_outputdelaysetting;
assign dq_outputenabledelaysetting_dlc = dq_outputenabledelaysetting;
assign dq_inputdelaysetting_dlc = dq_inputdelaysetting;
end
if (PIN_TYPE == "input" || PIN_TYPE == "bidir")
begin
wire raw_input;
if (USE_DYNAMIC_CONFIG == "true")
begin
`ifndef FAMILY_HAS_NO_DYNCONF
cyclonev_delay_chain in_delay_1(
.datain (raw_input),
.delayctrlin (dq_inputdelaysetting_dlc),
.dataout (ddr_data[pin_num])
);
`endif
end
else
begin
assign ddr_data[pin_num] = raw_input;
end
if (PIN_TYPE == "bidir")
begin
cyclonev_io_ibuf data_in (
.i(read_write_data_io[pin_num]),
.o(raw_input),
.ibar(),
.dynamicterminationcontrol(1'b0)
);
end
else
begin
cyclonev_io_ibuf data_in (
.i(read_data_in[pin_num]),
.o(raw_input),
.ibar(),
.dynamicterminationcontrol(1'b0)
);
end
end
if (PIN_TYPE == "output" || PIN_TYPE == "bidir")
begin
wire predelayed_data;
wire predelayed_oe;
if (USE_2X_FF == "true")
begin
reg dd_data;
reg dd_oe;
always @(posedge dq_dr_clock)
begin
dd_data <= aligned_data[pin_num];
dd_oe <= aligned_oe[pin_num];
end
assign predelayed_data = dd_data;
assign predelayed_oe = dd_oe;
end
else
begin
assign predelayed_data = aligned_data[pin_num];
assign predelayed_oe = aligned_oe[pin_num];
end
if (USE_DYNAMIC_CONFIG == "true")
begin
`ifndef FAMILY_HAS_NO_DYNCONF
wire delayed_data_1;
wire delayed_oe_1;
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
out_delay_1(
.datain (predelayed_data),
.delayctrlin (dq_outputdelaysetting_dlc),
.dataout (delayed_data_1)
);
assign delayed_data_out = delayed_data_1;
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
oe_delay_1(
.datain (predelayed_oe),
.delayctrlin (dq_outputenabledelaysetting_dlc),
.dataout (delayed_oe_1)
);
assign delayed_oe = delayed_oe_1;
`endif
end
else
begin
assign delayed_data_out = predelayed_data;
assign delayed_oe = predelayed_oe;
end
if (PIN_TYPE == "output")
begin
cyclonev_io_obuf data_out (
.i (delayed_data_out),
.o (write_data_out [pin_num]),
.oe (~delayed_oe),
.parallelterminationcontrol (parallelterminationcontrol_in),
.seriesterminationcontrol (seriesterminationcontrol_in),
.obar(),
.devoe(),
.dynamicterminationcontrol(1'b0)
);
end
else if (PIN_TYPE == "bidir")
begin
cyclonev_io_obuf
#(
.sim_dynamic_termination_control_is_connected("true")
) data_out (
.oe (~delayed_oe),
.i (delayed_data_out),
.o (read_write_data_io [pin_num]),
.parallelterminationcontrol (parallelterminationcontrol_in),
.dynamicterminationcontrol (delayed_oct),
.seriesterminationcontrol (seriesterminationcontrol_in),
.obar(),
.devoe()
);
/* synthesis translate_off */
assert property (@(posedge fr_clock_in or negedge fr_clock_in) (~delayed_oe === 1'b1) |-> delayed_oct === 1'b0)
else $display(1, "OE enabled but dynamic OCT ctrl is not in write mode");
`ifndef BOARD_DELAY_MODEL
assert property (@(posedge capture_strobe or negedge capture_strobe) (~delayed_oe === 1'b0 && read_write_data_io[pin_num] !== 1'bz) |-> delayed_oct === 1'b1)
else $display(1, "Read data comes back but dynamic OCT ctrl is not in read mode");
`endif
/* synthesis translate_on */
end
end
end
endgenerate
generate
genvar epin_num;
for (epin_num = 0; epin_num < EXTRA_OUTPUT_WIDTH; epin_num = epin_num + 1)
begin :extra_output_pad_gen
wire fr_data_hi;
wire fr_data_lo;
wire aligned_data;
wire extra_outputhalfratebypass;
if (USE_HALF_RATE_OUTPUT == "true")
begin
wire hr_data_t0;
wire hr_data_t1;
wire hr_data_t2;
wire hr_data_t3;
if (NATURAL_ALIGNMENT == "true")
begin
assign hr_data_t0 = extra_write_data_in [epin_num * rate_mult_out];
assign hr_data_t1 = extra_write_data_in [epin_num * rate_mult_out + 1];
assign hr_data_t2 = extra_write_data_in [epin_num * rate_mult_out + 2];
assign hr_data_t3 = extra_write_data_in [epin_num * rate_mult_out + 3];
end
else if (REGULAR_WRITE_BUS_ORDERING == "true")
begin
assign hr_data_t0 = extra_write_data_in [epin_num + 0*EXTRA_OUTPUT_WIDTH];
assign hr_data_t1 = extra_write_data_in [epin_num + 1*EXTRA_OUTPUT_WIDTH];
assign hr_data_t2 = extra_write_data_in [epin_num + 2*EXTRA_OUTPUT_WIDTH];
assign hr_data_t3 = extra_write_data_in [epin_num + 3*EXTRA_OUTPUT_WIDTH];
end
else
begin
assign hr_data_t0 = extra_write_data_in [epin_num + 2*EXTRA_OUTPUT_WIDTH];
assign hr_data_t1 = extra_write_data_in [epin_num + 0*EXTRA_OUTPUT_WIDTH];
assign hr_data_t2 = extra_write_data_in [epin_num + 3*EXTRA_OUTPUT_WIDTH];
assign hr_data_t3 = extra_write_data_in [epin_num + 1*EXTRA_OUTPUT_WIDTH];
end
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_hi (
.datainhi(hr_data_t0),
.datainlo(hr_data_t2),
.dataout(fr_data_hi),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(extra_outputhalfratebypass),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
cyclonev_ddio_out
#(
.half_rate_mode("true"),
.use_new_clocking_model("true"),
.async_mode("none")
) hr_to_fr_lo (
.datainhi(hr_data_t1),
.datainlo(hr_data_t3),
.dataout(fr_data_lo),
.clkhi (hr_seq_clock),
.clklo (hr_seq_clock),
.hrbypass(extra_outputhalfratebypass),
.muxsel (hr_seq_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn()
);
end
else
begin
if (NATURAL_ALIGNMENT == "true")
begin
assign fr_data_lo = extra_write_data_in [epin_num * rate_mult_out + 1];
assign fr_data_hi = extra_write_data_in [epin_num * rate_mult_out];
end
else
begin
assign fr_data_lo = extra_write_data_in [epin_num+EXTRA_OUTPUT_WIDTH];
assign fr_data_hi = extra_write_data_in [epin_num];
end
end
if (USE_OUTPUT_PHASE_ALIGNMENT == "true")
begin
end
else
begin
cyclonev_ddio_out
#(
.async_mode("none"),
.half_rate_mode("false"),
.sync_mode("none"),
.use_new_clocking_model("true")
) ddio_out (
.datainhi(fr_data_hi),
.datainlo(fr_data_lo),
.dataout(aligned_data),
.clkhi (dq_shifted_clock),
.clklo (dq_shifted_clock),
.muxsel (dq_shifted_clock),
.clk(),
.ena(1'b1),
.areset(),
.sreset(),
.dfflo(),
.dffhi(),
.devpor(),
.devclrn(),
.hrbypass()
);
end
wire delayed_data_out;
wire [4:0] dq_outputdelaysetting1;
wire [4:0] dq_inputdelaysetting;
wire [DELAY_CHAIN_WIDTH-1:0] dq_outputdelaysetting1_dlc;
wire [DELAY_CHAIN_WIDTH-1:0] dq_inputdelaysetting_dlc;
if (USE_DYNAMIC_CONFIG == "true")
begin
`ifndef FAMILY_HAS_NO_DYNCONF
cyclonev_io_config config_1 (
.datain(config_data_in),
.clk(config_clock_in),
.ena(config_extra_io_ena[epin_num]),
.update(config_update),
.outputregdelaysetting(dq_outputdelaysetting1),
.outputhalfratebypass(extra_outputhalfratebypass),
.padtoinputregisterdelaysetting(dq_inputdelaysetting),
.dataout(),
.readfiforeadclockselect(),
.readfifomode(),
.outputenabledelaysetting()
);
assign dq_outputdelaysetting1_dlc = dq_outputdelaysetting1;
assign dq_inputdelaysetting_dlc = dq_inputdelaysetting;
wire delayed_data_1;
cyclonev_delay_chain
#(.sim_intrinsic_rising_delay(0), .sim_intrinsic_falling_delay(0))
out_delay_1(
.datain (aligned_data),
.delayctrlin (dq_outputdelaysetting1_dlc),
.dataout (delayed_data_1)
);
assign delayed_data_out = delayed_data_1;
`endif
end
else
begin
assign delayed_data_out = aligned_data;
end
cyclonev_io_obuf obuf_1 (
.i (delayed_data_out),
.o (extra_write_data_out[epin_num]),
.parallelterminationcontrol(parallelterminationcontrol_in),
.dynamicterminationcontrol(1'b0),
.seriesterminationcontrol(seriesterminationcontrol_in),
.oe (1'b1),
.obar(),
.devoe()
);
end
endgenerate
endmodule