idt7202.vhd

VHDL的ram和fifo model code 包含众多的厂家

            VARIABLE Pviol_RNeg            :  X01 := '0';
            VARIABLE TD_RNeg      : VitalPeriodDataType := VitalPeriodDataInit;

            VARIABLE Pviol_WNeg            :  X01 := '0';
            VARIABLE TD_WNeg      : VitalPeriodDataType := VitalPeriodDataInit;

            VARIABLE Pviol_RSNeg           :  X01 := '0';
            VARIABLE TD_RSNeg     : VitalPeriodDataType := VitalPeriodDataInit;

            VARIABLE Pviol_FLNeg           :  X01 := '0';
            VARIABLE TD_FLNeg     : VitalPeriodDataType := VitalPeriodDataInit;

            VARIABLE Pviol_XINeg           :  X01 := '0';
            VARIABLE TD_XINeg     : VitalPeriodDataType := VitalPeriodDataInit;

            -- Memory array declaration
            TYPE MemStore IS ARRAY (0 to TotalLOC) OF INTEGER
                             RANGE  -2 TO MaxData;

            -- Functionality Results Variables
            VARIABLE Violation  : X01 := '0';

            TYPE mode_type IS (unk, single, first_exp, other_exp);
            TYPE stat_type IS (inact, act);
            VARIABLE mode       : mode_type;
            VARIABLE rd_stat    : stat_type;
            VARIABLE wr_stat    : stat_type;
            VARIABLE EFNeg_zd   : std_ulogic;
            VARIABLE FFNeg_zd   : std_ulogic;
            VARIABLE XONeg_zd   : std_ulogic;
            VARIABLE EF_pzd     : std_ulogic;
            VARIABLE FF_pzd     : std_ulogic;

            VARIABLE RDPoint    : INTEGER RANGE 0 TO TotalLoc := 0;
            VARIABLE WRPoint    : INTEGER RANGE 0 TO TotalLoc := 0;
            VARIABLE Count      : INTEGER RANGE 0 TO TotalLoc := 0;
            VARIABLE MemData    : MemStore;

            VARIABLE DataDrive : std_logic_vector(HiDbit DOWNTO 0)
                                   := (OTHERS => 'Z');

            -- Output Glitch Detection Variables
            VARIABLE FFNeg_GlitchData : VitalGlitchDataType;
            VARIABLE EFNeg_GlitchData : VitalGlitchDataType;
            VARIABLE XONeg_GlitchData : VitalGlitchDataType;
            VARIABLE EFp_GlitchData   : VitalGlitchDataType;
            VARIABLE FFp_GlitchData   : VitalGlitchDataType;

            -- No Weak Values Variables
            VARIABLE FLNeg_nwv       : UX01 := 'U';
            VARIABLE WNeg_nwv        : UX01 := 'U';
            VARIABLE RNeg_nwv        : UX01 := 'U';
            VARIABLE RSNeg_nwv       : UX01 := 'U';
            VARIABLE XINeg_nwv       : UX01 := 'U';

        BEGIN
            FLNeg_nwv    := To_UX01 (s => FLNegIn);
            WNeg_nwv     := To_UX01 (s => WNegIn);
            RNeg_nwv     := To_UX01 (s => RNegIn);
            RSNeg_nwv    := To_UX01 (s => RSNegIn);
            XINeg_nwv    := To_UX01 (s => XINegIn);

            --------------------------------------------------------------------
            -- Timing Check Section
            --------------------------------------------------------------------
            IF (TimingChecksOn) THEN

                VitalSetupHoldCheck (
                    TestSignal      => DIn,
                    TestSignalName  => "D",
                    RefSignal       => WNegIn,
                    RefSignalName   => "WNeg",
                    SetupHigh       => tsetup_D0_WNeg,
                    SetupLow        => tsetup_D0_WNeg,
                    HoldHigh        => thold_D0_WNeg,
                    HoldLow         => thold_D0_WNeg,
                    CheckEnabled    => (WNeg_nwv ='0'),
                    RefTransition   => '/',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_D0_WNeg,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_D0_WNeg );

                VitalSetupHoldCheck (
                    TestSignal      => RNegIn,
                    TestSignalName  => "RNeg",
                    RefSignal       => RSNegIn,
                    RefSignalName   => "RSNeg",
                    SetupHigh       => tsetup_RNeg_RSNeg,
                    SetupLow        => tsetup_RNeg_RSNeg,
                    HoldHigh        => thold_RNeg_RSNeg,
                    HoldLow         => thold_RNeg_RSNeg,
                    CheckEnabled    => (RSNeg_nwv ='0'),
                    RefTransition   => '/',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_RNeg_RSNeg,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_RNeg_RSNeg );

                VitalSetupHoldCheck (
                    TestSignal      => RNegIn,
                    TestSignalName  => "RNeg",
                    RefSignal       => FLNegIn,
                    RefSignalName   => "FLNeg",
                    SetupHigh       => tsetup_RNeg_FLNeg,
                    SetupLow        => tsetup_RNeg_FLNeg,
                    HoldHigh        => thold_RNeg_FLNeg,
                    HoldLow         => thold_RNeg_FLNeg,
                    CheckEnabled    => (FLNeg_nwv ='0'),
                    RefTransition   => '/',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_RNeg_FLNeg,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_RNeg_FLNeg );

                VitalSetupHoldCheck (
                    TestSignal      => XINegIn,
                    TestSignalName  => "XINeg",
                    RefSignal       => RNegIn,
                    RefSignalName   => "RNeg",
                    SetupHigh       => tsetup_XINeg_RNeg,
                    SetupLow        => tsetup_XINeg_RNeg,
                    CheckEnabled    => true,
                    RefTransition   => '/',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_XINeg_RNeg,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_XINeg_RNeg );

                VitalSetupHoldCheck (
                    TestSignal      => XINegIn,
                    TestSignalName  => "XINeg",
                    RefSignal       => WNegIn,
                    RefSignalName   => "WNeg",
                    SetupHigh       => tsetup_XINeg_RNeg,
                    SetupLow        => tsetup_XINeg_RNeg,
                    CheckEnabled    => true,
                    RefTransition   => '/',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_XINeg_WNeg,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_XINeg_WNeg );

                VitalPeriodPulseCheck (
                    TestSignal      =>  RNegIn,
                    TestSignalName  =>  "RNeg",
                    Period          =>  tperiod_RNeg,
                    PulseWidthLow   =>  tpw_RNeg_negedge,
                    PulseWidthHigh  =>  tpw_RNeg_posedge,
                    PeriodData      =>  TD_RNeg,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE,
                    Violation       =>  Pviol_RNeg );

                VitalPeriodPulseCheck (
                    TestSignal      =>  WNegIn,
                    TestSignalName  =>  "WNeg",
                    Period          =>  tperiod_WNeg,
                    PulseWidthLow   =>  tpw_WNeg_negedge,
                    PulseWidthHigh  =>  tpw_WNeg_posedge,
                    PeriodData      =>  TD_WNeg,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE,
                    Violation       =>  Pviol_WNeg );

                VitalPeriodPulseCheck (
                    TestSignal      =>  XINegIn,
                    TestSignalName  =>  "XINeg",
                    PulseWidthLow   =>  tpw_XINeg_negedge,
                    PeriodData      =>  TD_XINeg,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE,
                    Violation       =>  Pviol_XINeg );

                VitalPeriodPulseCheck (
                    TestSignal      =>  FLNegIn,
                    TestSignalName  =>  "FLNeg",
                    PulseWidthLow   =>  tpw_FLNeg_negedge,
                    PulseWidthHigh  =>  tpw_FLNeg_posedge,
                    PeriodData      =>  TD_FLNeg,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE,
                    Violation       =>  Pviol_FLNeg );

            END IF; -- Timing Check Section

        --------------------------------------------------------------------
        -- Functional Section
        --------------------------------------------------------------------
        Violation := Tviol_D0_WNeg OR Tviol_RNeg_RSNeg OR Tviol_RNeg_FLNeg
                     OR Tviol_XINeg_RNeg OR Tviol_XINeg_WNeg OR Pviol_RNeg
                     OR Pviol_WNeg OR Pviol_RSNeg OR Pviol_FLNeg OR
                     Pviol_XINeg;

        IF (Violation = 'X')  THEN
            DataDrive := (OTHERS => 'X');
            FFNeg_zd := 'X';
            EFNeg_zd := 'X';
            XONeg_zd := 'X';
        ELSIF falling_edge(RSNegIn) THEN
            RDPoint := 0;
            WRPoint := 0;
            Count   := 0;
        ELSIF rising_edge(RSNegIn) THEN
            FFNeg_zd := '1';
            XONeg_zd := '1';
            EFNeg_zd := '0';
            IF XINeg_nwv = '0' THEN
                mode := single;
                rd_stat := act;
                wr_stat := act;
            ELSIF FLNeg_nwv = '0' THEN
                mode := first_exp;
                rd_stat := act;
                wr_stat := act;
            ELSE
                mode := other_exp;
                rd_stat := inact;
                wr_stat := inact;
            END IF;
        END IF;

        IF rising_edge(WNegIn) THEN
            IF wr_stat = act AND FFNeg_zd = '1' THEN
                IF Violation = '0' THEN
                    MemData(WRPoint) := To_Nat(DIn);
                ELSE
                    MemData(WRPoint) := -1;
                END IF;
                Count := Count + 1;
                IF WRPoint = TotalLoc THEN
                    WRPoint := 0;
                ELSE
                    WRPoint := WRPoint + 1;
                END IF;
                IF Count > Half AND mode = single THEN
                    XONeg_zd := '0';
                ELSE