Subversion Repositories saturn

--============================================================================= 

--  TITRE : COMMUNICATION

--  DESCRIPTION : 

--        Implémente la pile communication des MIO de SATURN sans PIC32 

--        Le module read_mac maintien les autres modules en reset

--        tant que l'adresse MAC n'a pas été récupérée

--  FICHIER :        communication.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 communication IS

   GENERIC (

      reg_typemio : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"10";   -- Type du MIO

      reg_version : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"10";   -- Version du MIO

      ad_ref      : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"80";   -- Adresse des registres à émettre sur trame de synchro

      sz_ref      : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"04"    -- Nb otets à émettre sur trame de synchro

      );

   PORT (

      -- Ports système

      clk_sys  : IN  STD_LOGIC;                       -- Clock système

      rst_n    : IN  STD_LOGIC;                       -- Reset général système

      iid      : IN  STD_LOGIC_VECTOR(63 DOWNTO 0);   -- IID du MIO

      sync_lock   : OUT STD_LOGIC;

      -- Interfaces séries 1 et 2

      rx1       : IN  STD_LOGIC;                      -- Réception série    

      tx1       : OUT  STD_LOGIC;                     -- Transmission série

      rx2       : IN  STD_LOGIC;                      -- Réception série    

      tx2       : OUT  STD_LOGIC;                     -- Transmission série

      -- Bus d'accès à la zone métier du MIO

      datout_write: OUT STD_LOGIC_VECTOR(7 downto 0); -- Données à écrire sur l'interface externe

      datout_read : IN STD_LOGIC_VECTOR(7 downto 0);  -- Données lues sur l'interface externe

      ad_out      : OUT STD_LOGIC_VECTOR(6 downto 0); -- Adresse d'écriture et de lecture des données externe

      wr_out      : OUT STD_LOGIC;                    -- Signal d'écriture sur l'interface externe

      rd_out      : OUT STD_LOGIC;                    -- Signal de lecture sur l'interface externe

      -- Signaux de pilotage du SPI de la PROM de config du FPGA

      reload_fpgan: OUT STD_LOGIC;                    -- Ordre de reconfig du FPGA

      spi_csn  : OUT  STD_LOGIC;                      -- CS de la PROM

      spi_wpn  : OUT  STD_LOGIC;                      -- Write protect de la PROM

      spi_sdo  : OUT  STD_LOGIC;                      -- Serial Data vers la PROM

      spi_sdi  : IN  STD_LOGIC;                       -- Serial Data venant de la PROM

      spi_clk  : OUT  STD_LOGIC;                       -- clock série vers la PROM

                spare      : OUT STD_LOGIC_VECTOR(5 DOWNTO 0)

      );

END communication;

ARCHITECTURE rtl of communication is

   -- Définit le nombre de bit nécessaires pour mesurer la durée du bit le plus lent avec l'horloge système

   -- i.e. 1 Bit à 50Kbit/s = 20µs nbbit_div = Log2(96MHz x 20µs)

   CONSTANT nbbit_div      : INTEGER := 11;

   -- DFF pour la métastabilité de rx1 et rx2

   SIGNAL rx1_r1, rx1_r2 : STD_LOGIC;        -- Pour la metastabilité sur Rx1

   SIGNAL rx2_r1, rx2_r2 : STD_LOGIC;        -- Pour la metastabilité sur Rx2

   SIGNAL tc_divclk     : STD_LOGIC_VECTOR(nbbit_div - 1 DOWNTO 0); -- Diviseur d'horloge pour le baud rate

   SIGNAL baud_locked   : STD_LOGIC;                     -- Indique que l'autobaudrate a convergé

   SIGNAL tid           : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- TID du MIO

   -- Interfaces du SWITCH1

   SIGNAL layer1_rx1    : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Flux de donnée déserialisé (Rx)

   SIGNAL layer1_val1   : STD_LOGIC;                     -- Indique un octet valide sur layer1_rx1

   SIGNAL sw_ena1       : STD_LOGIC;                     -- Indique qu'on est en réception entre 2 trames sur port 1

   SIGNAL layer1_tx1    : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Flux de donnée à sérialiser (Tx)

   SIGNAL layer1_rd1    : STD_LOGIC;                     -- Demande un octet de plus à transmettre

   SIGNAL layer1_empty1 : STD_LOGIC;                     -- Indique qu'aucun octet n'est en attente de serialsiation

   SIGNAL copy_ena1     : STD_LOGIC;

   -- Interfaces du SWITCH2

   SIGNAL layer1_rx2    : STD_LOGIC_VECTOR(7 DOWNTO 0);

   SIGNAL layer1_val2   : STD_LOGIC;

   SIGNAL sw_ena2       : STD_LOGIC;

   SIGNAL layer1_tx2    : STD_LOGIC_VECTOR(7 DOWNTO 0);

   SIGNAL layer1_rd2    : STD_LOGIC;

   SIGNAL layer1_empty2 : STD_LOGIC;

   SIGNAL copy_ena2     : STD_LOGIC;

   -- Interfaces du module LAYER2_RX1

   SIGNAL layer2_rx1    : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Flux de données applicatives destuffé

   SIGNAL layer2_rxval1 : STD_LOGIC;                     -- Indique un octet valide sur layer2_rx1

   SIGNAL layer2_sof1   : STD_LOGIC;                     -- Indique un  début de trame

   SIGNAL layer2_eof1   : STD_LOGIC;                     -- Indqiue une fin de trame

   SIGNAL layer2_l2ok1  : STD_LOGIC;                     -- Indique que la trame reçue est correcte

   -- Interfaces du module LAYER2_RX2

   SIGNAL layer2_rx2    : STD_LOGIC_VECTOR(7 DOWNTO 0);

   SIGNAL layer2_rxval2 : STD_LOGIC;

   SIGNAL layer2_sof2   : STD_LOGIC;

   SIGNAL layer2_eof2   : STD_LOGIC;

   SIGNAL layer2_l2ok2  : STD_LOGIC;

   -- Interfaces du module FRAME_STORE1 (couche applicative)

   SIGNAL layer7_rx1       : STD_LOGIC_VECTOR(7 DOWNTO 0);-- Données applicatives reçues sur port 1

   SIGNAL layer7_soc1      : STD_LOGIC;                   -- Indique un début de trame

   SIGNAL layer7_rd1       : STD_LOGIC;                   -- Signal de lecture d'un octet de plus

   SIGNAL layer7_newframe1 : STD_LOGIC;                   -- Indique la réception d'une nouvelle trame

   SIGNAL layer7_comdispo1 : STD_LOGIC;                   -- Indique qu'au moins une trame est dispo en mémoire

   SIGNAL layer7_l7ok1     : STD_LOGIC;                   -- Indique que la trame reçue est conforme

   SIGNAL layer7_overflow1 : STD_LOGIC;                   -- Indique un débordement de mémoire

   -- Interfaces du module FRAME_STORE2

   SIGNAL layer7_rx2       : STD_LOGIC_VECTOR(7 DOWNTO 0);

   SIGNAL layer7_soc2      : STD_LOGIC;

   SIGNAL layer7_rd2       : STD_LOGIC;

   SIGNAL layer7_newframe2 : STD_LOGIC;

   SIGNAL layer7_comdispo2 : STD_LOGIC;

   SIGNAL layer7_l7ok2     : STD_LOGIC;

   SIGNAL layer7_overflow2 : STD_LOGIC;

   -- Interface d'écriture des trames à émettre

   SIGNAL tx_dat           : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Donnée applicative à émettre

   SIGNAL val_txdat        : STD_LOGIC;                     -- Indique un octet dispo sur tx_dat

   SIGNAL tx_sof           : STD_LOGIC;                     -- Indique un début de trame

   SIGNAL tx_eof           : STD_LOGIC;                     -- Indique une fin de trame

   SIGNAL txdat_free       : STD_LOGIC;                     -- Indique que le module couche transport Tx est dispo

   SIGNAL clr_fifo_tx      : STD_LOGIC;                     -- Clear de la FIFO transport Tx

   -- Interfaces du module LAYER2_TX

   SIGNAL layer2_txdat     : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Flux de donnée stuffé + CRC transport

   SIGNAL layer2_txval     : STD_LOGIC;                     -- Indique un octet valide sur layer2_txdat

   SIGNAL layer2_progfull1 : STD_LOGIC;                     -- La FIFO de données Tx port 1 est presque pleine

   SIGNAL layer2_progfull2 : STD_LOGIC;                     -- La FIFO de données Tx port 2 est presque pleine

   SIGNAL layer2_full1     : STD_LOGIC;                     -- La FIFO de données Tx port 1 est pleine

   SIGNAL layer2_full2     : STD_LOGIC;                     -- La FIFO de données Tx port 2 est pleine

   -- Interface de pilotage du module SPI de programmation de la PROM FPGA

   SIGNAL spitx_dat        : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Data + commande à sérialiser

   SIGNAL spitx_val        : STD_LOGIC;                     -- Validant de spitx_dat

   SIGNAL spirx_dat        : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Data reçue

   SIGNAL spirx_val        : STD_LOGIC;                     -- Indique des données dispo dans spirx_val

   SIGNAL spirx_next       : STD_LOGIC;                     -- Lit un octet de plus dans spirx_val

   SIGNAL spi_typecom      : STD_LOGIC;                     -- Type de commande à éxécuter

   SIGNAL spi_execcom      : STD_LOGIC;                     -- Ordre d'exécution d'une commande

   SIGNAL spi_busy         : STD_LOGIC;                     -- Indique que le module SPI est occupé

   SIGNAL spi_nbread       : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Nombre d 'octets à lire avec une commande de lecture

   SIGNAL spi_rstn         : STD_LOGIC;                     -- Reset du module SPI

        SIGNAL etat1, etat2        : STD_LOGIC;

        COMPONENT autobaud

        PORT(

                clk_sys     : IN STD_LOGIC;

                rst_n       : IN STD_LOGIC;

                rx1         : IN STD_LOGIC;

                val_rx1     : IN STD_LOGIC;

                eof1        : IN STD_LOGIC;

                dat_rx1     : IN  STD_LOGIC_VECTOR(7 DOWNTO 0);

      l2_ok1      : IN STD_LOGIC;

                rx2         : IN STD_LOGIC;

                val_rx2     : IN STD_LOGIC;

                eof2        : IN STD_LOGIC;

                dat_rx2     : IN  STD_LOGIC_VECTOR(7 DOWNTO 0);

      l2_ok2      : IN STD_LOGIC;

                tc_divclk   : OUT STD_LOGIC_VECTOR(10 downto 0);

                baud_locked : OUT STD_LOGIC

                );

        END COMPONENT;

        COMPONENT switch

   GENERIC (

      nbbit_div : INTEGER := 10);

        PORT(

                clk_sys     : IN STD_LOGIC;

                rst_n       : IN STD_LOGIC;

      baud_lock   : IN  STD_LOGIC;

                tc_divclk   : IN STD_LOGIC_VECTOR(nbbit_div-1 downto 0);

                rx          : IN STD_LOGIC;

                rx_dat      : OUT STD_LOGIC_VECTOR(7 downto 0);

                rx_val      : OUT STD_LOGIC;

                tx          : OUT STD_LOGIC;

                tx_dat      : IN STD_LOGIC_VECTOR(7 downto 0);

                tx_rd       : OUT STD_LOGIC;

                tx_empty    : IN STD_LOGIC;

                sw_ena      : IN STD_LOGIC;

                copy_ena    : IN STD_LOGIC;

                etat            : OUT  STD_LOGIC

                );

        END COMPONENT;

        COMPONENT layer2_rx

   GENERIC (

      nbbit_div : INTEGER := 10);

        PORT(

                clk_sys     : IN STD_LOGIC;

                rst_n       : IN STD_LOGIC;

                tc_divclk   : IN STD_LOGIC_VECTOR(nbbit_div-1 downto 0);

                ad_mio      : IN STD_LOGIC_VECTOR(7 downto 0);

                dat_in      : IN STD_LOGIC_VECTOR(7 downto 0);

                val_in      : IN STD_LOGIC;

                dat_out     : OUT STD_LOGIC_VECTOR(7 downto 0);

                val_out     : OUT STD_LOGIC;

                sw_ena      : OUT STD_LOGIC;

                sof         : OUT STD_LOGIC;

                eof         : OUT STD_LOGIC;

                l2_ok       : OUT STD_LOGIC

                );

        END COMPONENT;

        COMPONENT frame_store

        PORT(

                clk_sys     : IN STD_LOGIC;

                rst_n       : IN STD_LOGIC;

                dat_in      : IN STD_LOGIC_VECTOR(7 downto 0);

                val_in      : IN STD_LOGIC;

                sof         : IN STD_LOGIC;

                eof         : IN STD_LOGIC;

                l2_ok       : IN STD_LOGIC;

                dat_out     : OUT STD_LOGIC_VECTOR(7 downto 0);

      soc_out     : OUT STD_LOGIC;

                rd_datout   : IN STD_LOGIC;

                new_frame   : OUT STD_LOGIC;

                com_dispo   : OUT STD_LOGIC;

                l7_ok       : OUT STD_LOGIC;

      overflow    : OUT STD_LOGIC

                );

        END COMPONENT;

        COMPONENT com_exec

      GENERIC (

      freq_clksys : INTEGER := 48;

      reg_typemio : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"10";   -- Type du MIO

      reg_version : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"10";   -- Version du MIO

      ad_ref      : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"80";

      sz_ref      : STD_LOGIC_VECTOR(7 DOWNTO 0) := x"04"

      );

        PORT(

                clk_sys     : IN STD_LOGIC;

                rst_n       : IN STD_LOGIC;

                tid         : OUT STD_LOGIC_VECTOR(7 downto 0);

      iid         : IN  STD_LOGIC_VECTOR(63 downto 0);

      sync_lock   : OUT STD_LOGIC;

                datout_read : IN STD_LOGIC_VECTOR(7 downto 0);

                datout_write: OUT STD_LOGIC_VECTOR(7 downto 0);

                ad_out      : OUT STD_LOGIC_VECTOR(6 downto 0);

                wr_out      : OUT STD_LOGIC;

      rd_out      : OUT STD_LOGIC;

                activity1   : IN STD_LOGIC;

                activity2   : IN STD_LOGIC;

                datin1      : IN STD_LOGIC_VECTOR(7 downto 0);

      socin1      : IN STD_LOGIC;

                new_frame1  : IN STD_LOGIC;

                com_dispo1  : IN STD_LOGIC;

                l7_ok1      : IN STD_LOGIC;

      l7_overflow1: IN STD_LOGIC;

                datin2      : IN STD_LOGIC_VECTOR(7 downto 0);

      socin2      : IN STD_LOGIC;

                new_frame2  : IN STD_LOGIC;

                com_dispo2  : IN STD_LOGIC;

                l7_ok2      : IN STD_LOGIC;

      l7_overflow2: IN STD_LOGIC;

                datsent_free: IN STD_LOGIC;

                rd_datin1   : OUT STD_LOGIC;

                rd_datin2   : OUT STD_LOGIC;

                datsent     : OUT STD_LOGIC_VECTOR(7 downto 0);

                valsent     : OUT STD_LOGIC;

                sof         : OUT STD_LOGIC;

                eof         : OUT STD_LOGIC;

      clr_fifo_tx : OUT STD_LOGIC;

      copy_ena1   : OUT STD_LOGIC;

      copy_ena2   : OUT STD_LOGIC;

      reload_fpgan: OUT STD_LOGIC;

      spitx_dat   : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);

      spitx_val   : OUT STD_LOGIC;

      spirx_dat   : IN  STD_LOGIC_VECTOR(7 DOWNTO 0);

      spirx_val   : IN  STD_LOGIC;

      spirx_next  : OUT STD_LOGIC;

      spi_typecom : OUT STD_LOGIC;

      spi_execcom : OUT STD_LOGIC;

      spi_busy    : IN  STD_LOGIC;

      spi_nbread  : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);

      spi_rstn    : OUT STD_LOGIC

                );

        END COMPONENT;

   COMPONENT layer2_tx

   PORT(

      clk_sys     : IN STD_LOGIC;

      rst_n       : IN STD_LOGIC;

      dat_in      : IN STD_LOGIC_VECTOR(7 downto 0);

      val_in      : IN STD_LOGIC;

      sof         : IN STD_LOGIC;

      eof         : IN STD_LOGIC;

      datin_free  : OUT STD_LOGIC;

      dat_out     : OUT STD_LOGIC_VECTOR(7 downto 0);

      val_out     : OUT STD_LOGIC;

      clr_fifo    : IN   STD_LOGIC;

      progfull1   : IN   STD_LOGIC;

      progfull2   : IN   STD_LOGIC;

      full1       : IN   STD_LOGIC;

      empty1      : IN   STD_LOGIC;

      full2       : IN   STD_LOGIC;

      empty2      : IN   STD_LOGIC

      );

   END COMPONENT;

   -- La FIFO contient 512 mots, le prog_full est configuré à 500 mots pour laisser une marge de 

   -- stockage avant overflow (voir le module layer2_tx)

   COMPONENT fifo_tx

   PORT (

      clk      : IN STD_LOGIC;

      srst     : 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;

      prog_full: OUT STD_LOGIC

      );

   END COMPONENT;

   COMPONENT if_promspi

   GENERIC (

      div_rate : INTEGER := 3;      -- Diviseur d'horloge système pour obtenir le débit SPI = 2^div_rate

      spiclk_freq : INTEGER := 12

      );

   PORT(

      clk_sys  : IN  std_logic;

      rst_n    : IN  std_logic;

      spi_csn  : OUT  std_logic;

      spi_wpn  : OUT  std_logic;

      spi_sdo  : OUT  std_logic;

      spi_sdi  : IN  std_logic;

      spi_clk  : OUT  std_logic;

      tx_dat   : IN  std_logic_vector(7 downto 0);

      tx_val   : IN  std_logic;

      rx_dat   : OUT  std_logic_vector(7 downto 0);

      rx_val   : OUT  std_logic;

      rx_next  : IN  std_logic;

      type_com : IN  std_logic;

      exec_com : IN  std_logic;

      spi_busy : OUT  std_logic;

      nb_read  : IN  std_logic_vector(7 downto 0)

      );

    END COMPONENT;

BEGIN

        spare <= etat2 & etat1 & sw_ena2 & sw_ena1 & copy_ena2 & copy_ena1;

   --------------------------------------------

   -- Gestion de la métastbilité de rx1 et rx2

   --------------------------------------------

   meta : PROCESS(clk_sys, rst_n)

   BEGIN

      IF (rst_n = '0') THEN

         rx1_r1 <= '1';

         rx1_r2 <= '1';

         rx2_r1 <= '1';

         rx2_r2 <= '1';

      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN

         rx1_r1 <= rx1;

         rx1_r2 <= rx1_r1;

         rx2_r1 <= rx2;

         rx2_r2 <= rx2_r1;

      END IF;

   END PROCESS;

        inst_autobaud: autobaud

   PORT MAP(

                clk_sys =>  clk_sys,

                rst_n =>    rst_n,

                rx1 =>      rx1_r2,

                rx2 =>      rx2_r2,

                val_rx1 =>  layer1_val1,

                dat_rx1 =>  layer1_rx1,

      eof1 =>     layer2_eof1,

                l2_ok1 =>   layer2_l2ok1,

                val_rx2 =>  layer1_val2,

      dat_rx2 =>  layer1_rx2,

                eof2 =>     layer2_eof2,

                l2_ok2 =>   layer2_l2ok2,

                tc_divclk => tc_divclk,

                baud_locked => baud_locked

        );

        inst_switch1: switch

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

      baud_lock =>   baud_locked,

                tc_divclk =>   tc_divclk,

                rx =>          rx1_r2,

                rx_dat =>      layer1_rx1,

                rx_val =>      layer1_val1,

                tx =>          tx2,

                tx_dat =>      layer1_tx2,

                tx_rd =>       layer1_rd2,

                tx_empty =>    layer1_empty2,

                sw_ena =>      sw_ena1,

                copy_ena =>    copy_ena1,

                etat => etat1

        );

        inst_switch2: switch

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

      baud_lock =>   baud_locked,

                tc_divclk =>   tc_divclk,

                rx =>          rx2_r2,

                rx_dat =>      layer1_rx2,

                rx_val =>      layer1_val2,

                tx =>          tx1,

                tx_dat =>      layer1_tx1,

                tx_rd =>       layer1_rd1,

                tx_empty =>    layer1_empty1,

                sw_ena =>      sw_ena2,

                copy_ena =>    copy_ena2,

                etat => etat2

        );

        inst_layer2_rx1: layer2_rx

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

                tc_divclk =>   tc_divclk,

      ad_mio =>      tid,

                dat_in =>      layer1_rx1,

                val_in =>      layer1_val1,

                dat_out =>     layer2_rx1,

                val_out =>     layer2_rxval1,

                sof =>         layer2_sof1,

                eof =>         layer2_eof1,

                l2_ok =>       layer2_l2ok1,

                sw_ena =>      sw_ena1

        );

        inst_layer2_rx2: layer2_rx

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

                tc_divclk =>   tc_divclk,

      ad_mio =>      tid,

                dat_in =>      layer1_rx2,

                val_in =>      layer1_val2,

                dat_out =>     layer2_rx2,

                val_out =>     layer2_rxval2,

                sof =>         layer2_sof2,

                eof =>         layer2_eof2,

                l2_ok =>       layer2_l2ok2,

                sw_ena =>      sw_ena2

        );

        inst_frame_store1: frame_store

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

                dat_in =>      layer2_rx1,

                val_in =>      layer2_rxval1,

                sof =>         layer2_sof1,

                eof =>         layer2_eof1,

                l2_ok =>       layer2_l2ok1,

                dat_out =>     layer7_rx1,

      soc_out =>     layer7_soc1,

                rd_datout =>   layer7_rd1,

                new_frame =>   layer7_newframe1,

                com_dispo =>   layer7_comdispo1,

                l7_ok =>       layer7_l7ok1,

      overflow =>    layer7_overflow1

        );

        inst_frame_store2: frame_store

   PORT MAP(

                clk_sys =>     clk_sys,

                rst_n =>       rst_n,

                dat_in =>      layer2_rx2,

                val_in =>      layer2_rxval2,

                sof =>         layer2_sof2,

                eof =>         layer2_eof2,

                l2_ok =>       layer2_l2ok2,

                dat_out =>     layer7_rx2,

      soc_out =>     layer7_soc2,

                rd_datout =>   layer7_rd2,

                new_frame =>   layer7_newframe2,

                com_dispo =>   layer7_comdispo2,

                l7_ok =>       layer7_l7ok2,

      overflow =>    layer7_overflow2

        );

   inst_comexec: com_exec

   GENERIC MAP(

      freq_clksys => 96,

      reg_typemio => reg_typemio,

      reg_version => reg_version,

      ad_ref      => ad_ref,

      sz_ref      => sz_ref

      )

   PORT MAP(

      clk_sys     => clk_sys,

      rst_n       => rst_n,

      tid         => tid,

      iid         => iid,

      sync_lock   => sync_lock,

      datout_write=> datout_write,

      datout_read => datout_read,

      ad_out      => ad_out,

      wr_out      => wr_out,

      rd_out      => rd_out,

      activity1   => layer2_eof1,

      activity2   => layer2_eof2,

      datin1      => layer7_rx1,

      socin1      => layer7_soc1,

      rd_datin1   => layer7_rd1,

      new_frame1  => layer7_newframe1,

      com_dispo1  => layer7_comdispo1,

      l7_ok1      => layer7_l7ok1,

      l7_overflow1=> layer7_overflow1,

      datin2      => layer7_rx2,

      socin2      => layer7_soc2,

      rd_datin2   => layer7_rd2,

      new_frame2  => layer7_newframe2,

      com_dispo2  => layer7_comdispo2,

      l7_ok2      => layer7_l7ok2,

      l7_overflow2=> layer7_overflow2,

      datsent     => tx_dat,

      valsent     => val_txdat,

      sof         => tx_sof,

      eof         => tx_eof,

      datsent_free=> txdat_free,

      clr_fifo_tx => clr_fifo_tx,

      copy_ena1   => copy_ena1,

      copy_ena2   => copy_ena2,

      reload_fpgan=> reload_fpgan,

      spitx_dat   => spitx_dat,

      spitx_val   => spitx_val,

      spirx_dat   => spirx_dat,

      spirx_val   => spirx_val,

      spirx_next  => spirx_next,

      spi_typecom => spi_typecom,

      spi_execcom => spi_execcom,

      spi_busy    => spi_busy,

      spi_nbread  => spi_nbread,

      spi_rstn    => spi_rstn

      );

   inst_layer2_tx: layer2_tx

   PORT MAP(

      clk_sys => clk_sys,

      rst_n => rst_n,

      dat_in => tx_dat,

      val_in => val_txdat,

      sof => tx_sof,

      eof => tx_eof,

      datin_free => txdat_free,

      dat_out => layer2_txdat,

      val_out => layer2_txval,

      clr_fifo => clr_fifo_tx,

      progfull1 => layer2_progfull1,

      progfull2 => layer2_progfull2,

      full1     => layer2_full1,

      empty1    => layer1_empty1,

      full2     => layer2_full2,

      empty2    => layer1_empty2

        );

   inst_fifo_tx1 : fifo_tx

   PORT MAP (

      clk =>   clk_sys,

      srst =>  clr_fifo_tx,

      din =>   layer2_txdat,

      wr_en => layer2_txval,

      rd_en => layer1_rd1,

      dout =>  layer1_tx1,

      full =>  layer2_full1,

      empty => layer1_empty1,

      prog_full => layer2_progfull1

   );

   inst_fifo_tx2 : fifo_tx

   PORT MAP (

      clk =>   clk_sys,

      srst =>  clr_fifo_tx,

      din =>   layer2_txdat,

      wr_en => layer2_txval,

      rd_en => layer1_rd2,

      dout =>  layer1_tx2,

      full =>  layer2_full2,

      empty => layer1_empty2,

      prog_full => layer2_progfull2

   );

   inst_flash : if_promspi

   GENERIC MAP (

      div_rate => 3,

      spiclk_freq => 12)

   PORT MAP (

      clk_sys =>  clk_sys,

      rst_n =>    spi_rstn,

      spi_csn =>  spi_csn,

      spi_wpn =>  spi_wpn,

      spi_sdo =>  spi_sdo,

      spi_sdi =>  spi_sdi,

      spi_clk =>  spi_clk,

      tx_dat =>   spitx_dat,

      tx_val =>   spitx_val,

      rx_dat =>   spirx_dat,

      rx_val =>   spirx_val,

      rx_next =>  spirx_next,

      type_com => spi_typecom,

      exec_com => spi_execcom,

      spi_busy => spi_busy,

      nb_read =>  spi_nbread

        );

END rtl;