idt72264.vhd

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

                        to_slv(Threshold, OffsLen/2);  -- def PAE offs

                  RdOffsRegPtrint <= 0;
                  WrOffsRegPtrint <= 0;

               END IF;

            ELSIF InputLoadedint'event AND InputLoadedint = '1' THEN

                    -- Storing Input Register into FIFO

                    IF OpModeint = '0' THEN    -- Standard Operation Mode

                       FIFOMemory(WRITEPtrint)(FIFOWordLength-1 DOWNTO 0) :=
                                   InputRegint(FIFOWordLength-1 DOWNTO 0);

                        -- modification of the WRITE pointer

                        IF WRITEPtrint = FIFOSize - 1 THEN
                            WRITEPtrint <= 0;
                        ELSE WRITEPtrint <= WRITEPtrint + 1;
                        END IF;

                    ELSIF OpModeint = '1' THEN  -- FWFT Operation Mode

                          IF (WordCountInt = 0) AND          -- first word
                             (FWPassedint  = '0')            -- written to
                          THEN                               -- an empty FIFO
                                                             -- goes directly
                             OutputRegint    <= InputRegint; -- to Output Reg
                             FWPassedint     <= '1';
                             OutputLoadedint <= '1';

                          ELSE

                       FIFOMemory(WRITEPtrint)(FIFOWordLength-1 DOWNTO 0):=
                                   InputRegint(FIFOWordLength-1 DOWNTO 0);

                             -- modification of the WRITE pointer

                             IF WRITEPtrint = FIFOSize - 1 THEN
                                 WRITEPtrint <= 0;
                             ELSE WRITEPtrint <= WRITEPtrint + 1;
                             END IF;

                             FWPassedint     <= '0';
                             OutputLoadedint <= '0';

                          END IF;

                    END IF;

                    InputLoadedint <= '0';

            ELSIF FIFOOperableint THEN              -- I/O logic

               IF (WCLK'event AND WCLK = '1') THEN  -- synch by WCLK

                  IF WRITEint = '1' AND WRITEPossibleint = '1' THEN    -- WRITE

                     InputRegint    <= D;        -- load data in input Reg
                     InputLoadedint <= '1';

                  ELSIF PLOADint = '1' AND PLOADPossibleint = '1' THEN -- PLOAD

                        IF WrOffsRegPtrint = 0 THEN

                           OffsetRegint(OffsLen/2-1 DOWNTO 0) <=
                           D(OffsLen/2-1 DOWNTO 0);

                           WrOffsRegPtrint <= 1;  -- Empty offs loaded

                        ELSIF WrOffsRegPtrint = 1 THEN

                           OffsetRegint(OffsLen-1 DOWNTO OffsLen/2) <=
                           D(OffsLen/2-1 DOWNTO 0);

                           WrOffsRegPtrint <= 0;  -- Full offset loaded

                        END IF;

                  ELSIF SLOADint = '1' AND SLOADPossibleint = '1' THEN -- SLOAD

                        OffsetRegint(WrOffsRegPtrint) <= FWFTSI; -- load a bit

                        IF WrOffsRegPtrint = OffsLen-1 THEN -- MSB is reached
                           WrOffsRegPtrint <= 0;            -- reset to LSB
                        ELSE
                           WrOffsRegPtrint <= WrOffsRegPtrint + 1;-- advance ptr
                        END IF;

                  ELSE
                        NULL;
                  END IF;

               END IF;

               IF (RCLK'event AND RCLK = '1') THEN     -- synch by RCLK

                  IF RETRint = '1' AND RETRPossibleint = '1' THEN    -- RETARNS

                     -- retransmit setup

                     RTSCompletedint <= '0';

                     IF Frequencyint = '0' THEN        -- RCLK is faster or =
                        Tf := tperiod_RCLK_posedge;    -- WCLK
                     ELSIF Frequencyint = '1' THEN     -- WCLK is faster
                        Tf := tperiod_WCLK_posedge;
                     END IF;

                     IF OpModeint = '0' THEN           -- Standard Mode

                        READPtrint      <= 0;          -- initialize read ptr
                        RTSCompletedint <= '1'
                                           AFTER 14*Tf+3*tperiod_RCLK_posedge;

                     ELSIF OpModeint = '1' THEN        -- FWFT mode

                        READPtrint      <= 0,          -- initialize read ptr
                                           1 AFTER 14*Tf+4*tperiod_RCLK_posedge;
                        RTSCompletedint <= '1'
                                           AFTER 14*Tf+4*tperiod_RCLK_posedge;
                        OutputRegint(FIFOWordLength-1 DOWNTO 0) <=
                         FIFOMemory(0)(FIFOWordLength-1 DOWNTO 0);

                     END IF;

                  ELSIF READint = '1' AND READPossibleint = '1' THEN -- READ

                        -- reading memory to output register

                  OutputRegint (FIFOWordLength-1 DOWNTO 0)<=
                           FIFOMemory(READPtrint)(FIFOWordLength-1 DOWNTO 0);
                        OutputLoadedint <= '1';
                        StillNoReadint  <= '0'; -- reset still no read flag

                        -- modification of the READ pointer

                        IF READPtrint = FIFOSize - 1 THEN
                           READPtrint <= 0;
                        ELSE READPtrint <= READPtrint + 1;
                        END IF;

                  ELSIF PREADint = '1' AND PREADPossibleint = '1' THEN -- PREAD

                        -- parallel read from PAF/PAE offsets register

                        IF RdOffsRegPtrint = 0 THEN
                          IF MAC = '1' THEN
                           OutputRegint(FIFOSHORTWordLength-1 DOWNTO 0) <=
                                                           -- load PAE offs
                           to_slv(to_nat(OffsetRegint(OffsLen/2-1 DOWNTO 0)),
                                  FIFOSHORTWordLength);
                          ELSE
                           OutputRegint(FIFOLONGWordLength-1 DOWNTO 0) <=
                                                           -- load PAE offs
                           to_slv(to_nat(OffsetRegint(OffsLen/2-1 DOWNTO 0)),
                                  FIFOLONGWordLength);
                          END IF;

                           OutputLoadedint <= '1';
                           RdOffsRegPtrint <= 1;      -- jump to full offs part

                        ELSIF RdOffsRegPtrint = 1 THEN
                          IF MAC = '1' THEN
                           OutputRegint(FIFOSHORTWordLength-1 DOWNTO 0) <=
                                                             -- load PAF offs
                        to_slv(to_nat(OffsetRegint(OffsLen-1 DOWNTO OffsLen/2)),
                                                     FIFOSHORTWordLength);
                          ELSE
                           OutputRegint(FIFOLONGWordLength-1 DOWNTO 0) <=
                                                              -- load PAE offs
                        to_slv(to_nat(OffsetRegint(OffsLen-1 DOWNTO OffsLen/2)),
                                                          FIFOLONGWordLength);
                          END IF;

                           OutputLoadedint <= '1';
                           RdOffsRegPtrint <= 0;  -- jump to empty offset part

                        END IF;
                  ELSE
                        OutputLoadedint <= '0';
                  END IF;

               ELSE OutputLoadedint <= '0';

               END IF;

            END IF;

      EmptyOffsetint  <= to_nat(OffsetRegint(OffsLen/2-1 DOWNTO 0));
      FullOffsetint   <= to_nat(OffsetRegint(OffsLen-1 DOWNTO OffsLen/2));

        END PROCESS FIFOArrayIO;

        ------------------------------------------------------------------------
        -- Counting number of words in FIFO                                   --
        ------------------------------------------------------------------------

        WordCounter: PROCESS (WRITEPtrint, MAC, READPtrint)

            VARIABLE FIFOSize         : positive;
            VARIABLE FIFOWordLength   : positive;
            VARIABLE OffsLen          : positive;

        BEGIN
            IF MAC = '0' THEN--

               FIFOSize := FIFOShortSize;
               FIFOWordLength := FIFOLONGWordLength;
               OffsLen  := OffsSHORTLen;

            ELSIF MAC = '1' THEN ------

               FIFOSize := FIFOLONGSize;
               FIFOWordLength := FIFOSHORTWordLength;
               OffsLen  := OffsLongLen;
            END IF;

            IF    WRITEPtrint > READPtrint            -- no overrun
            THEN  WordCountint <= WRITEPtrint - READPtrint;
                  FWPassed2int <= '1';

            ELSIF WRITEPtrint < READPtrint            -- overrun
            THEN  WordCountint <= ((FIFOSize-1) - READPtrint + 1) +
                                  (WRITEPtrint);    -- - FIFOArray'low);
                  FWPassed2int <= '1';

            ELSIF (WRITEPtrint = READPtrint)  AND
                  WordCountint = FIFOSize - 1         -- WRptr've caught RDptr
            THEN  WordCountint <= FIFOSize;
                  FWPassed2int <= '1';

            ELSIF (WRITEPtrint = READPtrint)  AND
                  WordCountint = 1                    -- RDptr've caught WRptr
            THEN  WordCountint <= 0;
                  FWPassed2int <= '0';

            END IF;

        END PROCESS WordCounter;

        ------------------------------------------------------------------------
        -- Actual skew detection                                              --
        ------------------------------------------------------------------------

        SkewDetector: PROCESS(RCLK, WCLK)

            VARIABLE tRCLKposedge : Time := 0 ns;
            VARIABLE tWCLKposedge : Time := 0 ns;

        BEGIN

            IF RCLK'event AND RCLK = '1'
            THEN tRCLKposedge := Now;
                 tSKEW_WCLK_RCLK <= Now - tWCLKposedge;
            END IF;

            IF WCLK'event AND WCLK = '1'
            THEN tWCLKposedge := Now;
                 tSKEW_RCLK_WCLK <= Now - tRCLKposedge;
            END IF;

        END PROCESS SkewDetector;

        ------------------------------------------------------------------------
        -- Flag Logic                                                         --
        ------------------------------------------------------------------------
        -- EFOR & PAE flags update                                            --
        ------------------------------------------------------------------------

        EFORUpdate : PROCESS (MRSNeg, PRSNEg, RCLK, RTSCompletedint)

            VARIABLE FIFOSize         : positive;     ---------
            VARIABLE FIFOWordLength   : positive;
            VARIABLE OffsLen          : positive;

            VARIABLE Tf    : Time;
            VARIABLE Ahead : Natural RANGE 0 TO 1;

        BEGIN

            IF MAC = '0' THEN --!!!!!!!!!!!!!!!!!!!!!!

               FIFOSize := FIFOShortSize;
               FIFOWordLength := FIFOLONGWordLength;
               OffsLen  := OffsSHORTLen;

            ELSIF MAC = '1' THEN ------!!!!!!!!!!!!!!!!!!!!

               FIFOSize := FIFOLONGSize;
               FIFOWordLength := FIFOSHORTWordLength;
               OffsLen  := OffsLongLen;
            END IF;

           IF MRSNeg = '0' THEN    -- master reset

              PAENeg_zd  <= '0';
              EFORNeg_zd <= FWFTSI;

           ELSIF PRSNeg = '0' THEN -- partial reset

              PAENeg_zd  <= '0';
              EFORNeg_zd <= OpMOdeint;

           ELSIF RTSCompletedint'e