Subversion Repositories saturn

--============================================================================= 
--  TITRE : IF_PROMSPI
--  DESCRIPTION : 
--        Implémente une interface SPI master avec une vitesse de clk_sys / div_rate 
--        Le bus parallèle accepte en entrée un flux de données à écrire et fourni 
--        en sortie un flux de données lues.
--        Il supporte 2 types de commandes selon type_com et sur ordre de exec_com
--          type_com    |           opération
--             0        | Emet sur SPI la totalité des octets fournis précédemment sur TX_DAT
--             1        | Emet sur SPI la totalité des octets fournis précédemment sur TX_DAT
--                      | et récupère en lecture sur SPI nb_read octet et les met à disposition
--                      | sur RX_DAT
--  FICHIER :        if_promspi.vhd 
--=============================================================================
--  CREATION 
--  DATE	      AUTEUR	PROJET	REVISION 
--  10/04/2014	DRA	   SATURN	V1.0 
--=============================================================================
--  HISTORIQUE  DES  MODIFICATIONS :
--  DATE	      AUTEUR	PROJET	REVISION 
--=============================================================================
 
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
 
ENTITY if_promspi IS
   GENERIC (
      div_rate    : INTEGER := 1;      -- Diviseur d'horloge système pour obtenir le débit SPI = 2^div_rate
      spiclk_freq : INTEGER := 10      -- Fréquence horloge SPI (MHz) = freq(clk_sys)/2^div_rate
      );
   PORT (
      -- Ports système
      clk_sys     : IN  STD_LOGIC;  -- Clock système à 20 MHz
      rst_n       : IN  STD_LOGIC;  -- Reset général système
 
      -- Interface série
      spi_csn     : OUT STD_LOGIC;  -- CS de la mémoire SPI
      spi_wpn     : OUT STD_LOGIC;  -- Write Protect de la mémoire SPI
      spi_sdo     : OUT STD_LOGIC;  -- Data Write
      spi_sdi     : IN  STD_LOGIC;  -- Data Read
      spi_clk     : OUT STD_LOGIC;  -- SPI Clock en (CPOL, CPHA) = (0, 0)
 
      -- Interface parallèle
      tx_dat      : IN  STD_LOGIC_VECTOR(7 downto 0);  -- Commande + Données à transmettre en SPI
      tx_val      : IN  STD_LOGIC;                     -- Validant du bus tx_dat
      rx_dat      : OUT STD_LOGIC_VECTOR(7 downto 0);  -- Données lues sur le bus SPI
      rx_val      : OUT STD_LOGIC;                     -- Signal indiquant la validité de la donnée sur le bus rx
      rx_next     : IN  STD_LOGIC;                     -- Indique qu'il ya des donénes dans la FIFO de réception
      type_com    : IN  STD_LOGIC;                     -- Code du type de commande à éxécuter
      exec_com    : IN  STD_LOGIC;                     -- Ordre d'exécution de la commande codée par type_com
      spi_busy    : OUT STD_LOGIC;                     -- Signale que l'interface SPI est occupée avec une commande
      nb_read     : IN  STD_LOGIC_VECTOR(7 DOWNTO 0)   -- Nombre d'octets à lire pour les commandes de type READ
      );
END if_promspi;
 
ARCHITECTURE rtl of if_promspi is
   CONSTANT com_wronly  : STD_LOGIC := '0';                       -- Commande de type Write Only
   CONSTANT com_wrrd    : STD_LOGIC := '1';                       -- Commande de type Write + Read (nb_read)
   SIGNAL rst           : STD_LOGIC;                              -- Reset des FIFO Tx et Rx
   SIGNAL div_clk       : STD_LOGIC_VECTOR(div_rate-1 DOWNTO 0);  -- Compteur pour diviser l'horloge système
   SIGNAL rise_clk      : STD_LOGIC;                              -- Front montant de l'horloge SPI
   SIGNAL fall_clk      : STD_LOGIC;                              -- Front descendant de l'horloge SPI
   SIGNAL fallclk_r     : STD_LOGIC;                              -- Front descendant de l'horloge SPI retardé d'un clk
   SIGNAL mask_clk      : STD_LOGIC;                              -- Signal de masque de l'horloge SPI
   SIGNAL cpt_bit       : STD_LOGIC_VECTOR(2 DOWNTO 0);           -- Compteur de bit pour le ser/deser
   SIGNAL cpt_byt       : STD_LOGIC_VECTOR(7 DOWNTO 0);           -- Compteur d'octets pour la réception
   SIGNAL fifotx_rd     : STD_LOGIC;                              -- Signal de lecture de la FIFO Tx
   SIGNAL data_tx       : STD_LOGIC_VECTOR(7 DOWNTO 0);           -- Data lue dans la FIFO Tx
   SIGNAL fifotx_empty  : STD_LOGIC;                              -- FIFO Tx vide
   SIGNAL fiforx_wr     : STD_LOGIC;                              -- Signal d'écriture dans la FIFO Rx
   SIGNAL fiforx_empty  : STD_LOGIC;                              -- FIFO Rx vide
   SIGNAL shifter_tx    : STD_LOGIC_VECTOR(7 DOWNTO 0);           -- Serialisateur
   SIGNAL shifter_rx    : STD_LOGIC_VECTOR(7 DOWNTO 0);           -- Déserialisateur
   SIGNAL read_stat     : STD_LOGIC;                              -- A 1 lors d'une lecture du registre de status
   SIGNAL latch_typcom  : STD_LOGIC;                              -- Pour mémoriser le type de commande
 
   -- Machine d'état de gestion des commandes
   TYPE fsmspi_typ IS (idle_st, latchcom_st, sendcom_st, getdat_st, releasecs_st, readstat_st, endcom_st);
   SIGNAL fsm_spi    : fsmspi_typ;
 
   -- FIFO (256 x 8bits) TX et RX en FWFT
   COMPONENT fifo_spi
   PORT (
      clk   : IN STD_LOGIC;
      rst   : IN STD_LOGIC;
      din   : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
      wr_en : IN STD_LOGIC;
      rd_en : IN STD_LOGIC;
      dout  : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
      full  : OUT STD_LOGIC;
      empty : OUT STD_LOGIC
      );
   END COMPONENT;
 
BEGIN
   rst <= NOT(rst_n);
 
   ------------------------------------------
   -- Process de generation de la clock SPI
   ------------------------------------------
   gen_clk : PROCESS(clk_sys, rst_n)
   BEGIN
      IF (rst_n = '0') THEN
         div_clk <= (OTHERS => '0');
         fallclk_r <= '0';
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         div_clk <= div_clk + 1;
         fallclk_r <= fall_clk;
      END IF;
   END PROCESS;
   spi_clk <= mask_clk AND div_clk(div_clk'LEFT);     -- La clock est active en fonction de la machine d'état
   -- rise_clk est actif au cycle qui précède le front montant effectif
   rise_clk <= '1' WHEN (div_clk = CONV_STD_LOGIC_VECTOR(2**(div_rate-1)-1, div_rate)) ELSE '0';
   -- fall_clk est actif au cycle qui précède le front descendant effectif
   fall_clk <= '1' WHEN (div_clk = CONV_STD_LOGIC_VECTOR(2**div_rate-1, div_rate)) ELSE '0';
 
   -------------------------------------------------
   -- Machine d'état d'exécution des commandes SPI
   -------------------------------------------------
   spi_sdo <= shifter_tx(7);           -- On SER les data MSB first
   spi_wpn <= '1';                     -- L'écriture est toujours autorisée dans la flash
   man_fm : PROCESS(clk_sys, rst_n)
   BEGIN
      IF (rst_n = '0') THEN
         fsm_spi <= idle_st;
         spi_csn <= '1';
         mask_clk <= '0';
         spi_busy <= '1';              -- En reset, on indique le SPI est inutilisable
         shifter_tx <= (OTHERS => '0');
         fifotx_rd <= '0';
         shifter_rx <= (OTHERS => '0');
         fiforx_wr <= '0';
         read_stat <= '0';
         latch_typcom <= '0';
         cpt_bit <= "000";
         cpt_byt <= (OTHERS => '0');
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         CASE fsm_spi IS
            WHEN idle_st =>
            -- Etat d'attente d'une nouvelle commande à envoyer
               IF (exec_com = '1' AND fifotx_empty = '0') THEN
               -- Si on reçoit une nouvelle commande et si il y'a effectivement des octets à transmettre
                  spi_busy <= '1';           -- On signale qu'on est occupé
                  latch_typcom <= type_com;  -- On mémorise le type de la commande
                  fsm_spi <= latchcom_st;
               ELSE
                  spi_busy <= '0';
               END IF;
 
            WHEN latchcom_st =>
            -- Etat d'attent du 1er front montant de sclk
               IF (rise_clk = '1') THEN
                  spi_csn <= '0';         -- On active la Flash
                  cpt_bit <= "000";       -- On initialise le compteur de bit de façon à traiter le 1er octet (cf état suivant)
                  read_stat <= '0';       -- Par défaut, on ne lit pas encore le registre de status
                  fsm_spi <= sendcom_st;  -- On va envoyer la commande
               END IF;
 
            WHEN sendcom_st =>
            -- Etat de transmission de la commande
               IF (fall_clk = '1') THEN
               -- Sur chaque front descendant de la clock SPI
                  IF (cpt_bit = "000") THEN
                  -- Si on a transmis tous les bits (ou bien aucun pour le premier passage)
                     cpt_bit <= "111";
                     IF (fifotx_empty = '0' AND read_stat = '0') THEN
                     -- S'il reste des octets à transmettre et qu'on est pas en train de lire de status
                     -- note : si read_stat = 1 et fifo Tx n'est pas vide est un cas d'erreur
                        shifter_tx <= data_tx;  -- On va le SER
                        fifotx_rd <= '1';       -- On lit l'octet suivant dans la FIFO
                     ELSE
                     -- Si on a fini de transmettre les octets
                        IF (latch_typcom = com_wrrd or read_stat = '1') THEN
                        -- Si c'est une commande de type WR+RD ou bien si on lit le registre de staut
                           cpt_byt <= nb_read;     -- On va lire nb_read octets (ou une infinité si read_stat)
                           fsm_spi <= getdat_st;
                        ELSE
                        -- Si c'est une commande WR only
                           mask_clk <= '0';           -- On masque l'horloge
                           fsm_spi <= releasecs_st;   -- on va préparer la lecture du status
                        END IF;
                     END IF;
                  ELSE
                  -- Si on a pas SER tous les bits de l'octets
                     shifter_tx <= shifter_tx(6 DOWNTO 0) & '0';
                     cpt_bit <= cpt_bit - 1;
                     fifotx_rd <= '0';
                  END IF;
               ELSE
               -- On s'assure que le read dans la FIFO Tx ne dure qu'un cycle
                  fifotx_rd <= '0';
                  IF (fallclk_r = '1') THEN
                  -- Ici, on s'assure que le masque de l'horloge est enclenché un cycle d'horloge après le front descendant effectif
                  -- de la clock spi (évite les glitches)
                     mask_clk <= '1';
                  END IF;
               END IF;
 
            WHEN getdat_st =>
            -- Etat de réception des données de la FIFO
            -- Quand on arrive ici la première fois, nb_bit vaut déjà "111"
               IF (rise_clk = '1') THEN
               -- On échantillone sur front montant de la clock SPI
                  shifter_rx <= shifter_rx(6 DOWNTO 0) & spi_sdi; -- On DESER MSB first
               END IF;
               IF (fall_clk = '1') THEN
                  IF (cpt_bit = "000") THEN
                  -- Si on a DESER les 8 bits
                     fiforx_wr <= NOT(read_stat);          -- On stocke la donnée dans la FIFO Rx si c'est pas une lecture de status
                     IF ((latch_typcom = com_wrrd AND cpt_byt = CONV_STD_LOGIC_VECTOR(1, cpt_byt'LENGTH)) OR
                         (read_stat = '1' AND spi_sdi = '0')) THEN
                     -- Si c'est une commande WR+RD(nb_read) et qu'on a reçu les nb_read octets ou bien
                     -- on était en train de lire le registre de status et le LSB (WIP) du registre de status est nul
                        mask_clk <= '0';         -- On a fini
                        read_stat <= '0';
                        fsm_spi <= endcom_st;
                     ELSE
                     -- Si on doit encore récupérer des octets
                        cpt_byt <= cpt_byt - 1;
                     END IF;
                     cpt_bit <= "111";
                  ELSE
                  -- Si on n'a pas encore 7 bits
                     cpt_bit <= cpt_bit - 1;
                     fiforx_wr <= '0';
                  END IF;
               ELSE
               -- On s'assure que le signal de WR dans la FIFO Rx ne dure que 1 cycle
                  fiforx_wr <= '0';
               END IF;
 
            WHEN releasecs_st =>
            -- Etat de relachement du CS avant envoie de la commande de lecture du status.
               IF (rise_clk = '1') THEN
                  spi_csn <= '1';
                  -- On ajuste la tempo pour assurer que le release du CS fait bien 100ns quel que soit la clock SPI
                  cpt_byt <= CONV_STD_LOGIC_VECTOR(100*spiclk_freq/1000+1, cpt_byt'LENGTH);
                  fsm_spi <= readstat_st;
               END IF;
 
            WHEN readstat_st =>
            -- Etat de temporisation avant d'envoyer la commande de lecture du status 
               IF (rise_clk = '1') THEN
                  cpt_byt <= cpt_byt - 1;
               END IF;
               IF (fall_clk = '1' AND cpt_byt = CONV_STD_LOGIC_VECTOR(0, cpt_byt'LENGTH)) THEN
                  spi_csn <= '0';            -- On recommence un cycle SPI
                  cpt_bit <= "111";
                  shifter_tx <= x"05";       -- On force la transmission de la commande de lecture du status
                  read_stat <= '1';
                  fsm_spi <= sendcom_st;
               END IF;
 
            WHEN endcom_st =>
            -- Etat de fin, on attend un front montant de la clock SPI pour désactiver le CS.
               fiforx_wr <= '0';
               IF (rise_clk = '1') THEN
                  spi_busy <= '0';
                  spi_csn <= '1';
                  fsm_spi <= idle_st;
               END IF;
 
            WHEN OTHERS =>
               fsm_spi <= idle_st;
         END CASE;
      END IF;
   END PROCESS;
 
   inst_fiftx : fifo_spi
   PORT MAP (
      clk =>   clk_sys,
      rst =>   rst,
      din =>   tx_dat,
      wr_en => tx_val,
      rd_en => fifotx_rd,
      dout =>  data_tx,
      full =>  OPEN,
      empty => fifotx_empty
   );
 
   inst_fifrx : fifo_spi
   PORT MAP (
      clk =>   clk_sys,
      rst =>   rst,
      din =>   shifter_rx,
      wr_en => fiforx_wr,
      rd_en => rx_next,
      dout =>  rx_dat,
      full =>  OPEN,
      empty => fiforx_empty
   );
   rx_val <= NOT(fiforx_empty);
 
END rtl;