Subversion Repositories spacewiresystemc

// (C) 2001-2017 Intel Corporation. All rights reserved.
// Your use of Intel 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 Intel Program License Subscription 
// Agreement, Intel 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 Intel and sold by 
// Intel 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