k4f641612d.vhd

vhdl cod for ram.For sp3e

                    Violation       => Tviol_DQ0_UCASNegIn );


                VitalSetupHoldCheck (
                    TestSignal      => DataIn,
                    TestSignalName  => "DQ",
                    RefSignal       => LCASNegIn,
                    RefSignalName   => "LCAS#",
                    SetupHigh       => tsetup_DQ0_UCASNeg,
                    SetupLow        => tsetup_DQ0_UCASNeg,
                    HoldHigh        => thold_DQ0_UCASNeg,
                    HoldLow         => thold_DQ0_UCASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_DQ0_UCASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_DQ0_UCASNegIn );


                VitalSetupHoldCheck (
                    TestSignal      => WNegIn,
                    TestSignalName  => "W#",
                    RefSignal       => UCASNegIn,
                    RefSignalName   => "UCAS#",
                    SetupLow        => tsetup_WNeg_UCASNeg,
                    HoldLow         => thold_WNeg_UCASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_WNegIn_UCASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_WNegIn_UCASNegIn );


                VitalSetupHoldCheck (
                    TestSignal      => WNegIn,
                    TestSignalName  => "W#",
                    RefSignal       => LCASNegIn,
                    RefSignalName   => "LCAS#",
                    SetupHigh       => tsetup_WNeg_UCASNeg,
                    SetupLow        => tsetup_WNeg_UCASNeg,
                    HoldHigh        => thold_WNeg_UCASNeg,
                    HoldLow         => thold_WNeg_UCASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_WNegIn_UCASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_WNegIn_UCASNegIn );


                VitalSetupHoldCheck (
                    TestSignal      => OENegIn,
                    TestSignalName  => "OE#",
                    RefSignal       => WNegIn,
                    RefSignalName   => "W#",
                    HoldLow         => thold_OENeg_WNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_OENegIn_WNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_OENegIn_WNegIn );


                VitalSetupHoldCheck (
                    TestSignal      => RASNegIn,
                    TestSignalName  => "RAS#",
                    RefSignal       => UCASNegIn,
                    RefSignalName   => "UCAS#",
                    HoldLow         => thold_RASNeg_UCASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_RASNegIn_UCASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_RASNegIn_UCASNegIn );

                VitalSetupHoldCheck (
                    TestSignal      => RASNegIn,
                    TestSignalName  => "RAS#",
                    RefSignal       => LCASNegIn,
                    RefSignalName   => "LCAS#",
                    HoldLow         => thold_RASNeg_UCASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_RASNegIn_UCASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_RASNegIn_UCASNegIn );

                VitalSetupHoldCheck (
                    TestSignal      => UCASNegIn,
                    TestSignalName  => "UCAS#",
                    RefSignal       => RASNegIn,
                    RefSignalName   => "RAS#",
                    HoldLow         => thold_UCASNeg_RASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_UCASNegIn_RASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_UCASNegIn_RASNegIn );

                VitalSetupHoldCheck (
                    TestSignal      => LCASNegIn,
                    TestSignalName  => "LCAS#",
                    RefSignal       => RASNegIn,
                    RefSignalName   => "RAS#",
                    HoldLow         => thold_UCASNeg_RASNeg,
                    CheckEnabled    => chip_en,
                    RefTransition   => '\',
                    HeaderMsg       => InstancePath & PartID,
                    TimingData      => TD_UCASNegIn_RASNegIn,
                    XOn             => XOn,
                    MsgOn           => MsgOn,
                    Violation       => Tviol_UCASNegIn_RASNegIn );


                VitalPeriodPulseCheck (
                    TestSignal      =>  WNegIn,
                    TestSignalName  =>  "W#",
                    PulseWidthLow   =>  tpw_WNeg_negedge,
                    PeriodData      =>  PD_WNegIn,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    Violation       =>  Pviol_WNegIn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE );

                VitalPeriodPulseCheck (
                    TestSignal      =>  UCASNegIn,
                    TestSignalName  =>  "UCAS#",
                    PulseWidthHigh   =>  tpw_UCASNeg_posedge,
                    PeriodData      =>  PD_UCASNegIn,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    Violation       =>  Pviol_UCASNegIn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE );

                VitalPeriodPulseCheck (
                    TestSignal      =>  LCASNegIn,
                    TestSignalName  =>  "LCAS#",
                    PulseWidthHigh  =>  tpw_UCASNeg_posedge,
                    PeriodData      =>  PD_UCASNegIn,
                    XOn             =>  XOn,
                    MsgOn           =>  MsgOn,
                    Violation       =>  Pviol_UCASNegIn,
                    HeaderMsg       =>  InstancePath & PartID,
                    CheckEnabled    =>  TRUE );

            END IF; -- Timing Check Section

            Violation := Tviol_A0_RASNegIn        OR
                         Tviol_A0_UCASNegIn       OR
                         Tviol_DQ0_UCASNegIn      OR
                         Tviol_WNegIn_UCASNegIn   OR
                         Tviol_RASNegIn_UCASNegIn OR
                         Tviol_UCASNegIn_RASNegIn OR
                         Tviol_OENegIn_WNegIn     OR
                         Pviol_WNegIn             OR
                         Pviol_UCASNegIn ;

            ASSERT Violation = '0'
                REPORT InstancePath & partID & ": simulation may be" &
                       " inaccurate due to timing violations"
                SEVERITY SeverityMode;

    --------------------------------------------------------------------
    -- Functional Section
    --------------------------------------------------------------------
        IF (refreshed_out='0' AND PoweredUp AND Ref_Cnt > 0 ) THEN
            Ref_Cnt := Ref_Cnt - 1;
            refreshed_in <= '1','0' AFTER 1 ns;
        END IF;

        IF NOW > 0 ns THEN
	        ASSERT (not(Is_X(OENegIn)))
	            REPORT InstancePath & partID & ": Unusable value for OENeg"
	            SEVERITY SeverityMode;
	        ASSERT (not(Is_X(WNegIn)))
	            REPORT InstancePath & partID & ": Unusable value for WNeg"
	            SEVERITY SeverityMode;
	        ASSERT (not(Is_X(RASNegIn)))
	            REPORT InstancePath & partID & ": Unusable value for RASNeg"
	            SEVERITY SeverityMode;
	        ASSERT (not(Is_X(UCASNegIn)))
	            REPORT InstancePath & partID & ": Unusable value for UCASNeg"
	            SEVERITY SeverityMode;
	        ASSERT (not(Is_X(LCASNegIn)))
	            REPORT InstancePath & partID & ": Unusable value for LCASNeg"
	            SEVERITY SeverityMode;
        END IF;


        -- Command Decode
        IF ((RASNegIn = '1') AND ((LCASNegIn = '1') AND (UCASNegIn = '1'))
                AND (WNegIn = '1')) THEN
            command := nop;
        ELSIF ((RASNegIn = '0') AND (LCASNegIn = '1') AND (UCASNegIn = '1'))
                THEN
            command := act;
        ELSIF ((RASNegIn = '0') AND ((LCASNegIn = '0') OR (UCASNegIn = '0'))
                AND (WNegIn = '1') AND (OENegIn = '1')) THEN
            command := pre;
        ELSIF ((RASNegIn = '0') AND ((LCASNegIn = '0') OR (UCASNegIn = '0'))
                AND (WNegIn = '1') AND (OENegIn = '0')) THEN
            command := read;
        ELSIF ((RASNegIn = '0') AND ((LCASNegIn = '0') OR (UCASNegIn = '0'))
                AND (WNegIn = '0')) THEN
            command := writ;
        ELSIF ((RASNegIn = '1') AND (LCASNegIn = '0') AND (UCASNegIn = '0')
                AND (WNegIn = '1')) THEN
            command := ref;
        ELSIF ((RASNegIn = '1') AND (LCASNegIn = '0') AND (UCASNegIn = '0')
                AND (WNegIn = '0')) THEN
            command := test;
        END IF;

        -- PowerUp Check
        IF NOT(PoweredUp)  THEN
            ASSERT command = nop
                REPORT InstancePath & partID & ": Incorrect power up. Command"
                      & " issued before power up complete."
                SEVERITY SeverityMode;
        END IF;

        CASE state IS
            WHEN pwron =>
                IF (PoweredUp = false) THEN
                    ASSERT (command = nop)
                        REPORT InstancePath & partID
                               &": Only NOPs allowed"
                               & " during power up."
                        SEVERITY SeverityMode;
                    DataDrive(0) := "ZZZZZZZZ";
                    DataDrive(1) := "ZZZZZZZZ";
                ELSIF (command = nop)  THEN
                    state <= precharge, idle AFTER tdevice_TRP;
                END IF;

            WHEN precharge =>
                    ASSERT (command = nop OR command = act OR
                            command = ref OR command = test)
                        REPORT InstancePath & partID
                               &": Illegal command received"
                               & " during precharge."
                        SEVERITY SeverityMode;

            WHEN idle =>
                IF (command = nop) THEN
                    null;
                ELSIF (command = test) THEN
                    state <= test_in;

                ELSIF (command = ref) THEN
                    state <= refresh_rec ;
                    chr_in <= '1', '0' AFTER 1 ns;
                    rass_in <= '1';
                    ras_in  <= '1', '0' AFTER 100 us;

                ELSIF (command = act) THEN
                    state <= bank_act;
                    ras_in  <= '1', '0' AFTER 100 us;

                    rct_in  <= '1', '0' AFTER 1 ns;
                    rcdt_in <= '1', '0' AFTER 1 ns;
                    MemAddr(21 downto 10) := AddressIn;  -- latch row addr
                ELSE
                    ASSERT false
                        REPORT InstancePath & partID & ": Illegal command"
                               & " received in idle state."
                        SEVERITY SeverityMode;
                END IF;

            WHEN test_in =>
                DataDrive(1) := (OTHERS => 'Z');
                DataDrive(0) := (OTHERS => 'Z');
                IF command = test THEN
                    null;
                ELSIF command = nop THEN
                    state <= precharge, idle AFTER tdevice_TRP;
                END IF;

            WHEN refresh_rec =>
                IF command = pre THEN
                    state <= auto_refresh, self_refresh AFTER tdevice_TRASS;
                ELSE
  	                ASSERT command = nop OR command = ref
                        REPORT InstancePath & partID &