cy7c1361.vhd

vhdl cod for ram.For sp3e

            AND R = '0') THEN
            IF ADVNIn = '0' THEN
                command := SPwr_burst;
            ELSE
                command := SPwr_susp;
            END IF;
        ELSIF (CE2NegIn = '0' AND CE2In = '1' AND CENegIn = '0' AND
            ADSPNIn = '1' AND ADSCNIn = '0' AND R = '0') THEN
            command := SCwr;
        ELSE
            ASSERT false
                REPORT InstancePath & partID & ": Could not decode "
                       & "command."
                SEVERITY SeverityMode;
        END IF;

        -- The State Machine
        CASE state IS
            WHEN desel =>
                CASE command IS
                    WHEN begin_rw =>
                        state <= begin_rdwr;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        ReadMem(MemAddr);

                    WHEN SCwr =>
                        state <= SCwrite;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        OBuf1 := (others => 'Z');
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN others =>
                        null;

                END CASE;

            WHEN begin_rdwr =>
                Burst_Cnt := 0;
                CASE command IS
                    WHEN ds =>
                        state <= desel;
                        OBuf1 := (others => 'Z');

                    WHEN begin_rw =>
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        ReadMem(MemAddr);

                    WHEN SCwr =>
                        state <= SCwrite;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        OBuf1 := (others => 'Z');
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN SPwr_burst =>
                        OBuf1 := (others => 'Z');

                    WHEN SPwr_susp =>
                        state <= SPwrite;
                        OBuf1 := (others => 'Z');
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN read_burst =>
                        state <= read;
                        Burst_Cnt := Burst_Cnt + 1;
                        offset := Burst_Seq(memstart)(Burst_Cnt);
                        MemAddr := startaddr + offset;
                        ReadMem(MemAddr);

                    WHEN read_susp =>
                        null;
                END CASE;

            WHEN SPwrite =>
                CASE command IS
                    WHEN ds =>
                        state <= desel;
                        OBuf1 := (others => 'Z');

                    WHEN begin_rw =>
                        state <= begin_rdwr;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        ReadMem(MemAddr);

                    WHEN SCwr =>
                        state <= SCwrite;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN SPwr_burst =>
                        Burst_Cnt := Burst_Cnt + 1;
                        IF (Burst_Cnt = 4) THEN
                            Burst_Cnt := 0;
                        END IF;
                        offset := Burst_Seq(memstart)(Burst_Cnt);
                        MemAddr := startaddr + offset;
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN SPwr_susp =>
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN others =>
                        null;

                END CASE;

            WHEN SCwrite =>
                Burst_Cnt := 0;
                CASE command IS
                    WHEN ds =>
                        state <= desel;

                    WHEN begin_rw =>
                        state <= begin_rdwr;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        ReadMem(MemAddr);

                    WHEN SCwr =>
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN SPwr_burst =>
                        state <= SPwrite;
                        Burst_Cnt := Burst_Cnt + 1;
                        offset := Burst_Seq(memstart)(Burst_Cnt);
                        MemAddr := startaddr + offset;
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN others =>
                        null;

                END CASE;

            WHEN read =>
                CASE command IS
                    WHEN ds =>
                        state <= desel;
                        OBuf1 := (others => 'Z');

                    WHEN begin_rw =>
                        state <= begin_rdwr;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        ReadMem(MemAddr);

                    WHEN SCwr =>
                        state <= SCwrite;
                        MemAddr := to_nat(AddressIn);
                        startaddr := MemAddr;
                        memstart := to_nat(AddressIn(1 downto 0));
                        OBuf1 := (others => 'Z');
                        WriteMem(
                            WAddr  => MemAddr,
                            WDatA  => DatAIn,
                            WDatB  => DatBIn,
                            WDatC  => DatCIn,
                            WDatD  => DatDIn,
                            WGWN   => GWNIn,
                            WBWA   => BWANIn,
                            WBWB   => BWBNIn,
                            WBWC   => BWCNIn,
                            WBWD   => BWDNIn);

                    WHEN SPwr_burst =>
                        OBuf1 := (others => 'Z');

                    WHEN SPwr_susp =>
                        OBuf1 := (others => 'Z');

                    WHEN read_burst =>
                        state <= read;
                        Burst_Cnt := Burst_Cnt + 1;
                        IF (Burst_Cnt = 4) THEN
                            Burst_Cnt := 0;
                        END IF;
                        offset := Burst_Seq(memstart)(Burst_Cnt);
                        MemAddr := startaddr + offset;
                        ReadMem(MemAddr);

                    WHEN read_susp =>
                        state <= read;
                END CASE;
        END CASE;

        IF (OENegIn = '0') THEN
            IF OBuf1(0) /= 'Z' AND command /= read_susp THEN
                D_zd <= (others => 'X'), OBuf1 AFTER 1 ns;
            ELSE
                D_zd <= OBuf1;
            END IF;