FT2232H und riesen Slack

[Marcel D. (diablokiller999)]

Hi Leutz!
Ich versuche momentan ein Interface für den FTDI 2232H auf meinem FPGA 
zu implementieren. Jedoch funktioniert die Verbindung je nach Kompilat 
nur manchmal, häufig nicht und auch die Verbindung bricht immer wieder 
ab. Wie sich zeigt, habe ich wohl ordentliche Laufzeitprobleme, als 
Neuling aber nicht viel Ahnung davon, wie ich diese beseitigen kann. Ich 
weiß, dass ich gewisse Pfade im SDC-File per Constraints anpassen kann, 
jedoch finde ich kaum Literatur dafür.

Laut Simulation sollte meine Implementierung funktionieren(?), ich habe 
den Read und Write Fall in zwei Prozesse unterteilt, wobei der Read die 
Priorität genießt und sich beide gegenseitig von der Verwendung des 
Datenbusses ausschließen. Wie man in Signaltap sieht, wird mein A4 einen 
Takt zu spät auf den Datenbus gelegt (der Preload sollte es, wie in der 
Simulation, einen Takt vor dem LOW der oWR-Leitung anlegen) und das 
letzte Datenwort kommt erst nach dem HIGH auf oWR auf der Datenleitung 
an. Beim Lesen habe ich ein ähnliches Problem.

Write_USB:  process(iUSB_clk)
    begin
        if(falling_edge(iUSB_clk)) then
            if(ireset_n = '0') then
                oWR         <= '1';
                oTXRead     <= '0';
                nTXRun      <= '0';
                Datainout   <= (others => 'Z');
                stateTX     <= idle; 
                nTXE_Int    <=  '0';
            else
                case stateTX is
                    when idle =>
                        Datainout   <= (others => 'Z');
                        nTXRun      <= '0'; --  Release interface for RX
                        oWR         <= '1'; --  Set Write enable to high
                        oTXRead     <= '0'; --  Stop reading from FIFO
                        if(iTXEmpty = '0' AND iTXE = '0' AND iRXF = '1' AND nRXRun = '0') then  --  If TX Data available, TX to USB possible,no Read data available and RX not running
                            Datainout   <= iTXData; --  Send Data to bus 
                            nTXRun      <= '1'; --  Allocate USB Interface by blocking out RX
                           stateTX     <= prepare_data; --  Change state
                        end if;
                    
                    when prepare_data =>
                        oWR             <= '0';
                        oTXRead         <= '1'; --  Send Read Acknowledge to FIFO
                        stateTX         <= write_to_USB; --  Change state
                    when write_to_USB =>
                        if(iRXF = '0' AND iTXEmpty = '0') then --  If Read data available AND TX FIFO not empty
                            stateTX     <= idle; --  Change state back to idle
                            -- oTXRead     <= '0'; --  Stop reading from FIFO
                            Datainout   <= iTXData; --  Send out last Byte to USB
                        end if;
                        if((iTXE = '1' OR iTXEmpty = '1') OR --  If TX not possible OR TX FIFO is empty 
                             (iTXEmpty = '1' AND iRXF = '0')) then --  OR Read Data available AND TX FIFO empty simultaneous
                            stateTX     <= idle; --  Change state to idle
                            oTXRead     <= '0'; --  Stop writing Read Acknowledge to FIFO
                            oWR         <= '1'; --  Set Write enable to high
                            Datainout   <= (others => 'Z'); --  Set Output to high impedence
                        end if;
                        if(iTXE = '0' AND iTXEmpty = '0' AND iRXF = '1') then --  If TX available and TX FIFO not empty and no Data to receive
                            Datainout   <= iTXData; --  Send Data to Bus
                            oTXRead     <= '1'; --  Send Read Acknowledge to FIFO
                            oWR         <= '0'; --  Pull down Write Enable
                            stateTX     <= write_to_USB; --  Stay in state
                        end if;
                   when others =>
                        stateTX <= idle;
               end case;
            end if;
        end if;
end process;

Hier mal exemplarisch der Write-Fall.
Hat einer 'ne Idee, wie ich die Daten constrainen muss und/oder einen 
guten Link an der Hand, mit dem ich mich ein bisschen belesen kann?

[Markus F. (mfro)]

Marcel D. schrieb:
> oder einen
> guten Link an der Hand, mit dem ich mich ein bisschen belesen kann

http://www.alterawiki.com/wiki/TimeQuest_User_Guide

Da steht vermutlich mehr drin, als Du wissen willst.

[Gustl B. (-gb-)]

Hallo, ich verwende einen FT232H aber nur schreibend, also die Daten 
gehen vom FPGA zum PC. Die Daten kommen im FPGA aus einem 
Dual-Clock-FIFO, und werden aus diesem FIFO mit der 60MHz Clock "CLKOUT" 
gelesen. Das ist die Clock vom FT232H.
fifo_rd, fifo_empty sind die Signale zum/vom FIFO. Die Daten zum FT232H 
sind direkt mit dem Ausgang des FIFO (im FPGA) verbunden.

WR <= '0' when (TXE = '0' and fifo_rd_buff = '1') or (TXE = '0' and fail = '1') else '1';
fifo_rd <= '1' when TXE = '0' and fifo_empty = '0' else '0';
process 
  begin   
  wait until rising_edge(CLKOUT);
  fifo_rd_buff <= fifo_rd;
  TXE_buff <= TXE;
  fifo_empty_buff <= fifo_empty;
  if TXE = '0' then
    fail <= '0';
  end if;
  if fifo_empty_buff = '0' and TXE = '1' and TXE_buff = '0' then
    fail <= '1';
  end if;
end process;

fifo0: fifo_generator_0 PORT MAP(
    wr_clk => CLK100, --100MHz
    rd_clk => CLKOUT,--60MHz
    din => fifo_din,
    wr_en => fifo_wr,
    rd_en => fifo_rd,
    dout => D, --geht direkt zum FT232H
    full => fifo_full,
    empty => fifo_empty);

Das funktioniert super bis knapp 40MBytes/s dauerhaft. Der FIFO im FPGA 
sollte mindestens 64kBytes groß sein um abzufangen wenn der PC mal 
gerade nicht lesen will.

Hier 
http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.pdf 
Seite 41. Ich bin damals nur mit taktsynchronen Signalen nicht 
ausgekommen (zwar fast meistens, aber nicht immer, manchmal gab es 
Fehler) so dass ich ein paar Dinge ausserhalb des getakteten Process 
geschrieben habe.

[Marcel D. (diablokiller999)]

Danke für den Codeschnippsel!
Ich habe das ganze Design jetzt mal quasi asynchron aufgezogen, mal 
schauen ob das funktioniert (laut Simulation sollte es das). Werde dann 
in etwa 2 Stunden berichten können, so lange dauert der Kompiliervorgang 
leider. Eventuell kann ja jemand nochmal über die Richtigkeit der 
Implementierung drüber schauen, damit meine eigene Dummheit wenigstens 
ausgeschlossen werden kann ;)

entity FT2232h_V3_0 is
  port
    (
      iUSB_clk  : in        std_logic;                      --  60 MHz FT232H clock
      ireset_n  : in        std_logic;
      iTXE      : in        std_logic;                      --  TX allowed (Active low)
      iRXF      : in        std_logic;                      --  RX Data available (Active low)
      oRD       : out       std_logic;                      --  Read signal (Active low)
      oSIWU     : out       std_logic;                      --  Send Immediate / WakeUp
      oOE       : out       std_logic;                      --  Output enable (Active low)
      oWR       : out       std_logic;                      --  FIFO Buffer Write Enable (Active low)
      Datainout : inout     std_logic_vector(7 downto 0);   --  Bidirectional FIFO data 
      ---------------------------------------------------
      iTXData   : in        std_logic_vector(7 downto 0);   --  Input for Transmit Data from FIFO
      oTXRead   : out       std_logic;                      --  Acknowledge for read data
      iTXEmpty  : in        std_logic;                      --  Flag for empty TX FIFO
      ---------------------------------------------------
      oRXWrite  : out       std_logic;                      --  Write signal for RX FIFO
      oRXData   : out       std_logic_vector(7 downto 0);   --  Output Data for RX FIFO
      iRXFull   : in        std_logic                       --  Flag for full RX FIFO
      
      );
end entity;

architecture behaviour of FT2232h_V3_0 is
  type RX_TYPE is (idle, pull_rd, read_from_USB);
  signal stateRX    :   RX_TYPE := idle; 
  signal nRXRun     :   std_logic := '0';
  signal nTXRun     :   std_logic := '0';
begin
    Read_USB:  process(iUSB_clk)
    begin
        if(falling_edge(iUSB_clk)) then
            if(ireset_n = '0') then
                stateRX     <= idle;
            else
                case stateRX is
                    when idle =>
                        if(iRXFull = '0' AND iRXF = '0' AND nTXRun = '0') then --  If RX FIFO not full, RX Data available and TX not running
                            stateRX             <= pull_rd; --  Change state
                        end if;
                    when pull_rd =>
                            stateRX         <= read_from_USB;
                    when read_from_USB =>
                        if(iRXF = '0' AND iRXFull = '0') then --  When Data available on USB
                            stateRX         <= read_from_USB; --  Stay in state
                        end if;
                        if(iRXFull = '1' OR iRXF = '1') then --  If RX FIFO is full or USB RX is empty
                            stateRX         <= idle; --  Change back to state 0
                        end if;
                    when others =>
                        stateRX         <= idle;
                end case;
            end if;
        end if;
  
    end process;
oSIWU       <= '1';
oWR         <= '0' when (iTXEmpty = '0' AND iTXE = '0' AND iRXF = '1' AND nRXRun = '0' AND oOE = '1') else '1';
oOE         <= '0' when (stateRX /= idle) else '1';
oRD         <= '0' when (stateRX = read_from_USB) else '1';
oTXRead     <= '1' when (iTXEmpty = '0' AND iTXE = '0' AND iRXF = '1' AND nRXRun = '0') else '0';
Datainout   <= (others => 'Z') when (iRXF = '0') else iTXData;
nTXRun      <= '1' when (iTXEmpty = '0' AND iTXE = '0' AND iRXF = '1' AND nRXRun = '0') else '0';
nRXRun      <= '1' when (iRXFull = '0' AND iRXF = '0' AND nTXRun = '0') else '0';
oRXData     <= Datainout when (iRXFull = '0' AND iRXF = '0' AND nTXRun = '0') else (others => '0');
oRXWrite    <= '1' when (stateRX = read_from_USB) else '0';
end behaviour;

[Gustl B. (-gb-)]

Marcel D. schrieb:
> Werde dann
> in etwa 2 Stunden berichten können, so lange dauert der Kompiliervorgang
> leider.

Ähm ... wieso testest Du das nicht einzeln? Also nur die Anbindung zum 
FT2232H und generierst dazu im FPGA irgendwelche Dummydaten die Du am PC 
leicht überprüfen kannst, z. B. kann man gut einen Zähler verwenden und 
dann gucken ob wirklich alle Zählerwerte in richtiger Reihenfolge am PC 
ankommen.

[Marcel D. (diablokiller999)]

Weil das Devkit anderweitig in Benutzung ist und ich das auf fertiger 
Hardware testen muss, habe zwar Dinge aus dem Projekt entfernt aber 
leider ist die compile time noch immer gut 2 Stunden für den Arria :)