Changeset 715 for trunk


Ignore:
Timestamp:
Jun 23, 2014, 3:43:33 PM (11 years ago)
Author:
cfuguet
Message:

vci_io_bridge:

  • erasing XICU base and size registers. There registers are not used anymore because routing through INT network is done by using special attribute of IOX mapping segments.
  • bugfix: adding config_cmd_to_config_rsp registers for transmitting SRCID, TRDID and PKTID. Before, r_config_cmd registers were used for transmitting these informations to CONFIG_RSP FSM, but these registers can be simultaneously modified by the CONFIG_CMD FSM.
  • adding a masking table for SRCID in the DMA_CMD FSM. This masking table is used to replace SRCID global bits of commands coming from external DMA peripherals by the IOB cluster global bits. This way, the responses for DMA peripheral commands, will come through the same IOB. In the same manner, the DMA_RSP FSM masks the global bits of RSRCID before sending to DMA external peripherals.
  • introduction of an IO transaction table in the CONFIG_CMD FSM. This table is used to store SRCID and TRDID of incoming commands from the INT network. The SRCID and TRDID of these commands is replaced by the IOB IOX SRCID and table index respectively. The goal is to force that responses to these commands come back trough the same IOB. The CONFIG_RSP FSM restores both SRCID and TRDID by reading the table.
Location:
trunk/modules/vci_io_bridge
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/modules/vci_io_bridge/caba/metadata/vci_io_bridge.sd

    r434 r715  
    55
    66Module('caba:vci_io_bridge',
    7         classname = 'soclib::caba::VciIoBridge',
     7    classname = 'soclib::caba::VciIoBridge',
    88
    9         tmpl_parameters = [
     9    tmpl_parameters = [
    1010        parameter.Module('vci_param_int',
    1111                          default = 'caba:vci_param',
    1212                          cell_size = parameter.Reference('iob_cell_size_int')),
    13             parameter.Module('vci_param_ext',
     13        parameter.Module('vci_param_ext',
    1414                          default = 'caba:vci_param',
    1515                          cell_size = parameter.Reference('iob_cell_size_ext')),
    1616    ],
    1717
    18         header_files =         [
     18    header_files =         [
    1919        '../source/include/vci_io_bridge.h',
    20             '../source/include/transaction_tab_io.h'
     20        '../source/include/transaction_tab_io.h'
    2121    ],
    2222
    23         implementation_files = [ '../source/src/vci_io_bridge.cpp' ],
     23    implementation_files = [ '../source/src/vci_io_bridge.cpp' ],
    2424
    25         uses = [ Uses('caba:base_module'),
    26             Uses('common:mapping_table'),
    27             Uses('caba:generic_fifo'),
    28             Uses('caba:generic_tlb',
    29               addr_t = parameter.StringExt('sc_dt::sc_uint<%d> ', 
     25    uses = [ Uses('caba:base_module'),
     26        Uses('common:mapping_table'),
     27        Uses('caba:generic_fifo'),
     28        Uses('caba:generic_tlb',
     29              addr_t = parameter.StringExt('sc_dt::sc_uint<%d> ',
    3030              parameter.Reference('addr_size'))),
    31             Uses('common:address_decoding_table',
     31        Uses('common:address_decoding_table',
    3232              input_t  = 'unsigned long',
    3333              output_t = 'bool'),
    34             Uses('common:address_decoding_table',
     34        Uses('common:address_decoding_table',
    3535              input_t  = 'unsigned long',
    3636              output_t = 'int'),
    3737    ],
    3838
    39         ports = [
    40               Port('caba:vci_initiator', 'p_vci_ini_ram'),
    41                   Port('caba:vci_target',    'p_vci_tgt_iox'),
    42               Port('caba:vci_initiator', 'p_vci_ini_iox'),
    43                   Port('caba:vci_target',    'p_vci_tgt_int'),
    44               Port('caba:vci_initiator', 'p_vci_ini_int'),
    45                   Port('caba:bit_in','p_irq', 32),
    46                   Port('caba:bit_in', 'p_resetn', auto = 'resetn'),
    47                   Port('caba:clock_in', 'p_clk', auto = 'clock'),
     39    ports = [
     40        Port('caba:vci_initiator', 'p_vci_ini_ram'),
     41        Port('caba:vci_target',    'p_vci_tgt_iox'),
     42        Port('caba:vci_initiator', 'p_vci_ini_iox'),
     43        Port('caba:vci_target',    'p_vci_tgt_int'),
     44        Port('caba:vci_initiator', 'p_vci_ini_int'),
     45        Port('caba:bit_in','p_irq', 32),
     46        Port('caba:bit_in', 'p_resetn', auto = 'resetn'),
     47        Port('caba:clock_in', 'p_clk', auto = 'clock'),
    4848    ],
    4949
    50     instance_parameters = [ 
     50    instance_parameters = [
    5151        parameter.Module('mt_ext', 'common:mapping_table'),
    5252        parameter.Module('mt_int', 'common:mapping_table'),

  • trunk/modules/vci_io_bridge/caba/source/include/transaction_tab_io.h

    r240 r715  
    99#define DEBUG_IOB_TRANSACTION 0
    1010
    11 // The index of Transaction Tab Entry corresponds to the trdid of the VCI packet on XRAM network
    12 
    1311////////////////////////////////////////////////////////////////////////
    1412//                  A transaction tab entry         
    … …  
    1614
    1715class TransactionTabIOEntry {
    18   typedef uint32_t              size_t;
     16  typedef uint32_t size_t;
    1917
    2018 public:
    21   bool                      valid;          // entry valid
    22   size_t                    srcid;          // processor requesting the transaction
    23   size_t                    trdid;          // processor requesting the transaction
     19  bool   valid;          // valid entry
     20  size_t srcid;          // initiator requesting the transaction
     21  size_t trdid;          // thread ID of transaction
    2422
    2523  /////////////////////////////////////////////////////////////////////
    … …  
    2826  void init()
    2927  {
    30     valid               = false;
     28    valid = false;
    3129  }
    3230
    … …  
    3836  void copy(const TransactionTabIOEntry &source)
    3937  {
    40     valid          = source.valid;
    41     srcid          = source.srcid;
    42     trdid          = source.trdid;
     38    valid = source.valid;
     39    srcid = source.srcid;
     40    trdid = source.trdid;
    4341  }
    4442
    … …  
    4745  ////////////////////////////////////////////////////////////////////
    4846  void print(){
    49     std::cout << "valid       = " << valid        << std::endl;
    50     std::cout << "srcid       = " << srcid        << std::endl;
    51     std::cout << "trdid       = " << trdid        << std::endl;
    52   }
    53 
    54   /////////////////////////////////////////////////////////////////////
    55   //            Constructors
     47    std::cout << "   valid = " << valid << std::hex
     48              << " / srcid = " << srcid
     49              << " / trdid = " << trdid << std::dec
     50              << std::endl;
     51  }
     52
     53  /////////////////////////////////////////////////////////////////////
     54  //        Constructors
    5655  /////////////////////////////////////////////////////////////////////
    5756
    5857  TransactionTabIOEntry()
     58  {
     59    valid = false;
     60  }
     61
     62  TransactionTabIOEntry(const TransactionTabIOEntry &source){
     63    valid = source.valid;
     64    srcid = source.srcid;
     65    trdid = source.trdid;
     66  }
     67
     68}; // end class TransactionTabIOEntry
     69
     70////////////////////////////////////////////////////////////////////////
     71//                  The transaction tab                             
     72////////////////////////////////////////////////////////////////////////
     73class TransactionTabIO{
     74 private:
     75  const size_t size_tab;          // The size of the tab
     76
     77 public:
     78  TransactionTabIOEntry *tab;     // The transaction tab
     79
     80  ////////////////////////////////////////////////////////////////////
     81  //        Constructors
     82  ////////////////////////////////////////////////////////////////////
     83  TransactionTabIO(size_t n_entries) : size_tab(n_entries)
     84  {
     85    tab = new TransactionTabIOEntry[size_tab];
     86  }
     87
     88  ~TransactionTabIO()
     89  {
     90    delete [] tab;
     91  }
     92
     93  /////////////////////////////////////////////////////////////////////
     94  // The size() function returns the size of the tab
     95  /////////////////////////////////////////////////////////////////////
     96  const size_t& size()
     97  {
     98    return size_tab;
     99  }
     100
     101  /////////////////////////////////////////////////////////////////////
     102  // The init() function initializes the transaction tab entries
     103  /////////////////////////////////////////////////////////////////////
     104  void init()
     105  {
     106    for ( size_t index = 0; index < size_tab; index++)
    59107    {
    60       valid=false;
     108      tab[index].init();
    61109    }
    62 
    63   TransactionTabIOEntry(const TransactionTabIOEntry &source){
    64     valid           = source.valid;
    65     srcid           = source.srcid;
    66     trdid           = source.trdid;
    67   }
    68 
    69 }; // end class TransactionTabIOEntry
    70 
    71 ////////////////////////////////////////////////////////////////////////
    72 //                  The transaction tab                             
    73 ////////////////////////////////////////////////////////////////////////
    74 class TransactionTabIO{
    75 //  typedef uint32_t size_t;
    76 
    77  private:
    78   size_t size_tab;                // The size of the tab
    79 
    80  public:
    81   TransactionTabIOEntry *tab;       // The transaction tab
    82 
    83   ////////////////////////////////////////////////////////////////////
    84   //            Constructors
    85   ////////////////////////////////////////////////////////////////////
    86   TransactionTabIO()
    87     {
    88       size_tab=0;
    89       tab=NULL;
    90     }
    91 
    92   TransactionTabIO(size_t n_entries)
    93     {
    94       size_tab = n_entries;
    95       tab = new TransactionTabIOEntry[size_tab];
    96     }
    97 
    98   ~TransactionTabIO()
    99     {
    100       delete [] tab;
    101     }
    102 
    103   /////////////////////////////////////////////////////////////////////
    104   // The size() function returns the size of the tab
    105   /////////////////////////////////////////////////////////////////////
    106   size_t size()
    107   {
    108     return size_tab;
    109   }
    110 
    111   /////////////////////////////////////////////////////////////////////
    112   // The init() function initializes the transaction tab entries
    113   /////////////////////////////////////////////////////////////////////
    114   void init()
    115   {
    116     for ( size_t i=0; i<size_tab; i++) {
    117       tab[i].init();
    118     }
    119110  }
    120111
    … …  
    126117  void print(const size_t index)
    127118  {
    128     assert( (index < size_tab)
    129             && "Invalid Transaction Tab Entry");
     119    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
    130120    tab[index].print();
    131121    return;
    … …  
    133123
    134124  /////////////////////////////////////////////////////////////////////
     125  // The printTrace() function prints all transaction tab entries
     126  /////////////////////////////////////////////////////////////////////
     127  void printTrace()
     128  {
     129    for (size_t index = 0; index < size_tab; index++)
     130    {
     131      tab[index].print();
     132    }
     133  }
     134
     135  /////////////////////////////////////////////////////////////////////
    135136  // The read() function returns a transaction tab entry.
    136137  // Arguments :
    137138  // - index : the index of the entry to read
    138139  /////////////////////////////////////////////////////////////////////
    139   TransactionTabIOEntry read(const size_t index)
    140   {
    141     assert( (index < size_tab)
    142             && "Invalid Transaction Tab Entry");
     140  TransactionTabIOEntry& read(const size_t index)
     141  {
     142    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
    143143    return tab[index];
    144144  }
    … …  
    151151  size_t readSrcid(const size_t index)
    152152  {
    153     assert( (index < size_tab)
    154             && "Invalid Transaction Tab Entry");
     153    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
    155154    return tab[index].srcid;
    156155  }
    … …  
    163162  size_t readTrdid(const size_t index)
    164163  {
    165     assert( (index < size_tab)
    166             && "Invalid Transaction Tab Entry");
     164    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
    167165    return tab[index].trdid;
    168166  }
    … …  
    176174  bool full(size_t &index)
    177175  {
    178     for(size_t i=0; i<size_tab; i++){
    179       if(!tab[i].valid){
    180             index=i;
    181             return false;       
     176    for(size_t i=0; i<size_tab; i++)
     177    {
     178      if(!tab[i].valid)
     179      {
     180        index = i;
     181        return false;   
    182182      }
    183183    }
    … …  
    194194  /////////////////////////////////////////////////////////////////////
    195195  void set(const size_t index,
    196            const size_t srcid,
    197            const size_t trdid)
    198   {
    199     assert( (index < size_tab)
    200             && "The selected entry is out of range in set() Transaction Tab");
    201 
    202     tab[index].valid            = true;
    203     tab[index].srcid            = srcid;
    204     tab[index].trdid            = trdid;
     196           const size_t srcid,
     197           const size_t trdid)
     198  {
     199    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
     200    tab[index].valid = true;
     201    tab[index].srcid = srcid;
     202    tab[index].trdid = trdid;
    205203  }
    206204
    … …  
    212210  void erase(const size_t index)
    213211  {
    214     assert( (index < size_tab)
    215             && "The selected entry is out of range in erase() Transaction Tab");
    216     tab[index].valid    = false;
     212    assert( (index < size_tab) && "Invalid Transaction Tab Entry");
     213    tab[index].valid = false;
    217214  }
    218215}; // end class TransactionTabIO
    … …  
    221218
    222219// Local Variables:
    223 // tab-width: 4
    224 // c-basic-offset: 4
     220// tab-width: 2
     221// c-basic-offset: 2
    225222// c-file-offsets:((innamespace . 0)(inline-open . 0))
    226223// indent-tabs-mode: nil
    227224// End:
    228225
    229 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
    230 
     226// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
     227

  • trunk/modules/vci_io_bridge/caba/source/include/vci_io_bridge.h

    r712 r715  
    66 *
    77 * SOCLIB_LGPL_HEADER_BEGIN
    8  * 
     8 *
    99 * This file is part of SoCLib, GNU LGPLv2.1.
    10  * 
     10 *
    1111 * SoCLib is free software; you can redistribute it and/or modify it
    1212 * under the terms of the GNU Lesser General Public License as published
    1313 * by the Free Software Foundation; version 2.1 of the License.
    14  * 
     14 *
    1515 * SoCLib is distributed in the hope that it will be useful, but
    1616 * WITHOUT ANY WARRANTY; without even the implied warranty of
    1717 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    1818 * Lesser General Public License for more details.
    19  * 
     19 *
    2020 * You should have received a copy of the GNU Lesser General Public
    2121 * License along with SoCLib; if not, write to the Free Software
    2222 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    2323 * 02110-1301 USA
    24  * 
     24 *
    2525 * SOCLIB_LGPL_HEADER_END
    2626 */
    … …  
    4444// to a (up to) 40 bits physical address by a standard SoCLib generic TLB.
    4545// In case of TLB MISS, the DMA transaction is stalled until the TLB is updated.
    46 // In case of page fault or read_only violation (illegal access), a VCI error 
     46// In case of page fault or read_only violation (illegal access), a VCI error
    4747// is returned to the faulty peripheral, and a IOMMU WTI is sent.
    4848/////////////////////////////////////////////////////////////////////////////////
    … …  
    6262////////////////////////////////////////////////////////////////////////////////
    6363
    64  
     64
    6565///////TODO List///////////////////////////////////////////////////////////////
    6666// - Ne pas garder tous les champs WRITE CMD dans les FIFO a chaque flit
    … …  
    7777#include "generic_tlb.h"
    7878#include "mapping_table.h"
    79 #include "address_decoding_table.h"
     79#include "address_decoding_table.h"
     80#include "address_masking_table.h"
    8081#include "static_assert.h"
    8182#include "vci_initiator.h"
    8283#include "vci_target.h"
     84#include "transaction_tab_io.h"
    8385#include "../../../include/soclib/io_bridge.h"
    8486
    … …  
    101103    typedef typename vci_param_int::be_t            int_be_t;
    102104
    103     // Other fields must be equal   
    104     typedef typename vci_param_int::fast_addr_t     vci_addr_t; 
    105     typedef typename vci_param_int::srcid_t         vci_srcid_t; 
     105    // Other fields must be equal
     106    typedef typename vci_param_int::fast_addr_t     vci_addr_t;
     107    typedef typename vci_param_int::srcid_t         vci_srcid_t;
    106108    typedef typename vci_param_int::trdid_t         vci_trdid_t;
    107109    typedef typename vci_param_int::pktid_t         vci_pktid_t;
    … …  
    116118    typedef typename vci_param_int::rerror_t        vci_rerror_t;
    117119
    118     enum 
    119     {
    120         CACHE_LINE_MASK    = 0xFFFFFFFFC0LL, 
    121         PPN1_MASK          = 0x0007FFFF, 
    122         PPN2_MASK          = 0x0FFFFFFF, 
    123         K_PAGE_OFFSET_MASK = 0x00000FFF, 
     120    enum
     121    {
     122        CACHE_LINE_MASK    = 0xFFFFFFFFC0LL,
     123        PPN1_MASK          = 0x0007FFFF,
     124        PPN2_MASK          = 0x0FFFFFFF,
     125        K_PAGE_OFFSET_MASK = 0x00000FFF,
    124126        M_PAGE_OFFSET_MASK = 0x001FFFFF,
    125127        PTE2_LINE_OFFSET   = 0x00007000, // bits 12,13,14.
    126         PTE1_LINE_OFFSET   = 0x01E00000, // bits 21,22,23,24 
    127     };
    128  
     128        PTE1_LINE_OFFSET   = 0x01E00000, // bits 21,22,23,24
     129    };
     130
    129131    // States for DMA_CMD FSM (from IOX to RAM)
    130     enum dma_cmd_fsm_state 
    131     { 
     132    enum dma_cmd_fsm_state
     133    {
    132134        DMA_CMD_IDLE,
    133135        DMA_CMD_DMA_REQ,
    … …  
    138140        DMA_CMD_TLB_MISS_WAIT,
    139141    };
    140    
    141     // States for DMA_RSP FSM 
    142     enum dma_rsp_fsm_state 
    143     { 
     142
     143    // States for DMA_RSP FSM
     144    enum dma_rsp_fsm_state
     145    {
    144146        DMA_RSP_IDLE_DMA,
    145147        DMA_RSP_IDLE_WTI,
    … …  
    149151        DMA_RSP_PUT_ERR,
    150152    };
    151    
     153
    152154    // States for TLB_MISS FSM
    153     enum dma_tlb_fsm_state 
    154     {   
     155    enum dma_tlb_fsm_state
     156    {
    155157        TLB_IDLE,
    156158        TLB_MISS,
    … …  
    158160        TLB_PTE1_SELECT,
    159161        TLB_PTE1_UPDT,
    160         TLB_PTE2_GET,                                                 
     162        TLB_PTE2_GET,
    161163        TLB_PTE2_SELECT,
    162164        TLB_PTE2_UPDT,
    … …  
    164166        TLB_RETURN,
    165167        TLB_INVAL_CHECK,
    166         };
    167    
    168     // States for CONFIG_CMD FSM 
    169     enum config_cmd_fsm_state 
    170     { 
     168    };
     169
     170    // States for CONFIG_CMD FSM
     171    enum config_cmd_fsm_state
     172    {
    171173        CONFIG_CMD_IDLE,
    172         CONFIG_CMD_NEXT,
     174        CONFIG_CMD_WAIT,
     175        CONFIG_CMD_HI,
     176        CONFIG_CMD_LO,
    173177        CONFIG_CMD_PUT,
    174178        CONFIG_CMD_RSP,
    175         };
    176    
    177     // states for CONFIG_RSP FSM 
    178     enum config_rsp_fsm_state 
    179     { 
     179    };
     180
     181    // states for CONFIG_RSP FSM
     182    enum config_rsp_fsm_state
     183    {
    180184        CONFIG_RSP_IDLE_IOX,
    181185        CONFIG_RSP_IDLE_LOC,
    182         CONFIG_RSP_PUT_LOW,
     186        CONFIG_RSP_PUT_LO,
    183187        CONFIG_RSP_PUT_HI,
    184188        CONFIG_RSP_PUT_UNC,
    … …  
    186190
    187191    };
    188    
    189     // States for MISS_WTI_RSP FSM 
    190     enum miss_wti_rsp_state 
    191     { 
     192
     193    // States for MISS_WTI_RSP FSM
     194    enum miss_wti_rsp_state
     195    {
    192196        MISS_WTI_RSP_IDLE,
    193197        MISS_WTI_RSP_WTI_IOX,
    194198        MISS_WTI_RSP_WTI_MMU,
    195199        MISS_WTI_RSP_MISS,
    196         };
     200    };
    197201
    198202    // PKTID values for TLB MISS and WTI transactions
    … …  
    203207        PKTID_WTI_MMU = 0xC,  // TSAR code for write
    204208    };
    205    
     209
    206210    // Miss types for iotlb
    207211    enum tlb_miss_type_e
    208212    {
    209         PTE1_MISS, 
     213        PTE1_MISS,
    210214        PTE2_MISS,
    211         };
    212    
     215    };
     216
    213217public:
    214218    sc_in<bool>                               p_clk;
    215219    sc_in<bool>                               p_resetn;
    216    
    217     soclib::caba::VciInitiator<vci_param_ext> p_vci_ini_ram; 
     220
     221    soclib::caba::VciInitiator<vci_param_ext> p_vci_ini_ram;
    218222
    219223    soclib::caba::VciTarget<vci_param_ext>    p_vci_tgt_iox;
    … …  
    224228
    225229private:
    226     const size_t                                  m_words;
     230    const size_t                              m_words;
    227231
    228232    // INT & IOX Networks
    229233    std::list<soclib::common::Segment>        m_int_seglist;
    230     const vci_srcid_t                             m_int_srcid;      // SRCID on INT network
     234    const vci_srcid_t                         m_int_srcid;      // SRCID on INT network
    231235    std::list<soclib::common::Segment>        m_iox_seglist;
     236    const vci_srcid_t                         m_iox_srcid;      // SRCID on IOX network
     237
     238    // INT & RAM srcid masking table
     239    const AddressMaskingTable<uint32_t>       m_srcid_gid_mask;
     240    const AddressMaskingTable<uint32_t>       m_srcid_lid_mask;
    232241
    233242    // TLB parameters
    234     const size_t                                                  m_iotlb_ways;
    235     const size_t                                                  m_iotlb_sets;
    236 
    237     // debug variables 
     243    const size_t                              m_iotlb_ways;
     244    const size_t                              m_iotlb_sets;
     245
     246    // debug variables
    238247    uint32_t                                  m_debug_start_cycle;
    239248    bool                                      m_debug_ok;
    … …  
    247256    sc_signal<uint32_t>         r_iommu_bvar;           // bad vaddr
    248257    sc_signal<uint32_t>         r_iommu_etr;            // error type
    249     sc_signal<uint32_t>         r_iommu_bad_id;         // faulty srcid 
    250     sc_signal<bool>             r_iommu_wti_enable;     // enable IOB WTI 
     258    sc_signal<uint32_t>         r_iommu_bad_id;         // faulty srcid
     259    sc_signal<bool>             r_iommu_wti_enable;     // enable IOB WTI
    251260    sc_signal<uint32_t>         r_iommu_wti_addr_lo;    // IOMMU WTI paddr (32 lsb)
    252261    sc_signal<uint32_t>         r_iommu_wti_addr_hi;    // IOMMU WTI paddr (32 msb)
    253262
    254     sc_signal<uint32_t>         r_xicu_base;            // XICU paddr base (cluster 0)
    255     sc_signal<uint32_t>         r_xicu_size;            // XIXU paddr size (cluster 0)
    256  
    257         ///////////////////////////////////
     263    ///////////////////////////////////
    258264    // DMA_CMD FSM REGISTERS
    259265    ///////////////////////////////////
    260     sc_signal<int>              r_dma_cmd_fsm;         
     266    sc_signal<int>              r_dma_cmd_fsm;
    261267    sc_signal<vci_addr_t>       r_dma_cmd_paddr;                // output paddr
    262268
    … …  
    275281    sc_signal<vci_rerror_t>     r_dma_cmd_to_dma_rsp_rerror;
    276282    sc_signal<ext_data_t>       r_dma_cmd_to_dma_rsp_rdata;
    277      
     283
    278284    sc_signal<bool>             r_dma_cmd_to_tlb_req;
    279     sc_signal<uint32_t>         r_dma_cmd_to_tlb_vaddr;         // input vaddr 
     285    sc_signal<uint32_t>         r_dma_cmd_to_tlb_vaddr;         // input vaddr
    280286
    281287    ///////////////////////////////////
    … …  
    283289    ///////////////////////////////////
    284290    sc_signal<int>              r_dma_rsp_fsm;
    285    
     291
    286292    ///////////////////////////////////
    287293    // CONFIG_CMD FSM REGISTERS
    … …  
    294300    sc_signal<bool>             r_config_cmd_to_config_rsp_req;
    295301    sc_signal<bool>             r_config_cmd_to_config_rsp_rerror;
    296     sc_signal<uint32_t>         r_config_cmd_to_config_rsp_rdata;
     302    sc_signal<int_data_t>       r_config_cmd_to_config_rsp_rdata;
     303    sc_signal<vci_srcid_t>      r_config_cmd_to_config_rsp_rsrcid;
     304    sc_signal<vci_trdid_t>      r_config_cmd_to_config_rsp_rtrdid;
     305    sc_signal<vci_pktid_t>      r_config_cmd_to_config_rsp_rpktid;
    297306
    298307    sc_signal<ext_data_t>       r_config_cmd_wdata;
    … …  
    301310    sc_signal<vci_addr_t>       r_config_cmd_address;
    302311    sc_signal<vci_srcid_t>      r_config_cmd_srcid;
     312    sc_signal<vci_trdid_t>      r_config_cmd_trdid;
    303313    sc_signal<vci_pktid_t>      r_config_cmd_pktid;
    304     sc_signal<vci_trdid_t>      r_config_cmd_trdid;
    305314    sc_signal<vci_plen_t>       r_config_cmd_plen;
    306315    sc_signal<vci_clen_t>       r_config_cmd_clen;
    … …  
    311320    sc_signal<vci_eop_t>        r_config_cmd_eop;
    312321
     322    TransactionTabIO            m_iox_transaction_tab;
     323
    313324    ///////////////////////////////////
    314325    // CONFIG_RSP FSM REGISTERS
    315326    ///////////////////////////////////
    316327    sc_signal<int>              r_config_rsp_fsm;
     328    sc_signal<vci_srcid_t>      r_config_rsp_rsrcid;
     329    sc_signal<vci_trdid_t>      r_config_rsp_rtrdid;
    317330
    318331    ///////////////////////////////////
    319332    // TLB FSM REGISTERS
    320333    ///////////////////////////////////
    321     sc_signal<int>              r_tlb_fsm;                          // state register
     334    sc_signal<int>              r_tlb_fsm;                  // state register
    322335    sc_signal<bool>             r_waiting_transaction;      // Flag for returning from
    323336    sc_signal<int>              r_tlb_miss_type;
    324         sc_signal<bool>             r_tlb_miss_error;
    325 
    326     sc_signal<vci_addr_t>       r_tlb_paddr;                    // physical address of pte
    327     sc_signal<uint32_t>         r_tlb_pte_flags;                // pte1 or first word of pte2
    328     sc_signal<uint32_t>         r_tlb_pte_ppn;              // second word of pte2
    329     sc_signal<size_t>           r_tlb_way;                          // selected way in tlb   
    330     sc_signal<size_t>           r_tlb_set;                          // selected set in tlb   
     337    sc_signal<bool>             r_tlb_miss_error;
     338
     339    sc_signal<vci_addr_t>       r_tlb_paddr;                // physical address of pte
     340    sc_signal<uint32_t>         r_tlb_pte_flags;            // pte1 or first word of pte2
     341    sc_signal<uint32_t>         r_tlb_pte_ppn;              // second word of pte2
     342    sc_signal<size_t>           r_tlb_way;                  // selected way in tlb
     343    sc_signal<size_t>           r_tlb_set;                  // selected set in tlb
    331344
    332345    uint32_t*                   r_tlb_buf_data;             // prefetch buffer for PTEs
    333346    sc_signal<bool>             r_tlb_buf_valid;            // one valit flag for all PTEs
    334     sc_signal<vci_addr_t>       r_tlb_buf_tag;              // cache line number 
    335     sc_signal<vci_addr_t>       r_tlb_buf_vaddr;            // vaddr for first PTE 
     347    sc_signal<vci_addr_t>       r_tlb_buf_tag;              // cache line number
     348    sc_signal<vci_addr_t>       r_tlb_buf_vaddr;            // vaddr for first PTE
    336349    sc_signal<bool>             r_tlb_buf_big_page;         // ???
    337350
    … …  
    352365    sc_signal<vci_pktid_t>      r_miss_wti_rsp_to_dma_rsp_rpktid;
    353366
    354    
     367
    355368    /////////////////////////////////////////////////////
    356369    //  ALLOCATORS for CONFIG_RSP fifo & DMA_RSP fifo
    357370    /////////////////////////////////////////////////////
    358     sc_signal<bool>             r_alloc_fifo_config_rsp_local; 
    359 
    360    
     371    sc_signal<bool>             r_alloc_fifo_config_rsp_local;
     372
     373
    361374    //////////////////////////////////////////////////////////////////
    362     // IOTLB 
     375    // IOTLB
    363376    //////////////////////////////////////////////////////////////////
    364377    GenericTlb<vci_addr_t>      r_iotlb;
    365        
    366    
     378
     379
    367380    /////////////////////////
    368381    // FIFOs
    … …  
    392405    GenericFifo<vci_eop_t>      m_dma_rsp_reop_fifo;
    393406    GenericFifo<vci_rerror_t>   m_dma_rsp_rerror_fifo;
    394        
     407
    395408    // output FIFO to VCI INI port on IOX network (VCI command)
    396409    GenericFifo<vci_addr_t>     m_config_cmd_addr_fifo;
    … …  
    408421    GenericFifo<vci_cfixed_t>   m_config_cmd_cfixed_fifo;
    409422    GenericFifo<vci_clen_t>     m_config_cmd_clen_fifo;
    410    
    411     // output FIFO to VCI TGT port on INT network (VCI response) 
     423
     424    // output FIFO to VCI TGT port on INT network (VCI response)
    412425    GenericFifo<int_data_t>     m_config_rsp_data_fifo;
    413426    GenericFifo<vci_srcid_t>    m_config_rsp_rsrcid_fifo;
    … …  
    416429    GenericFifo<vci_eop_t>      m_config_rsp_reop_fifo;
    417430    GenericFifo<vci_rerror_t>   m_config_rsp_rerror_fifo;
    418        
     431
    419432    // output FIFO to VCI_INI port on INT network (VCI command)
    420433    GenericFifo<vci_addr_t>     m_miss_wti_cmd_addr_fifo;
    … …  
    432445    GenericFifo<vci_cfixed_t>   m_miss_wti_cmd_cfixed_fifo;
    433446    GenericFifo<vci_clen_t>     m_miss_wti_cmd_clen_fifo;
    434    
     447
    435448    ////////////////////////////////
    436449    // Activity counters
    437450    ////////////////////////////////
    438    
     451
    439452    uint32_t m_cpt_total_cycles;            // total number of cycles
    440    
     453
    441454    // TLB activity counters
    442455    uint32_t m_cpt_iotlb_read;              // number of iotlb read
    443456    uint32_t m_cpt_iotlb_miss;              // number of iotlb miss
    444457    uint32_t m_cost_iotlb_miss;             // number of wait cycles (not treatment itself)
    445     uint32_t m_cpt_iotlbmiss_transaction;   // number of tlb miss transactions 
     458    uint32_t m_cpt_iotlbmiss_transaction;   // number of tlb miss transactions
    446459    uint32_t m_cost_iotlbmiss_transaction;  // cumulated duration tlb miss transactions
    447460
    … …  
    454467    // FSM activity counters
    455468    // unused on print_stats
    456     uint32_t m_cpt_fsm_dma_cmd          [32]; 
    457     uint32_t m_cpt_fsm_dma_rsp          [32]; 
    458     uint32_t m_cpt_fsm_tlb              [32]; 
    459     uint32_t m_cpt_fsm_config_cmd       [32]; 
    460     uint32_t m_cpt_fsm_config_rsp       [32]; 
     469    uint32_t m_cpt_fsm_dma_cmd          [32];
     470    uint32_t m_cpt_fsm_dma_rsp          [32];
     471    uint32_t m_cpt_fsm_tlb              [32];
     472    uint32_t m_cpt_fsm_config_cmd       [32];
     473    uint32_t m_cpt_fsm_config_rsp       [32];
    461474    uint32_t m_cpt_fsm_miss_wti_rsp     [32];
    462  
     475
    463476protected:
    464477
    … …  
    468481
    469482    VciIoBridge(
    470         sc_module_name insname,
    471         const    soclib::common::MappingTable  &mt_ext,      // external network
    472         const    soclib::common::MappingTable  &mt_int,      // internal network
    473         const    soclib::common::MappingTable  &mt_iox,      // iox network
    474         const    soclib::common::IntTab        &int_tgtid,   // INT network TGTID
    475         const    soclib::common::IntTab        &int_srcid,   // INT network SRCID
    476         const    soclib::common::IntTab        &iox_tgtid,   // IOX network TGTID
    477         const    size_t                        dcache_words,
    478         const    size_t                        iotlb_ways,
    479         const    size_t                        iotlb_sets,
    480         const    uint32_t                      debug_start_cycle,
    481         const    bool                          debug_ok );
     483        sc_module_name                      insname,
     484        const soclib::common::MappingTable  &mt_ext,      // external network
     485        const soclib::common::MappingTable  &mt_int,      // internal network
     486        const soclib::common::MappingTable  &mt_iox,      // iox network
     487        const soclib::common::IntTab        &int_tgtid,   // INT network TGTID
     488        const soclib::common::IntTab        &int_srcid,   // INT network SRCID
     489        const soclib::common::IntTab        &iox_tgtid,   // IOX network TGTID
     490        const soclib::common::IntTab        &iox_srcid,   // IOX network SRCID
     491        const size_t                        dcache_words,
     492        const size_t                        iotlb_ways,
     493        const size_t                        iotlb_sets,
     494        const uint32_t                      debug_start_cycle,
     495        const bool                          debug_ok );
    482496
    483497    ~VciIoBridge();
    … …  
    486500    void clear_stats();
    487501    void print_trace(size_t mode = 0);
    488    
     502
    489503
    490504private:

  • trunk/modules/vci_io_bridge/caba/source/src/vci_io_bridge.cpp

    r713 r715  
    55 *
    66 * SOCLIB_LGPL_HEADER_BEGIN
    7  * 
     7 *
    88 * This file is part of SoCLib, GNU LGPLv2.1.
    9  * 
     9 *
    1010 * SoCLib is free software; you can redistribute it and/or modify it
    1111 * under the terms of the GNU Lesser General Public License as published
    1212 * by the Free Software Foundation; version 2.1 of the License.
    13  * 
     13 *
    1414 * SoCLib is distributed in the hope that it will be useful, but
    1515 * WITHOUT ANY WARRANTY; without even the implied warranty of
    1616 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    1717 * Lesser General Public License for more details.
    18  * 
     18 *
    1919 * You should have received a copy of the GNU Lesser General Public
    2020 * License along with SoCLib; if not, write to the Free Software
    2121 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    2222 * 02110-1301 USA
    23  * 
     23 *
    2424 * SOCLIB_LGPL_HEADER_END
    2525 */
    … …  
    3838/////////////////////////////////////////////////////////////////////////////////
    3939
    40 #define DEBUG_DMA_CMD           1
    41 #define DEBUG_DMA_RSP           1
    42 #define DEBUG_TLB_MISS          1
    43 #define DEBUG_CONFIG_CMD                1
    44 #define DEBUG_CONFIG_RSP                1
    45 #define DEBUG_MISS_WTI_CMD      1
    46 
    47 namespace soclib { 
     40#define DEBUG_DMA_CMD           1
     41#define DEBUG_DMA_RSP           1
     42#define DEBUG_TLB_MISS          1
     43#define DEBUG_CONFIG_CMD        1
     44#define DEBUG_CONFIG_RSP        1
     45#define DEBUG_MISS_WTI_CMD      1
     46
     47namespace soclib {
    4848namespace caba {
    4949
    5050namespace {
    5151
    52 const char *dma_cmd_fsm_state_str[] = 
     52const char *dma_cmd_fsm_state_str[] =
    5353    {
    5454        "DMA_CMD_IDLE",
    … …  
    6161    };
    6262
    63 const char *dma_rsp_fsm_state_str[] = 
     63const char *dma_rsp_fsm_state_str[] =
    6464    {
    6565        "DMA_RSP_IDLE_DMA",
    … …  
    7171    };
    7272
    73 const char *tlb_fsm_state_str[] = 
     73const char *tlb_fsm_state_str[] =
    7474    {
    7575        "TLB_IDLE",
    … …  
    7878        "TLB_PTE1_SELECT",
    7979        "TLB_PTE1_UPDT",
    80         "TLB_PTE2_GET",                                                 
     80        "TLB_PTE2_GET",
    8181        "TLB_PTE2_SELECT",
    8282        "TLB_PTE2_UPDT",
    … …  
    8686    };
    8787
    88 const char *config_cmd_fsm_state_str[] = 
     88const char *config_cmd_fsm_state_str[] =
    8989    {
    9090        "CONFIG_CMD_IDLE",
    91         "CONFIG_CMD_NEXT",
     91        "CONFIG_CMD_HI",
     92        "CONFIG_CMD_LO",
    9293        "CONFIG_CMD_PUT",
    9394        "CONFIG_CMD_RSP",
    9495    };
    9596
    96 const char *config_rsp_fsm_state_str[] = 
     97const char *config_rsp_fsm_state_str[] =
    9798    {
    9899        "CONFIG_RSP_IDLE_IOX",
    99100        "CONFIG_RSP_IDLE_LOC",
    100         "CONFIG_RSP_PUT_LOW",
    101         "CONFIG_RSP_PUT_HI", 
    102         "CONFIG_RSP_PUT_UNC", 
    103         "CONFIG_RSP_PUT_LOC", 
     101        "CONFIG_RSP_PUT_LO",
     102        "CONFIG_RSP_PUT_HI",
     103        "CONFIG_RSP_PUT_UNC",
     104        "CONFIG_RSP_PUT_LOC",
    104105    };
    105106
    106 const char *miss_wti_rsp_state_str[] = 
    107     { 
     107const char *miss_wti_rsp_state_str[] =
     108    {
    108109        "MISS_WTI_RSP_IDLE",
    109110        "MISS_WTI_RSP_WTI_IOX",
    … …  
    117118////////////////////////
    118119tmpl(/**/)::VciIoBridge(
    119     sc_module_name                                  name,
    120     const soclib::common::MappingTable  &mt_ext,
    121     const soclib::common::MappingTable  &mt_int,
    122     const soclib::common::MappingTable  &mt_iox,
    123     const soclib::common::IntTab            &int_tgtid,     // INT network TGTID
    124     const soclib::common::IntTab            &int_srcid,     // INT network SRCID
    125     const soclib::common::IntTab            &iox_tgtid,     // IOX network TGTID
     120    sc_module_name                      name,
     121    const soclib::common::MappingTable  &mt_ext,
     122    const soclib::common::MappingTable  &mt_int,
     123    const soclib::common::MappingTable  &mt_iox,
     124    const soclib::common::IntTab        &int_tgtid,     // INT network TGTID
     125    const soclib::common::IntTab        &int_srcid,     // INT network SRCID
     126    const soclib::common::IntTab        &iox_tgtid,     // IOX network TGTID
     127    const soclib::common::IntTab        &iox_srcid,     // IOX network SRCID
    126128    const size_t                        dcache_words,
    127     const size_t                                        iotlb_ways,
    128     const size_t                                        iotlb_sets,
    129     const uint32_t                                      debug_start_cycle,
    130     const bool                                      debug_ok)
     129    const size_t                        iotlb_ways,
     130    const size_t                        iotlb_sets,
     131    const uint32_t                      debug_start_cycle,
     132    const bool                          debug_ok)
    131133    : soclib::caba::BaseModule(name),
    132134
    … …  
    143145      // INT & IOX Network
    144146      m_int_seglist( mt_int.getSegmentList( int_tgtid )),
    145       m_int_srcid( mt_int.indexForId( int_srcid )), 
     147      m_int_srcid( mt_int.indexForId( int_srcid )),
    146148      m_iox_seglist( mt_iox.getSegmentList( iox_tgtid )),
     149      m_iox_srcid( mt_iox.indexForId( iox_srcid )),
     150
     151      m_srcid_gid_mask( mt_int.getSrcidLevelBits()[0],  // use global bits
     152                        mt_int.getSrcidLevelBits()[1]), // drop local bits
     153      m_srcid_lid_mask( mt_int.getSrcidLevelBits()[1],  // use local bits
     154                        0),
    147155
    148156      m_iotlb_ways(iotlb_ways),
    … …  
    176184      r_dma_cmd_to_dma_rsp_rtrdid("r_dma_cmd_to_dma_rsp_rtrdid"),
    177185      r_dma_cmd_to_dma_rsp_rpktid("r_dma_cmd_to_dma_rsp_rpktid"),
    178      
     186
    179187      r_dma_cmd_to_tlb_req("r_dma_cmd_to_tlb_req"),
    180188      r_dma_cmd_to_tlb_vaddr("r_dma_cmd_to_tlb_vaddr"),
    181      
     189
    182190      //DMA_RSP FSM registers
    183191      r_dma_rsp_fsm("r_dma_rsp_fsm"),
    184192
    185       // CONFIG_CMD FSM registers 
     193      // CONFIG_CMD FSM registers
    186194      r_config_cmd_fsm("r_config_cmd_fsm"),
    187195
    … …  
    192200      r_config_cmd_to_config_rsp_rerror("r_config_cmd_to_config_rsp_rerror"),
    193201      r_config_cmd_to_config_rsp_rdata("r_config_cmd_to_config_rsp_rdata"),
     202      r_config_cmd_to_config_rsp_rsrcid("r_config_cmd_to_config_rsp_rsrcid"),
     203      r_config_cmd_to_config_rsp_rtrdid("r_config_cmd_to_config_rsp_rtrdid"),
     204      r_config_cmd_to_config_rsp_rpktid("r_config_cmd_to_config_rsp_rpktid"),
    194205
    195206      r_config_cmd_wdata("r_config_cmd_wdata"),
    … …  
    198209      r_config_cmd_address("r_config_cmd_address"),
    199210      r_config_cmd_srcid("r_config_cmd_srcid"),
     211      r_config_cmd_trdid("r_config_cmd_trdid"),
    200212      r_config_cmd_pktid("r_config_cmd_pktid"),
    201       r_config_cmd_trdid("r_config_cmd_trdid"),
    202213      r_config_cmd_plen("r_config_cmd_plen"),
    203214      r_config_cmd_clen("r_config_cmd_clen"),
    … …  
    208219      r_config_cmd_eop("r_config_cmd_eop"),
    209220
    210       // CONFIG_RSP FSM registers 
     221      // ID translation table used by CONFIG_CMD and CONFIG_RSP FSMs
     222      m_iox_transaction_tab(1),
     223
     224      // CONFIG_RSP FSM registers
    211225      r_config_rsp_fsm("r_config_rsp_fsm"),
     226      r_config_rsp_rsrcid("r_config_rsp_rsrcid"),
     227      r_config_rsp_rtrdid("r_config_rsp_rtrdid"),
    212228
    213229      // TLB FSM registers
    … …  
    217233      r_tlb_miss_error("r_tlb_miss_error"),
    218234
    219       r_tlb_paddr("r_tlb_paddr"),               
     235      r_tlb_paddr("r_tlb_paddr"),
    220236      r_tlb_pte_flags("r_tlb_pte_flags"),
    221237      r_tlb_pte_ppn("r_tlb_pte_ppn"),
    222238      r_tlb_way("r_tlb_way"),
    223       r_tlb_set("r_tlb_set"), 
    224    
     239      r_tlb_set("r_tlb_set"),
     240
    225241      r_tlb_buf_valid("r_tlb_buf_valid"),
    226242      r_tlb_buf_tag("r_tlb_buf_tag"),
    … …  
    231247
    232248      // MISS_WTI_RSP FSM registers
    233       r_miss_wti_rsp_fsm("r_miss_wti_rsp_fsm"), 
     249      r_miss_wti_rsp_fsm("r_miss_wti_rsp_fsm"),
    234250      r_miss_wti_rsp_error_wti("r_miss_wti_rsp_error_wti"),
    235251      r_miss_wti_rsp_error_miss("r_miss_wti_rsp_error_miss"),
    … …  
    244260      // TLB for IOMMU
    245261      r_iotlb("iotlb", 0, iotlb_ways, iotlb_sets, vci_param_int::N),
    246      
     262
    247263      // DMA_CMD FIFOs
    248264      m_dma_cmd_addr_fifo("m_dma_cmd_addr_fifo",2),
    249       m_dma_cmd_srcid_fifo("m_dma_cmd_srcid_fifo",2), 
    250       m_dma_cmd_trdid_fifo("m_dma_cmd_trdid_fifo",2), 
    251       m_dma_cmd_pktid_fifo("m_dma_cmd_pktid_fifo",2), 
    252       m_dma_cmd_be_fifo("m_dma_cmd_be_fifo",2), 
    253       m_dma_cmd_cmd_fifo("m_dma_cmd_cmd_fifo",2), 
    254       m_dma_cmd_contig_fifo("m_dma_cmd_contig_fifo",2), 
    255       m_dma_cmd_data_fifo("m_dma_cmd_data_fifo",2), 
     265      m_dma_cmd_srcid_fifo("m_dma_cmd_srcid_fifo",2),
     266      m_dma_cmd_trdid_fifo("m_dma_cmd_trdid_fifo",2),
     267      m_dma_cmd_pktid_fifo("m_dma_cmd_pktid_fifo",2),
     268      m_dma_cmd_be_fifo("m_dma_cmd_be_fifo",2),
     269      m_dma_cmd_cmd_fifo("m_dma_cmd_cmd_fifo",2),
     270      m_dma_cmd_contig_fifo("m_dma_cmd_contig_fifo",2),
     271      m_dma_cmd_data_fifo("m_dma_cmd_data_fifo",2),
    256272      m_dma_cmd_eop_fifo("m_dma_cmd_eop_fifo",2),
    257       m_dma_cmd_cons_fifo("m_dma_cmd_cons_fifo",2), 
    258       m_dma_cmd_plen_fifo("m_dma_cmd_plen_fifo",2), 
    259       m_dma_cmd_wrap_fifo("m_dma_cmd_wrap_fifo",2), 
     273      m_dma_cmd_cons_fifo("m_dma_cmd_cons_fifo",2),
     274      m_dma_cmd_plen_fifo("m_dma_cmd_plen_fifo",2),
     275      m_dma_cmd_wrap_fifo("m_dma_cmd_wrap_fifo",2),
    260276      m_dma_cmd_cfixed_fifo("m_dma_cmd_cfixed_fifo",2),
    261       m_dma_cmd_clen_fifo("m_dma_cmd_clen_fifo",2), 
     277      m_dma_cmd_clen_fifo("m_dma_cmd_clen_fifo",2),
    262278
    263279      // DMA_RSP FIFOs
    … …  
    268284      m_dma_rsp_reop_fifo("m_dma_rsp_reop_fifo",2),
    269285      m_dma_rsp_rerror_fifo("m_dma_rsp_rerror_fifo",2),
    270  
     286
    271287      // CONFIG_CMD FIFOs
    272288      m_config_cmd_addr_fifo("m_config_cmd_addr_fifo",2),
    … …  
    286302
    287303      // CONFIG_RSP FIFOs
    288       m_config_rsp_data_fifo("m_config_rsp_data_fifo",2),     
     304      m_config_rsp_data_fifo("m_config_rsp_data_fifo",2),
    289305      m_config_rsp_rsrcid_fifo("m_config_rsp_rsrcid_fifo",2),
    290306      m_config_rsp_rtrdid_fifo("m_config_rsp_rtrdid_fifo",2),
    … …  
    311327    std::cout << "  - Building VciIoBridge : " << name << std::endl;
    312328
    313     // checking segments on INT network 
     329    // checking segments on INT network
    314330    assert ( ( not m_int_seglist.empty() ) and
    315331    "VCI_IO_BRIDGE ERROR : no segment allocated on INT network");
    … …  
    320336        std::cout << "    => segment " << int_seg->name()
    321337                  << " / base = " << std::hex << int_seg->baseAddress()
    322                   << " / size = " << int_seg->size() 
    323                   << " / special = " << int_seg->special() << std::endl; 
    324     }
    325 
    326     // checking segments on IOX network 
     338                  << " / size = " << int_seg->size()
     339                  << " / special = " << int_seg->special() << std::endl;
     340    }
     341
     342    // checking segments on IOX network
    327343    assert ( ( not m_iox_seglist.empty() ) and
    328344    "VCI_IO_BRIDGE ERROR : no segment allocated on IOX network");
    … …  
    333349        std::cout << "    => segment " << iox_seg->name()
    334350                  << " / base = " << std::hex << iox_seg->baseAddress()
    335                   << " / size = " << iox_seg->size() << std::endl; 
    336     }
    337 
    338     assert( (vci_param_int::N == vci_param_ext::N) and 
     351                  << " / size = " << iox_seg->size() << std::endl;
     352    }
     353
     354    assert( (vci_param_int::N == vci_param_ext::N) and
    339355    "VCI_IO_BRIDGE ERROR: VCI ADDRESS widths must be equal on the 3 networks");
    340356
    … …  
    343359
    344360    assert( (vci_param_int::B == 4) and
    345     "VCI_IO_BRIDGE ERROR: VCI DATA width must be 32 bits on internal network");   
     361    "VCI_IO_BRIDGE ERROR: VCI DATA width must be 32 bits on internal network");
    346362
    347363    assert( (vci_param_ext::B == 8) and
    348     "VCI_IO_BRIDGE ERROR: VCI DATA width must be 64 bits on external network");   
     364    "VCI_IO_BRIDGE ERROR: VCI DATA width must be 64 bits on external network");
    349365
    350366    assert( (vci_param_int::S == vci_param_ext::S) and
    … …  
    357373    dont_initialize();
    358374    sensitive << p_clk.pos();
    359  
     375
    360376    SC_METHOD(genMoore);
    361377    dont_initialize();
    … …  
    392408        r_iotlb.printTrace();
    393409    }
     410
     411    if(mode & 0x02)
     412    {
     413        std::cout << "  IOX TRANSACTION TAB" << std::endl;
     414        m_iox_transaction_tab.printTrace();
     415    }
    394416}
    395417
    … …  
    398420////////////////////////
    399421{
    400     std::cout << name() << std::endl
    401         << "- IOTLB MISS RATE      = " << (float)m_cpt_iotlb_miss/m_cpt_iotlb_read << std::endl
    402         << "- IOTLB MISS COST         = " << (float)m_cost_iotlb_miss/m_cpt_iotlb_miss << std::endl
    403         << "- IOTLB MISS TRANSACTION COST  = " << (float)m_cost_iotlbmiss_transaction/m_cpt_iotlbmiss_transaction << std::endl
    404         << "- IOTLB MISS TRANSACTION RATE (OVER ALL MISSES)  = " << (float)m_cpt_iotlbmiss_transaction/m_cpt_iotlb_miss << std::endl;
     422    std::cout << name()
     423        << "\n- IOTLB MISS RATE                                = "
     424        << (float)m_cpt_iotlb_miss/m_cpt_iotlb_read
     425        << "\n- IOTLB MISS COST                                = "
     426        << (float)m_cost_iotlb_miss/m_cpt_iotlb_miss
     427        << "\n- IOTLB MISS TRANSACTION COST                    = "
     428        << (float)m_cost_iotlbmiss_transaction/m_cpt_iotlbmiss_transaction
     429        << "\n- IOTLB MISS TRANSACTION RATE (OVER ALL MISSES)  = "
     430        << (float)m_cpt_iotlbmiss_transaction/m_cpt_iotlb_miss
     431        << std::endl;
    405432}
    406433
    … …  
    409436////////////////////////
    410437{
    411     m_cpt_iotlb_read                = 0;             
    412     m_cpt_iotlb_miss                = 0;             
     438    m_cpt_iotlb_read                = 0;
     439    m_cpt_iotlb_miss                = 0;
    413440    m_cost_iotlb_miss               = 0;
    414     m_cpt_iotlbmiss_transaction     = 0;   
    415     m_cost_iotlbmiss_transaction    = 0;   
     441    m_cpt_iotlbmiss_transaction     = 0;
     442    m_cost_iotlbmiss_transaction    = 0;
    416443}
    417444
    … …  
    420447////////////////////////////////////
    421448{
    422     uint32_t addr32 = (uint32_t)paddr;
    423     uint32_t base   = r_xicu_base.read();
    424     uint32_t size   = r_xicu_size.read();
    425     return ( (addr32 >= base) and (addr32 < (base + size)) );
     449    std::list<soclib::common::Segment>::iterator seg;
     450    for ( seg  = m_iox_seglist.begin() ;
     451          seg != m_iox_seglist.end()   ;
     452          seg++ )
     453    {
     454        if ( seg->contains(paddr) ) return seg->special();
     455    }
     456    return false;
    426457}
    427458
    … …  
    430461/////////////////////////
    431462{
    432     if ( not p_resetn.read() ) 
    433     {
    434         r_dma_cmd_fsm      = DMA_CMD_IDLE;
    435         r_dma_rsp_fsm      = DMA_RSP_IDLE_DMA;
    436         r_tlb_fsm              = TLB_IDLE;
     463    if ( not p_resetn.read() )
     464    {
     465        r_dma_cmd_fsm      = DMA_CMD_IDLE;
     466        r_dma_rsp_fsm      = DMA_RSP_IDLE_DMA;
     467        r_tlb_fsm          = TLB_IDLE;
    437468        r_config_cmd_fsm   = CONFIG_CMD_IDLE;
    438469        r_config_rsp_fsm   = CONFIG_RSP_IDLE_IOX;
    439470        r_miss_wti_rsp_fsm = MISS_WTI_RSP_IDLE;
    440471
    441         r_tlb_buf_valid    = false; 
    442                 r_iommu_active     = false;
    443                 r_iommu_wti_enable = false;
    444 
    445         r_xicu_size        = 0;
    446         r_xicu_base        = 0;
     472        r_tlb_buf_valid    = false;
     473        r_iommu_active     = false;
     474        r_iommu_wti_enable = false;
     475
     476        // initializing translation table
     477        m_iox_transaction_tab.init();
    447478
    448479        // initializing FIFOs
    … …  
    461492        m_dma_cmd_cfixed_fifo.init();
    462493        m_dma_cmd_clen_fifo.init();
    463        
     494
    464495        m_dma_rsp_rsrcid_fifo.init();
    465496        m_dma_rsp_rtrdid_fifo.init();
    … …  
    468499        m_dma_rsp_rerror_fifo.init();
    469500        m_dma_rsp_reop_fifo.init();
    470        
     501
    471502        m_config_cmd_addr_fifo.init();
    472503        m_config_cmd_srcid_fifo.init();
    … …  
    483514        m_config_cmd_cfixed_fifo.init();
    484515        m_config_cmd_clen_fifo.init();
    485        
     516
    486517        m_miss_wti_cmd_addr_fifo.init();
    487518        m_miss_wti_cmd_srcid_fifo.init();
    … …  
    498529        m_miss_wti_cmd_cfixed_fifo.init();
    499530        m_miss_wti_cmd_clen_fifo.init();
    500        
     531
    501532        m_config_rsp_rsrcid_fifo.init();
    502533        m_config_rsp_rtrdid_fifo.init();
    … …  
    505536        m_config_rsp_rerror_fifo.init();
    506537        m_config_rsp_reop_fifo.init();
    507        
    508         // SET/RESET Communication flip-flops 
     538
     539        // SET/RESET Communication flip-flops
    509540        r_dma_cmd_to_miss_wti_cmd_req  = false;
    510541        r_dma_cmd_to_dma_rsp_req       = false;
    511         r_dma_cmd_to_tlb_req               = false;
    512         r_config_cmd_to_tlb_req            = false;
     542        r_dma_cmd_to_tlb_req           = false;
     543        r_config_cmd_to_tlb_req        = false;
    513544        r_config_cmd_to_config_rsp_req = false;
    514545        r_tlb_to_miss_wti_cmd_req      = false;
    … …  
    520551
    521552        // Debug variable
    522                 m_debug_activated                  = false;
    523        
    524             // activity counters
    525             m_cpt_total_cycles             = 0;
    526         m_cpt_iotlb_read               = 0;             
    527         m_cpt_iotlb_miss               = 0;             
    528         m_cpt_iotlbmiss_transaction    = 0;   
    529         m_cost_iotlbmiss_transaction   = 0;   
    530        
     553        m_debug_activated              = false;
     554
     555        // activity counters
     556        m_cpt_total_cycles             = 0;
     557        m_cpt_iotlb_read               = 0;
     558        m_cpt_iotlb_miss               = 0;
     559        m_cpt_iotlbmiss_transaction    = 0;
     560        m_cost_iotlbmiss_transaction   = 0;
     561
    531562        m_cpt_trt_dma_full             = 0;
    532563        m_cpt_trt_dma_full_cost        = 0;
    … …  
    547578    bool            dma_cmd_fifo_put          = false;
    548579    bool            dma_cmd_fifo_get          = p_vci_ini_ram.cmdack.read();
    549    
    550     bool            dma_rsp_fifo_put          = false;
     580    vci_srcid_t     dma_cmd_fifo_srcid        = 0;
     581
     582    bool            dma_rsp_fifo_put          = false;
    551583    bool            dma_rsp_fifo_get          = p_vci_tgt_iox.rspack.read();
    552584    vci_rerror_t    dma_rsp_fifo_rerror       = 0;
    … …  
    579611
    580612#ifdef INSTRUMENTATION
    581     m_cpt_fsm_dma_cmd           [r_dma_cmd_fsm.read()] ++;
    582     m_cpt_fsm_dma_rsp           [r_dma_rsp_fsm.read() ] ++;
    583     m_cpt_fsm_tlb                   [r_tlb_fsm.read() ] ++;
    584     m_cpt_fsm_config_cmd            [r_config_cmd_fsm.read() ] ++;
    585     m_cpt_fsm_config_rsp            [r_config_rsp_fsm.read() ] ++;
     613    m_cpt_fsm_dma_cmd           [r_dma_cmd_fsm.read()] ++;
     614    m_cpt_fsm_dma_rsp           [r_dma_rsp_fsm.read() ] ++;
     615    m_cpt_fsm_tlb               [r_tlb_fsm.read() ] ++;
     616    m_cpt_fsm_config_cmd        [r_config_cmd_fsm.read() ] ++;
     617    m_cpt_fsm_config_rsp        [r_config_rsp_fsm.read() ] ++;
    586618    m_cpt_fsm_miss_wti_rsp      [r_miss_wti_rsp_fsm.read() ] ++;
    587619#endif
    … …  
    607639    ///////////////////////////////////////////////////////////////////////////////
    608640
    609     switch( r_dma_cmd_fsm.read() ) 
     641    switch( r_dma_cmd_fsm.read() )
    610642    {
    611643    //////////////////
    … …  
    614646                        // no VCI flit is consumed in this state
    615647    {
    616         if ( p_vci_tgt_iox.cmdval.read() ) 
    617         { 
    618             if ( not r_iommu_active.read() )    // tlb not activated
     648        if ( p_vci_tgt_iox.cmdval.read() )
     649        {
     650            if ( not r_iommu_active.read() )    // tlb not activated
    619651            {
    620652                // save paddr address
    … …  
    625657                if ( is_wti( p_vci_tgt_iox.address.read() ) )
    626658                {
    627                     assert( p_vci_tgt_iox.eop.read() and 
     659                    assert( p_vci_tgt_iox.eop.read() and
    628660                    "ERROR in VCI_IOB illegal VCI WTI command from IOX network");
    629661
    … …  
    637669#if DEBUG_DMA_CMD
    638670if( m_debug_activated )
    639 std::cout << "  <IOB DMA_CMD_IDLE> DMA command"
     671std::cout << name()
     672          << "  <IOB DMA_CMD_IDLE> DMA command"
    640673          << " : address = " << std::hex << p_vci_tgt_iox.address.read()
    641674          << " / srcid = " << p_vci_tgt_iox.srcid.read()
    … …  
    646679            }
    647680            else if (r_tlb_fsm.read() == TLB_IDLE ||
    648                      r_tlb_fsm.read() == TLB_WAIT )       // tlb access possible
    649             {
    650                 vci_addr_t      iotlb_paddr;
    651                 pte_info_t  iotlb_flags; 
    652                 size_t      iotlb_way; 
     681                     r_tlb_fsm.read() == TLB_WAIT )   // tlb access possible
     682            {
     683                vci_addr_t  iotlb_paddr;
     684                pte_info_t  iotlb_flags;
     685                size_t      iotlb_way;
    653686                size_t      iotlb_set;
    654687                vci_addr_t  iotlb_nline;
    655                 bool            iotlb_hit; 
     688                bool        iotlb_hit;
    656689
    657690#ifdef INSTRUMENTATION
    … …  
    662695                                              &iotlb_flags,
    663696                                              &iotlb_nline,  // unused
    664                                               &iotlb_way,        // unused
     697                                              &iotlb_way,    // unused
    665698                                              &iotlb_set );  // unused
    666            
    667                 if ( iotlb_hit )                                     // tlb hit
    668                 { 
    669                     if ( not iotlb_flags.w and    // access right violation 
    670                         (p_vci_tgt_iox.cmd.read() == vci_param_ext::CMD_WRITE) ) 
     699
     700                if ( iotlb_hit )                                 // tlb hit
     701                {
     702                    if ( not iotlb_flags.w and    // access right violation
     703                        (p_vci_tgt_iox.cmd.read() == vci_param_ext::CMD_WRITE) )
    671704                    {
    672705                        // register error
    673                         r_iommu_etr      = MMU_WRITE_ACCES_VIOLATION; 
     706                        r_iommu_etr      = MMU_WRITE_ACCES_VIOLATION;
    674707                        r_iommu_bvar     = p_vci_tgt_iox.address.read();
    675708                        r_iommu_bad_id   = p_vci_tgt_iox.srcid.read();
    676                        
     709
    677710                        // prepare response error request to DMA_RSP FSM
    678711                        r_dma_cmd_to_dma_rsp_rsrcid = p_vci_tgt_iox.srcid.read();
    … …  
    684717#if DEBUG_DMA_CMD
    685718if( m_debug_activated )
    686 std::cout << "  <IOB DMA_CMD_IDLE> TLB HIT but writable violation" << std::endl;
     719std::cout << name()
     720          << "  <IOB DMA_CMD_IDLE> TLB HIT but writable violation" << std::endl;
    687721#endif
    688722                    }
    … …  
    691725#if DEBUG_DMA_CMD
    692726if( m_debug_activated )
    693 std::cout << "  <IOB DMA_CMD_IDLE> TLB HIT" << std::endl;
     727std::cout << name()
     728          << "  <IOB DMA_CMD_IDLE> TLB HIT" << std::endl;
    694729#endif
    695730                        // save paddr address
    … …  
    699734                        if ( is_wti( iotlb_paddr ) )
    700735                        {
    701                             assert( p_vci_tgt_iox.eop.read() and 
     736                            assert( p_vci_tgt_iox.eop.read() and
    702737                                   (p_vci_tgt_iox.cmd == vci_param_int::CMD_WRITE) and
    703738                            "ERROR in VCI_IOB illegal VCI WTI command from IOX network");
    704739
    705                             r_dma_cmd_fsm   = DMA_CMD_WTI_IOX_REQ;
     740                            r_dma_cmd_fsm = DMA_CMD_WTI_IOX_REQ;
    706741                        }
    707742                        else
    … …  
    717752m_cpt_iotlb_miss++;
    718753#endif
    719                     // register virtual address, and send request to TLB FSM 
    720                             r_dma_cmd_to_tlb_vaddr = p_vci_tgt_iox.address.read();
     754                    // register virtual address, and send request to TLB FSM
     755                    r_dma_cmd_to_tlb_vaddr = p_vci_tgt_iox.address.read();
    721756                    r_dma_cmd_to_tlb_req   = true;
    722757                    r_dma_cmd_fsm          = DMA_CMD_TLB_MISS_WAIT;
    723758#if DEBUG_DMA_CMD
    724759if( m_debug_activated )
    725 std::cout << "  <IOB DMA_CMD_IDLE> TLB MISS" << std::endl;
    726 #endif
    727                 } // end tlb miss
     760std::cout << name()
     761          << "  <IOB DMA_CMD_IDLE> TLB MISS" << std::endl;
     762#endif
     763                } // end tlb miss
    728764            } // end if tlb_activated
    729765        } // end if cmdval
    … …  
    732768    /////////////////////
    733769    case DMA_CMD_DMA_REQ:    // put a flit in DMA_CMD FIFO
    734                              // if contig, VCI address must be incremented 
     770                             // if contig, VCI address must be incremented
    735771                             // after initial translation by IOMMU.
    736772                             // flit is consumed if DMA_CMD FIFO not full
    737773    {
    738         if ( p_vci_tgt_iox.cmdval && m_dma_cmd_addr_fifo.wok() )
    739         {
    740             dma_cmd_fifo_put = true;
    741            
    742             if ( p_vci_tgt_iox.contig.read() ) r_dma_cmd_paddr = r_dma_cmd_paddr.read() +
    743                                                           vci_param_ext::B;
    744 
    745             if ( p_vci_tgt_iox.eop.read() )    r_dma_cmd_fsm   = DMA_CMD_IDLE;
    746            
     774        if ( p_vci_tgt_iox.cmdval && m_dma_cmd_addr_fifo.wok() )
     775        {
     776            // SRCID in RAM network is the concatenation of the IO bridge
     777            // cluster id with the DMA peripheral local id
     778            assert((m_srcid_gid_mask[p_vci_tgt_iox.srcid.read()] == 0) &&
     779                    "error: external DMA peripherals global id must be 0");
     780
     781            dma_cmd_fifo_srcid = (m_srcid_gid_mask.mask() & m_int_srcid) |
     782                                 p_vci_tgt_iox.srcid.read();
     783            dma_cmd_fifo_put   = true;
     784
     785            if ( p_vci_tgt_iox.contig.read() )
     786            {
     787                r_dma_cmd_paddr = r_dma_cmd_paddr.read() + vci_param_ext::B;
     788            }
     789
     790            if ( p_vci_tgt_iox.eop.read() )
     791            {
     792                r_dma_cmd_fsm = DMA_CMD_IDLE;
     793            }
     794
    747795#if DEBUG_DMA_CMD
    748 if( m_debug_activated )
    749 std::cout << "  <IOB DMA_CMD_FIFO_PUT_CMD> Push into DMA_CMD fifo:"
     796if( m_debug_activated )
     797std::cout << name()
     798          << "  <IOB DMA_CMD_FIFO_PUT_CMD> Push into DMA_CMD fifo:"
    750799          << " address = " << std::hex << r_dma_cmd_paddr.read()
    751           << " srcid = " << p_vci_tgt_iox.srcid.read()
     800          << " srcid = " << dma_cmd_fifo_srcid
    752801          << " wdata = " << p_vci_tgt_iox.wdata.read()
    753802          << " plen = " << std::dec << p_vci_tgt_iox.plen.read()
    … …  
    758807    }
    759808    /////////////////////////
    760     case DMA_CMD_WTI_IOX_REQ:    // post a WTI_IOX request to MISS_WTI FSM 
     809    case DMA_CMD_WTI_IOX_REQ:    // post a WTI_IOX request to MISS_WTI FSM
    761810                                 // if no prending previous request
    762                                  // command arguments are stored in dedicated registers 
     811                                 // command arguments are stored in dedicated registers
    763812                                 // VCI flit is consumed if no previous request
    764813    {
    765814        if ( not r_dma_cmd_to_miss_wti_cmd_req.read() )  // no previous pending request
    766815        {
     816            // SRCID in INT network for WTI transactions is the concatenation
     817            // of the IO bridge cluster id with the DMA peripheral local id
     818            assert((m_srcid_gid_mask[p_vci_tgt_iox.srcid.read()] == 0) &&
     819                    "error: external DMA peripherals global id must be 0");
     820
     821            vci_srcid_t wti_srcid = (m_srcid_gid_mask.mask() & m_int_srcid) |
     822                                    p_vci_tgt_iox.srcid.read();
     823
    767824            r_dma_cmd_to_miss_wti_cmd_req   = true;
    768825            r_dma_cmd_to_miss_wti_cmd_addr  = p_vci_tgt_iox.address.read();
    769826            r_dma_cmd_to_miss_wti_cmd_cmd   = p_vci_tgt_iox.cmd.read();
    770827            r_dma_cmd_to_miss_wti_cmd_wdata = (uint32_t)p_vci_tgt_iox.wdata.read();
    771             r_dma_cmd_to_miss_wti_cmd_srcid = p_vci_tgt_iox.srcid.read();
     828            r_dma_cmd_to_miss_wti_cmd_srcid = wti_srcid;
    772829            r_dma_cmd_to_miss_wti_cmd_trdid = p_vci_tgt_iox.trdid.read();
    773830            r_dma_cmd_to_miss_wti_cmd_pktid = PKTID_WTI_IOX;
    774831
    775832            r_dma_cmd_fsm = DMA_CMD_IDLE;
    776            
     833
    777834#if DEBUG_DMA_CMD
    778 if( m_debug_activated )
    779 std::cout << "  <IOB DMA_CMD_WTI_IOX_REQ> request WTI transaction from ext peripheral"
     835if( m_debug_activated )
     836std::cout << name()
     837          << "  <IOB DMA_CMD_WTI_IOX_REQ> request WTI transaction from ext peripheral"
    780838          << " : address = " << std::hex << r_dma_cmd_paddr.read()
    781           << " / srcid = " << p_vci_tgt_iox.srcid.read()
     839          << " / srcid = " << wti_srcid
    782840          << " / wdata = " << p_vci_tgt_iox.wdata.read() << std::endl;
    783841#endif
    … …  
    786844    }
    787845    //////////////////////////
    788     case DMA_CMD_ERR_WAIT_EOP:  // wait EOP before requesting WTI & error response
     846    case DMA_CMD_ERR_WAIT_EOP:  // wait EOP before requesting WTI & error response
    789847                                 // VCI flit is always consumed
    790848    {
    … …  
    792850
    793851#if DEBUG_DMA_CMD
    794 if( m_debug_activated )
    795 std::cout << "  <IOB DMA_CMD_WAIT_EOP> wait EOP for faulty DMA command" << std::endl;
    796 #endif
    797         break;
    798     }
    799    
     852if( m_debug_activated )
     853std::cout << name()
     854          << "  <IOB DMA_CMD_WAIT_EOP> wait EOP for faulty DMA command" << std::endl;
     855#endif
     856        break;
     857    }
     858
    800859    /////////////////////////
    801     case DMA_CMD_ERR_WTI_REQ:    // post a WTI_MMU request to MISS_WTI_CMD FSM
     860    case DMA_CMD_ERR_WTI_REQ:    // post a WTI_MMU request to MISS_WTI_CMD FSM
    802861                                 // if no prending previous request
    803862                                 // response arguments are stored in dedicated registers
    804                                  // no VCI flit is consumed 
     863                                 // no VCI flit is consumed
    805864    {
    806865        if ( not r_dma_cmd_to_miss_wti_cmd_req.read() )  // no pending previous request
    … …  
    817876
    818877#if DEBUG_DMA_CMD
    819 if( m_debug_activated )
    820 std::cout << "  <IOB DMA_CMD_ERR_WTI_REQ> request an IOMMU WTI" << std::endl;
     878if( m_debug_activated )
     879std::cout << name()
     880          << "  <IOB DMA_CMD_ERR_WTI_REQ> request an IOMMU WTI" << std::endl;
    821881#endif
    822882        }
    … …  
    827887                                 // if no prending previous request
    828888                                 // response arguments are stored in dedicated registers
    829                                  // no VCI flit is consumed 
     889                                 // no VCI flit is consumed
    830890    {
    831891        if ( not r_dma_cmd_to_dma_rsp_req.read() )  // no pending previous request
    … …  
    839899    ///////////////////////////
    840900    case DMA_CMD_TLB_MISS_WAIT:  // waiting completion of a TLB miss
    841                                  // we must test a possible page fault error...   
     901                                 // we must test a possible page fault error...
    842902    {
    843903        if ( not r_dma_cmd_to_tlb_req.read() ) // TLB miss completed
    … …  
    845905            if ( r_tlb_miss_error.read() )   // Error reported by TLB FSM
    846906            {
    847                 r_iommu_etr     = MMU_READ_PT2_UNMAPPED; 
     907                r_iommu_etr     = MMU_READ_PT2_UNMAPPED;
    848908                r_iommu_bvar    = r_dma_cmd_to_tlb_vaddr.read();
    849909                r_iommu_bad_id  = p_vci_tgt_iox.srcid.read();
    … …  
    872932    if ( m_dma_rsp_rerror_fifo.wok() )
    873933    {
    874         switch( r_dma_rsp_fsm.read() ) 
     934        switch( r_dma_rsp_fsm.read() )
    875935        {
    876936            //////////////////////
    877937            case DMA_RSP_IDLE_DMA:  // normal DMA response has highest priority
    878             {           
     938            {
    879939                if     (p_vci_ini_ram.rspval.read())          r_dma_rsp_fsm = DMA_RSP_PUT_DMA;
    880940                else if(r_miss_wti_rsp_to_dma_rsp_req.read()) r_dma_rsp_fsm = DMA_RSP_PUT_WTI;
    … …  
    884944            //////////////////////
    885945            case DMA_RSP_IDLE_WTI:  // normal WTI response has highest priority
    886             {           
    887                 if     (r_miss_wti_rsp_to_dma_rsp_req.read()) r_dma_rsp_fsm = DMA_RSP_PUT_WTI; 
     946            {
     947                if     (r_miss_wti_rsp_to_dma_rsp_req.read()) r_dma_rsp_fsm = DMA_RSP_PUT_WTI;
    888948                else if(r_dma_cmd_to_dma_rsp_req.read())      r_dma_rsp_fsm = DMA_RSP_PUT_ERR;
    889949                else if(p_vci_ini_ram.rspval.read())          r_dma_rsp_fsm = DMA_RSP_PUT_DMA;
    … …  
    892952            //////////////////////
    893953            case DMA_RSP_IDLE_ERR:  // error  response has highest priority
    894             {           
     954            {
    895955                if     (r_dma_cmd_to_dma_rsp_req.read())      r_dma_rsp_fsm = DMA_RSP_PUT_ERR;
    896956                else if(p_vci_ini_ram.rspval.read())          r_dma_rsp_fsm = DMA_RSP_PUT_DMA;
    897                 else if(r_miss_wti_rsp_to_dma_rsp_req.read()) r_dma_rsp_fsm = DMA_RSP_PUT_WTI; 
     957                else if(r_miss_wti_rsp_to_dma_rsp_req.read()) r_dma_rsp_fsm = DMA_RSP_PUT_WTI;
    898958                break;
    899959            }
    900960            ///////////////////////
    901961            case DMA_RSP_PUT_DMA:  // put one flit of the DMA response into FIFO
    902             {           
     962            {
    903963                dma_rsp_fifo_put    = true;
    904964                dma_rsp_fifo_rerror = p_vci_ini_ram.rerror.read();
    905965                dma_rsp_fifo_rdata  = p_vci_ini_ram.rdata.read();
    906                 dma_rsp_fifo_rsrcid = p_vci_ini_ram.rsrcid.read();
     966                dma_rsp_fifo_rsrcid = m_srcid_lid_mask[p_vci_ini_ram.rsrcid.read()];
    907967                dma_rsp_fifo_rtrdid = p_vci_ini_ram.rtrdid.read();
    908968                dma_rsp_fifo_rpktid = p_vci_ini_ram.rpktid.read();
    … …  
    913973
    914974#if DEBUG_DMA_RSP
    915 if( m_debug_activated )
    916 std::cout << "  <IOB DMA_RSP_PUT_DMA> Push DMA response into DMA_RSP FIFO"
    917           << " : rsrcid = " << std::hex << p_vci_ini_ram.rsrcid.read()
     975if( m_debug_activated )
     976std::cout << name()
     977          << "  <IOB DMA_RSP_PUT_DMA> Push DMA response into DMA_RSP FIFO"
     978          << std::hex
     979          << " : rsrcid = " << m_srcid_lid_mask[p_vci_ini_ram.rsrcid.read()]
    918980          << " / rtrdid = " << p_vci_ini_ram.rtrdid.read()
    919981          << " / rpktid = " << p_vci_ini_ram.rpktid.read()
    … …  
    923985#endif
    924986                break;
    925                     }
     987            }
    926988            ///////////////////////
    927989            case DMA_RSP_PUT_WTI:  // put single flit WTI response into FIFO
    928             {           
     990            {
    929991                dma_rsp_fifo_put    = true;
    930992                dma_rsp_fifo_rerror = r_miss_wti_rsp_to_dma_rsp_rerror.read();
    931993                dma_rsp_fifo_rdata  = 0;
    932                 dma_rsp_fifo_rsrcid = r_miss_wti_rsp_to_dma_rsp_rsrcid.read();
     994                dma_rsp_fifo_rsrcid =
     995                    m_srcid_lid_mask[r_miss_wti_rsp_to_dma_rsp_rsrcid.read()];
    933996                dma_rsp_fifo_rtrdid = r_miss_wti_rsp_to_dma_rsp_rtrdid.read();
    934997                dma_rsp_fifo_rpktid = r_miss_wti_rsp_to_dma_rsp_rpktid.read();
    … …  
    9371000                // acknowledge request
    9381001                r_miss_wti_rsp_to_dma_rsp_req = false;
    939  
     1002
    9401003                // update priority
    9411004                r_dma_rsp_fsm = DMA_RSP_IDLE_ERR;
    9421005
    9431006#if DEBUG_DMA_RSP
    944 if( m_debug_activated )
    945 std::cout << "  <IOB DMA_RSP_PUT_WTI> Push WTI response into DMA_RSP FIFO"
    946           << " : rsrcid = " << std::hex << r_miss_wti_rsp_to_dma_rsp_rsrcid.read()
     1007if( m_debug_activated )
     1008std::cout << name()
     1009          << "  <IOB DMA_RSP_PUT_WTI> Push WTI response into DMA_RSP FIFO"
     1010          << std::hex
     1011          << " : rsrcid = " << m_srcid_lid_mask[r_miss_wti_rsp_to_dma_rsp_rsrcid.read()]
    9471012          << " / rtrdid = " << r_miss_wti_rsp_to_dma_rsp_rtrdid.read()
    9481013          << " / rpktid = " << r_miss_wti_rsp_to_dma_rsp_rpktid.read()
    … …  
    9661031                // acknowledge request
    9671032                r_dma_cmd_to_dma_rsp_req = false;
    968  
     1033
    9691034                // update priority
    9701035                r_dma_rsp_fsm = DMA_RSP_PUT_DMA;
    9711036
    9721037#if DEBUG_DMA_RSP
    973 if( m_debug_activated )
    974 std::cout << "  <IOB DMA_RSP_PUT_DMA> Push IOMMU ERROR response into DMA_RSP FIFO"
     1038if( m_debug_activated )
     1039std::cout << name()
     1040          << "  <IOB DMA_RSP_PUT_DMA> Push IOMMU ERROR response into DMA_RSP FIFO"
    9751041          << " : rsrcid = " << std::hex << r_dma_cmd_to_dma_rsp_rsrcid.read()
    9761042          << " / rtrdid = " << r_dma_cmd_to_dma_rsp_rtrdid.read()
    … …  
    9821048                break;
    9831049            }
    984                 } // end switch DMA_RSP FSM
     1050        } // end switch DMA_RSP FSM
    9851051    }  // end if FIFO full
    9861052
    … …  
    9891055    // The TLB FSM handles the TLB miss requests from DMA_CMD FSM,
    9901056    // and the PTE inval request (from CONFIG_CMD FSM).
    991     // PTE inval request have highest priority. In case of TLB miss, 
     1057    // PTE inval request have highest priority. In case of TLB miss,
    9921058    // this fsm searchs the requested PTE on the prefetch buffer.
    9931059    // In case of buffer miss,  it request the MISS_WTI FSM to access the memory.
    … …  
    10031069                     // PTE inval request are handled as unmaskable interrupts
    10041070    {
    1005         if ( r_config_cmd_to_tlb_req.read() ) // Request for a PTE invalidation 
     1071        if ( r_config_cmd_to_tlb_req.read() ) // Request for a PTE invalidation
    10061072        {
    10071073            r_config_cmd_to_tlb_req  = false;
    … …  
    10101076        }
    10111077
    1012         else if ( r_dma_cmd_to_tlb_req.read() )   // request for a TLB Miss 
     1078        else if ( r_dma_cmd_to_tlb_req.read() )   // request for a TLB Miss
    10131079        {
    10141080            // Checking prefetch buffer
    … …  
    10161082            {
    10171083                if( r_tlb_buf_valid &&         // Hit on prefetch buffer
    1018                     (r_tlb_buf_vaddr.read() == 
     1084                    (r_tlb_buf_vaddr.read() ==
    10191085                    (r_dma_cmd_to_tlb_vaddr.read()& ~PTE2_LINE_OFFSET & ~K_PAGE_OFFSET_MASK)))
    10201086                {
    1021                     size_t   pte_offset = (r_dma_cmd_to_tlb_vaddr.read()& PTE2_LINE_OFFSET)>>12; 
     1087                    size_t   pte_offset = (r_dma_cmd_to_tlb_vaddr.read()& PTE2_LINE_OFFSET)>>12;
    10221088                    uint32_t pte_flags  = r_tlb_buf_data[2*pte_offset];
    1023                     uint32_t pte_ppn    = r_tlb_buf_data[2*pte_offset+1]; 
    1024                
     1089                    uint32_t pte_ppn    = r_tlb_buf_data[2*pte_offset+1];
     1090
    10251091                    // Bit valid checking
    1026                     if ( not ( pte_flags & PTE_V_MASK) )        // unmapped
     1092                    if ( not ( pte_flags & PTE_V_MASK) )    // unmapped
    10271093                    {
    1028                         std::cout << "VCI_IO_BRIDGE ERROR : " << name() 
     1094                        std::cout << "VCI_IO_BRIDGE ERROR : " << name()
    10291095                                  << " Page Table entry unmapped" << std::endl;
    1030                        
     1096
    10311097                        r_tlb_miss_error = true;
    10321098                        r_dma_cmd_to_tlb_req    = false;
    10331099#if DEBUG_TLB_MISS
    10341100if ( m_debug_activated )
    1035 std::cout << "  <IOB TLB_IDLE> PTE2 Unmapped" << std::hex
     1101std::cout << name()
     1102          << "  <IOB TLB_IDLE> PTE2 Unmapped" << std::hex
    10361103          << " / paddr = " << r_tlb_paddr.read()
    10371104          << " / PTE_FLAGS = " << pte_flags
    10381105          << " / PTE_PPN = " << pte_ppn << std::endl;
    10391106#endif
    1040                         break; 
     1107                        break;
    10411108                    }
    10421109
    10431110                    // valid PTE2 : we must update the TLB
    1044                     r_tlb_pte_flags = pte_flags; 
     1111                    r_tlb_pte_flags = pte_flags;
    10451112                    r_tlb_pte_ppn   = pte_ppn;
    10461113                    r_tlb_fsm       = TLB_PTE2_SELECT;
    10471114#if DEBUG_TLB_MISS
    10481115if ( m_debug_activated )
    1049 std::cout << "  <IOB TLB_IDLE> Hit on prefetch buffer: PTE2" << std::hex
    1050           << " / PTE_FLAGS = " << pte_flags
     1116std::cout << name()
     1117          << "  <IOB TLB_IDLE> Hit on prefetch buffer: PTE2" << std::hex
     1118          << " / PTE_FLAGS = " << pte_flags
    10511119          << " / PTE_PPN = " << pte_ppn << std::endl;
    10521120#endif
    1053                     break;   
     1121                    break;
    10541122                }
    10551123            }
    … …  
    10571125            {
    10581126                if( r_tlb_buf_valid &&         // Hit on prefetch buffer
    1059                     (r_tlb_buf_vaddr.read() == 
    1060                     (r_dma_cmd_to_tlb_vaddr.read()& ~PTE1_LINE_OFFSET & ~M_PAGE_OFFSET_MASK ))) 
    1061                 {
    1062                     size_t   pte_offset = (r_dma_cmd_to_tlb_vaddr.read()& PTE1_LINE_OFFSET)>>21; 
     1127                    (r_tlb_buf_vaddr.read() ==
     1128                    (r_dma_cmd_to_tlb_vaddr.read()& ~PTE1_LINE_OFFSET & ~M_PAGE_OFFSET_MASK )))
     1129                {
     1130                    size_t   pte_offset = (r_dma_cmd_to_tlb_vaddr.read()& PTE1_LINE_OFFSET)>>21;
    10631131                    uint32_t pte_flags  = r_tlb_buf_data[pte_offset];
    1064                            
     1132
    10651133                    // Bit valid checking
    1066                     if ( not ( pte_flags & PTE_V_MASK) )        // unmapped
     1134                    if ( not ( pte_flags & PTE_V_MASK) )    // unmapped
    10671135                    {
    1068                         std::cout << "VCI_IO_BRIDGE ERROR : " << name() 
     1136                        std::cout << "VCI_IO_BRIDGE ERROR : " << name()
    10691137                                  << " Page Table entry unmapped" << std::endl;
    1070                        
     1138
    10711139                        r_tlb_miss_error = true;
    10721140                        r_dma_cmd_to_tlb_req    = false;
    10731141#if DEBUG_TLB_MISS
    10741142if ( m_debug_activated )
    1075 std::cout << "  <IOB TLB_IDLE> PTE1 Unmapped" << std::hex
     1143std::cout << name()
     1144          << "  <IOB TLB_IDLE> PTE1 Unmapped" << std::hex
    10761145          << " / paddr = " << r_tlb_paddr.read()
    10771146          << " / PTE = " << pte_flags << std::endl;
    10781147#endif
    1079                         break; 
     1148                        break;
    10801149                    }
    10811150
    … …  
    10851154#if DEBUG_TLB_MISS
    10861155if ( m_debug_activated )
    1087 std::cout << "  <IOB TLB_PTE1_GET> Hit on prefetch buffer: PTE1" << std::hex
     1156std::cout << name()
     1157          << "  <IOB TLB_PTE1_GET> Hit on prefetch buffer: PTE1" << std::hex
    10881158          << " / paddr = " << r_tlb_paddr.read()
    10891159          << std::hex << " / PTE1 = " << pte_flags << std::endl;
    … …  
    10921162                }
    10931163            }
    1094        
     1164
    10951165            // prefetch buffer miss
    1096             r_tlb_fsm = TLB_MISS; 
     1166            r_tlb_fsm = TLB_MISS;
    10971167
    10981168#if DEBUG_TLB_MISS
    10991169if ( m_debug_activated )
    1100 std::cout << "  <IOB TLB_IDLE> Miss on prefetch buffer"
     1170std::cout << name()
     1171          << "  <IOB TLB_IDLE> Miss on prefetch buffer"
    11011172          << std::hex << " / vaddr = " << r_dma_cmd_to_tlb_vaddr.read() << std::endl;
    11021173#endif
    … …  
    11071178    case TLB_MISS: // handling tlb miss
    11081179    {
    1109         uint32_t        ptba = 0;
    1110         bool            bypass;
    1111         vci_addr_t      pte_paddr;
     1180        uint32_t    ptba = 0;
     1181        bool        bypass;
     1182        vci_addr_t  pte_paddr;
    11121183
    11131184#ifdef INSTRUMENTATION
    … …  
    11161187        // evaluate bypass in order to skip first level page table access
    11171188        bypass = r_iotlb.get_bypass(r_dma_cmd_to_tlb_vaddr.read(), &ptba);
    1118        
    1119         // Request MISS_WTI_FSM a transaction on INT Network 
     1189
     1190        // Request MISS_WTI_FSM a transaction on INT Network
    11201191        if ( not bypass )     // Read PTE1/PTD1 in XRAM
    11211192        {
    … …  
    11231194#if DEBUG_TLB_MISS
    11241195if ( m_debug_activated )
    1125 std::cout << "  <IOB TLB_MISS> Read PTE1/PTD1 in memory" << std::endl;
     1196std::cout << name()
     1197          << "  <IOB TLB_MISS> Read PTE1/PTD1 in memory" << std::endl;
    11261198#endif
    11271199            pte_paddr = (vci_addr_t)((r_iommu_ptpr.read()) << (INDEX1_NBITS+2)) |
    11281200                        (vci_addr_t)((r_dma_cmd_to_tlb_vaddr.read() >> PAGE_M_NBITS) << 2);
    11291201            r_tlb_paddr = pte_paddr;
    1130            
     1202
    11311203            r_tlb_to_miss_wti_cmd_req = true;
    11321204            r_tlb_miss_type           = PTE1_MISS;
    … …  
    11381210#if DEBUG_TLB_MISS
    11391211if ( m_debug_activated )
    1140 std::cout << "  <IOB TLB_MISS> Read PTE2 in memory" << std::endl;
     1212std::cout << name()
     1213          << "  <IOB TLB_MISS> Read PTE2 in memory" << std::endl;
    11411214#endif
    11421215            //&PTE2 = PTBA + IX2 * 8
    11431216            pte_paddr = (vci_addr_t)ptba << PAGE_K_NBITS |
    11441217                        (vci_addr_t)(r_dma_cmd_to_tlb_vaddr.read()&PTD_ID2_MASK)>>(PAGE_K_NBITS-3);
    1145            
     1218
    11461219            r_tlb_paddr = pte_paddr;
    1147            
     1220
    11481221            r_tlb_to_miss_wti_cmd_req = true;
    11491222            r_tlb_miss_type           = PTE2_MISS;
    … …  
    11531226        break;
    11541227    }
    1155     ////////////////// 
    1156     case TLB_PTE1_GET:  // Try to read a PT1 entry in the miss buffer
    1157     {
    1158        
     1228    //////////////////
     1229    case TLB_PTE1_GET:  // Try to read a PT1 entry in the miss buffer
     1230    {
     1231
    11591232        uint32_t  entry;
    1160        
     1233
    11611234        vci_addr_t line_number  = (vci_addr_t)((r_tlb_paddr.read())&(CACHE_LINE_MASK));
    11621235        size_t word_position = (size_t)( ((r_tlb_paddr.read())&(~CACHE_LINE_MASK))>>2 );
    11631236
    1164         // Hit test. Just to verify. 
     1237        // Hit test. Just to verify.
    11651238        // Hit must happen, since we've just finished its' miss transaction
    1166         bool hit = (r_tlb_buf_valid && (r_tlb_buf_tag.read()== line_number) ); 
    1167         assert(hit and "Error: No hit on prefetch buffer after Miss Transaction"); 
    1168        
     1239        bool hit = (r_tlb_buf_valid && (r_tlb_buf_tag.read()== line_number) );
     1240        assert(hit and "Error: No hit on prefetch buffer after Miss Transaction");
     1241
    11691242        entry = r_tlb_buf_data[word_position];
    1170            
     1243
    11711244        // Bit valid checking
    1172         if ( not ( entry & PTE_V_MASK) )        // unmapped
     1245        if ( not ( entry & PTE_V_MASK) )    // unmapped
    11731246        {
    11741247            //must not occur!
    11751248            std::cout << "IOMMU ERROR " << name() << "TLB_IDLE state" << std::endl
    11761249                      << "The Page Table entry ins't valid (unmapped)" << std::endl;
    1177                        
     1250
    11781251            r_tlb_miss_error       = true;
    11791252            r_dma_cmd_to_tlb_req   = false;
    1180             r_tlb_fsm              = TLB_IDLE;           
     1253            r_tlb_fsm              = TLB_IDLE;
    11811254
    11821255#if DEBUG_TLB_MISS
    11831256if ( m_debug_activated )
    11841257{
    1185     std::cout << "  <IOB DMA_PTE1_GET> First level entry Unmapped"
     1258    std::cout << name()
     1259              << "  <IOB DMA_PTE1_GET> First level entry Unmapped"
    11861260              << std::hex << " / paddr = " << r_tlb_paddr.read()
    11871261              << std::hex << " / PTE = " << entry << std::endl;
    11881262}
    11891263#endif
    1190                     break; 
     1264                    break;
    11911265        }
    1192    
    1193         if( entry & PTE_T_MASK )        //  PTD : me must access PT2
     1266
     1267        if( entry & PTE_T_MASK )    //  PTD : me must access PT2
    11941268        {
    11951269            // register bypass
    11961270            r_iotlb.set_bypass( r_dma_cmd_to_tlb_vaddr.read(),
    1197                                 entry & ((1 << (vci_param_int::N-PAGE_K_NBITS)) - 1), 
    1198                                 0); //nline, unused 
     1271                                entry & ((1 << (vci_param_int::N-PAGE_K_NBITS)) - 1),
     1272                                0); //nline, unused
    11991273
    12001274            // &PTE2 = PTBA + IX2 * 8
    … …  
    12131287#if DEBUG_TLB_MISS
    12141288if ( m_debug_activated )
    1215 std::cout << "  <IOB TLB_PTE1_GET> Success. Search PTE2" << std::hex
     1289std::cout << name()
     1290          << "  <IOB TLB_PTE1_GET> Success. Search PTE2" << std::hex
    12161291          << " / PADDR = " << r_tlb_paddr.read()
    12171292          << " / PTD = " << entry << std::endl;
    12181293#endif
    12191294        }
    1220         else                    //  PTE1 :  we must update the IOTLB
     1295        else            //  PTE1 :  we must update the IOTLB
    12211296                        //  Should not occur if working only with small pages
    12221297        {
    … …  
    12261301#if DEBUG_TLB_MISS
    12271302if ( m_debug_activated )
    1228 std::cout << "  <IOB TLB_PTE1_GET> Success. Big page"
     1303std::cout << name()
     1304          << "  <IOB TLB_PTE1_GET> Success. Big page"
    12291305          << std::hex << " / paddr = " << r_tlb_paddr.read()
    12301306          << std::hex << " / PTE1 = " << entry << std::endl;
    … …  
    12341310    }
    12351311    /////////////////////
    1236     case TLB_PTE1_SELECT:       // select a slot for PTE1
    1237     {
    1238         size_t  way;
    1239         size_t  set;
    1240        
     1312    case TLB_PTE1_SELECT:   // select a slot for PTE1
     1313    {
     1314        size_t  way;
     1315        size_t  set;
     1316
    12411317        r_iotlb.select(  r_dma_cmd_to_tlb_vaddr.read(),
    1242                         true,  // PTE1 
     1318                        true,  // PTE1
    12431319                        &way,
    12441320                        &set );
    … …  
    12491325#if DEBUG_TLB_MISS
    12501326if ( m_debug_activated )
    1251 std::cout << "  <IOB TLB_PTE1_SELECT> Select a slot in TLB"
     1327std::cout << name()
     1328          << "  <IOB TLB_PTE1_SELECT> Select a slot in TLB"
    12521329          << " / way = " << std::dec << way
    12531330          << " / set = " << set << std::endl;
    … …  
    12631340    {
    12641341        uint32_t  pte   = r_tlb_pte_flags.read();
    1265        
     1342
    12661343        r_tlb_paddr = (vci_addr_t)( ((r_tlb_pte_flags.read() & PPN1_MASK) << 21)
    12671344                        | (r_dma_cmd_to_tlb_vaddr.read()& M_PAGE_OFFSET_MASK) );
    1268        
     1345
    12691346        // update TLB
    1270         r_iotlb.write( true,            // 2M page
     1347        r_iotlb.write( true,        // 2M page
    12711348                      pte,
    1272                       0,                // argument unused for a PTE1
    1273                       r_dma_cmd_to_tlb_vaddr.read(),   
    1274                       r_tlb_way.read(), 
     1349                      0,        // argument unused for a PTE1
     1350                      r_dma_cmd_to_tlb_vaddr.read(),
     1351                      r_tlb_way.read(),
    12751352                      r_tlb_set.read(),
    12761353                      0 );      //we set nline = 0
    … …  
    12831360if ( m_debug_activated )
    12841361{
    1285 std::cout << "  <IOB TLB_PTE1_UPDT> write PTE1 in TLB"
     1362std::cout << name()
     1363          << "  <IOB TLB_PTE1_UPDT> write PTE1 in TLB"
    12861364          << " / set = " << std::dec << r_tlb_set.read()
    12871365          << " / way = " << r_tlb_way.read() << std::endl;
    … …  
    12901368#endif
    12911369        // next state
    1292         r_tlb_fsm = TLB_RETURN; // exit sub-fsm
     1370        r_tlb_fsm = TLB_RETURN; // exit sub-fsm
    12931371        break;
    12941372    }
    12951373    //////////////////
    1296     case TLB_PTE2_GET:  // Try to read a PTE2 (64 bits) in the miss buffer
    1297     {   
    1298         uint32_t        pte_flags;
    1299         uint32_t        pte_ppn;
    1300        
     1374    case TLB_PTE2_GET:  // Try to read a PTE2 (64 bits) in the miss buffer
     1375    {
     1376        uint32_t    pte_flags;
     1377        uint32_t    pte_ppn;
     1378
    13011379        vci_addr_t line_number  = (vci_addr_t)((r_tlb_paddr.read())&(CACHE_LINE_MASK));
    13021380        size_t word_position = (size_t)( ((r_tlb_paddr.read())&(~CACHE_LINE_MASK))>>2 );
    1303        
    1304        
     1381
     1382
    13051383        // Hit test. Just to verify.
    1306         bool hit = (r_tlb_buf_valid && (r_tlb_buf_tag.read()== line_number) ); 
    1307         assert(hit and "Error: No hit on prefetch buffer after Miss Transaction"); 
     1384        bool hit = (r_tlb_buf_valid && (r_tlb_buf_tag.read()== line_number) );
     1385        assert(hit and "Error: No hit on prefetch buffer after Miss Transaction");
    13081386        pte_flags= r_tlb_buf_data[word_position];
    13091387        pte_ppn= r_tlb_buf_data[word_position+1]; //because PTE2 is 2 words long
    13101388        // Bit valid checking
    1311         if ( not ( pte_flags & PTE_V_MASK) )    // unmapped
     1389        if ( not ( pte_flags & PTE_V_MASK) )    // unmapped
    13121390        {
    13131391            //must not occur!
    13141392            std::cout << "IOMMU ERROR " << name() << "TLB_IDLE state" << std::endl
    13151393                      << "The Page Table entry ins't valid (unmapped)" << std::endl;
    1316                        
     1394
    13171395            r_tlb_miss_error       = true;
    13181396            r_dma_cmd_to_tlb_req         = false;
    1319             r_tlb_fsm             = TLB_IDLE;           
     1397            r_tlb_fsm             = TLB_IDLE;
    13201398
    13211399#if DEBUG_TLB_MISS
    13221400if ( m_debug_activated )
    1323 std::cout << "  <IOB TLB_PTE2_GET> PTE2 Unmapped" << std::hex
     1401std::cout << name()
     1402          << "  <IOB TLB_PTE2_GET> PTE2 Unmapped" << std::hex
    13241403          << " / PADDR = " << r_tlb_paddr.read()
    13251404          << " / PTE = " << pte_flags << std::endl;
    13261405#endif
    1327             break; 
     1406            break;
    13281407        }
    1329            
    1330         r_tlb_pte_flags       = pte_flags; 
     1408
     1409        r_tlb_pte_flags       = pte_flags;
    13311410        r_tlb_pte_ppn         = pte_ppn;
    13321411        r_tlb_fsm           = TLB_PTE2_SELECT;
    1333                
     1412
    13341413#if DEBUG_TLB_MISS
    13351414if ( m_debug_activated )
    1336 std::cout << "  <IOB TLB_PTE2_GET> Mapped" << std::hex
    1337           << " / PTE_FLAGS = " << pte_flags
     1415std::cout << name()
     1416          << "  <IOB TLB_PTE2_GET> Mapped" << std::hex
     1417          << " / PTE_FLAGS = " << pte_flags
    13381418          << " / PTE_PPN = " << pte_ppn << std::endl;
    13391419#endif
    … …  
    13471427
    13481428        r_iotlb.select( r_dma_cmd_to_tlb_vaddr.read(),
    1349                         false,  // PTE2
     1429                        false,  // PTE2
    13501430                        &way,
    13511431                        &set );
    … …  
    13561436#if DEBUG_TLB_MISS
    13571437if ( m_debug_activated )
    1358 std::cout << "  <IOB TLB_PTE2_SELECT> Select a slot in IOTLB:"
     1438std::cout << name()
     1439          << "  <IOB TLB_PTE2_SELECT> Select a slot in IOTLB:"
    13591440          << " way = " << std::dec << way
    13601441          << " / set = " << set << std::endl;
    … …  
    13661447    }
    13671448    ///////////////////
    1368     case TLB_PTE2_UPDT:         // write a new PTE2 in tlb
     1449    case TLB_PTE2_UPDT:         // write a new PTE2 in tlb
    13691450                                // not necessary to treat the L/R bit
    13701451    {
    13711452        uint32_t        pte_flags = r_tlb_pte_flags.read();
    13721453        uint32_t        pte_ppn   = r_tlb_pte_ppn.read();
    1373        
     1454
    13741455        r_tlb_paddr = (vci_addr_t)( ((r_tlb_pte_ppn.read() & PPN2_MASK) << 12)
    13751456                        | (r_dma_cmd_to_tlb_vaddr.read()& K_PAGE_OFFSET_MASK) );
    1376        
     1457
    13771458        // update TLB for a PTE2
    1378         r_iotlb.write( false,   // 4K page
     1459        r_iotlb.write( false,   // 4K page
    13791460                       pte_flags,
    13801461                       pte_ppn,
    1381                        r_dma_cmd_to_tlb_vaddr.read(),   
    1382                        r_tlb_way.read(), 
     1462                       r_dma_cmd_to_tlb_vaddr.read(),
     1463                       r_tlb_way.read(),
    13831464                       r_tlb_set.read(),
    13841465                       0 );     // nline = 0
    … …  
    13901471if ( m_debug_activated )
    13911472{
    1392 std::cout << "  <IOB TLB_PTE2_UPDT> write PTE2 in IOTLB"
     1473std::cout << name()
     1474          << "  <IOB TLB_PTE2_UPDT> write PTE2 in IOTLB"
    13931475          << " / set = " << std::dec << r_tlb_set.read()
    13941476          << " / way = " << r_tlb_way.read() << std::endl;
    … …  
    13971479#endif
    13981480        // next state
    1399         r_tlb_fsm = TLB_RETURN; 
     1481        r_tlb_fsm = TLB_RETURN;
    14001482        break;
    14011483    }
    … …  
    14041486                     // PTE inval request are handled as unmaskable interrupts
    14051487    {
    1406         if ( r_config_cmd_to_tlb_req.read() ) // Request for a PTE invalidation 
     1488        if ( r_config_cmd_to_tlb_req.read() ) // Request for a PTE invalidation
    14071489        {
    14081490            r_config_cmd_to_tlb_req = false;
    … …  
    14141496m_cost_iotlbmiss_transaction++;
    14151497#endif
    1416         if ( not r_tlb_to_miss_wti_cmd_req.read() )     //  Miss transaction completed
    1417         { 
    1418                 if ( r_miss_wti_rsp_error_miss.read() ) // bus error reported
    1419                 {
     1498        if ( not r_tlb_to_miss_wti_cmd_req.read() ) //  Miss transaction completed
     1499        {
     1500            if ( r_miss_wti_rsp_error_miss.read() ) // bus error reported
     1501            {
    14201502                r_miss_wti_rsp_error_miss = false;
    14211503                r_tlb_miss_error          = true;
    … …  
    14251507            else if(r_tlb_miss_type == PTE1_MISS)
    14261508            {
    1427                 r_tlb_fsm = TLB_PTE1_GET; 
     1509                r_tlb_fsm = TLB_PTE1_GET;
    14281510            }
    14291511            else
    … …  
    14401522#if DEBUG_TLB_MISS
    14411523if ( m_debug_activated )
    1442 std::cout << "  <IOB TLB_RETURN> IOTLB MISS completed" << std::endl;
     1524std::cout << name()
     1525          << "  <IOB TLB_RETURN> IOTLB MISS completed" << std::endl;
    14431526#endif
    14441527        r_dma_cmd_to_tlb_req  = false;
    … …  
    14571540            if(!r_tlb_buf_big_page)
    14581541            {
    1459                if( r_tlb_buf_vaddr.read() == 
    1460                    (r_config_cmd_to_tlb_vaddr.read()& ~PTE2_LINE_OFFSET) ) 
     1542               if( r_tlb_buf_vaddr.read() ==
     1543                   (r_config_cmd_to_tlb_vaddr.read()& ~PTE2_LINE_OFFSET) )
    14611544                // The virtual address corresponds to one entry on the buffer line
    14621545                {
    … …  
    14661549            else    // First level entries on buffer. Unused if only small pages
    14671550            {
    1468                if( r_tlb_buf_vaddr.read() == 
    1469                    (r_config_cmd_to_tlb_vaddr.read()& ~PTE1_LINE_OFFSET) ) 
     1551               if( r_tlb_buf_vaddr.read() ==
     1552                   (r_config_cmd_to_tlb_vaddr.read()& ~PTE1_LINE_OFFSET) )
    14701553                // The virtual address corresponds to one entry on the buffer line
    14711554                {
    … …  
    14741557            }
    14751558        }
    1476        
     1559
    14771560        // Invalidation on IOTLB
    1478         bool    ok;
    1479         ok = r_iotlb.inval(r_config_cmd_to_tlb_vaddr.read());
    1480          
    1481         if(r_waiting_transaction.read()) r_tlb_fsm =TLB_WAIT;
     1561        r_iotlb.inval(r_config_cmd_to_tlb_vaddr.read());
     1562
     1563        if(r_waiting_transaction.read()) r_tlb_fsm =TLB_WAIT;
    14821564        else r_tlb_fsm = TLB_IDLE;
    1483         break; 
     1565        break;
    14841566    }
    14851567    } //end switch r_tlb_fsm
    1486    
     1568
    14871569    ////////////////////////////////////////////////////////////////////////////////
    14881570    // The CONFIG_CMD_FSM handles the VCI commands from the INT network.
    … …  
    15011583    ///////////////////////////////////////////////////////////////////////////////
    15021584
    1503     switch( r_config_cmd_fsm.read() ) 
     1585    switch( r_config_cmd_fsm.read() )
    15041586    {
    15051587    /////////////////////
    15061588    case CONFIG_CMD_IDLE:   // A VCI INT command is always consumed in this state
    15071589    {
    1508         if ( p_vci_tgt_int.cmdval.read() ) 
     1590        if ( p_vci_tgt_int.cmdval.read() )
    15091591        {
    15101592
    15111593#if DEBUG_CONFIG_CMD
    15121594if( m_debug_activated )
    1513 std::cout << "  <IOB CONFIG_CMD_IDLE> ### Config Command received" << std::endl
     1595std::cout << name()
     1596          << "  <IOB CONFIG_CMD_IDLE> ### Config Command received" << std::endl
    15141597          << "  address = " << std::hex << p_vci_tgt_int.address.read()
    15151598          << " / srcid = " << p_vci_tgt_int.srcid.read()
    15161599          << " / trdid = " << p_vci_tgt_int.trdid.read()
     1600          << " / pktid = " << p_vci_tgt_int.pktid.read()
    15171601          << " / wdata = " << std::hex << p_vci_tgt_int.wdata.read()
    15181602          << " / be = " << p_vci_tgt_int.be.read()
    … …  
    15221606            vci_addr_t paddr = p_vci_tgt_int.address.read();
    15231607            bool       read  = (p_vci_tgt_int.cmd.read() == vci_param_int::CMD_READ);
    1524             uint32_t   cell  = (uint32_t)((paddr & 0x1FF)>>2); 
     1608            uint32_t   cell  = (uint32_t)((paddr & 0x1FF)>>2);
    15251609            bool       eop   = p_vci_tgt_int.eop.read();
    15261610            bool       high  = (paddr & 0x4);
     1611            ext_data_t wdata = (ext_data_t)p_vci_tgt_int.wdata.read();
     1612            ext_be_t   be    = (ext_be_t)p_vci_tgt_int.be.read();
    15271613
    15281614            // chek segments
    … …  
    15301616            bool found   = false;
    15311617            bool special = false;
    1532             for ( seg = m_int_seglist.begin() ; 
     1618            for ( seg = m_int_seglist.begin() ;
    15331619                  seg != m_int_seglist.end() and not found ; seg++ )
    15341620            {
    1535                 if ( seg->contains(paddr) ) 
     1621                if ( seg->contains(paddr) )
    15361622                {
    15371623                   found   = true;
    … …  
    15391625                }
    15401626            }
    1541            
     1627
    15421628            if ( found and special )  // IO_BRIDGE itself
    15431629            {
    15441630                bool rerror = false;
    1545 
    1546                 assert( (p_vci_tgt_int.be.read() == 0xF) and
     1631                int_data_t rdata;
     1632
     1633                assert( (be == 0xF) and
    15471634                "ERROR in vci_io_bridge : BE must be 0xF for a config access");
    15481635
    … …  
    15521639                if ( not read && (cell == IOB_IOMMU_PTPR) )       // WRITE PTPR
    15531640                {
    1554                     r_iommu_ptpr = (uint32_t)p_vci_tgt_int.wdata.read();
    1555                 }
    1556                 else if ( read && (cell == IOB_IOMMU_PTPR) )      // READ PTPR 
    1557                 {
    1558                     r_config_cmd_to_config_rsp_rdata = r_iommu_ptpr.read();
     1641                    r_iommu_ptpr = (uint32_t)wdata;
     1642                }
     1643                else if ( read && (cell == IOB_IOMMU_PTPR) )      // READ PTPR
     1644                {
     1645                    rdata = r_iommu_ptpr.read();
    15591646                }
    15601647                else if( not read && (cell == IOB_WTI_ENABLE))  // WRITE WTI_ENABLE
    15611648                {
    1562                     r_iommu_wti_enable = p_vci_tgt_int.wdata.read();
     1649                    r_iommu_wti_enable = wdata;
    15631650                }
    15641651                else if( read && (cell == IOB_WTI_ENABLE))       // READ WTI ENABLE
    15651652                {
    1566                     r_config_cmd_to_config_rsp_rdata = r_iommu_wti_enable.read();
     1653                    rdata = r_iommu_wti_enable.read();
    15671654                }
    15681655                else if( read && (cell == IOB_IOMMU_BVAR))        // READ BVAR
    15691656                {
    1570                     r_config_cmd_to_config_rsp_rdata = r_iommu_bvar.read();
     1657                    rdata = r_iommu_bvar.read();
    15711658                }
    15721659                else if( read && (cell == IOB_IOMMU_ETR))          // READ ETR
    15731660                {
    1574                     r_config_cmd_to_config_rsp_rdata = r_iommu_etr.read();
     1661                    rdata = r_iommu_etr.read();
    15751662                }
    15761663                else if( read && (cell == IOB_IOMMU_BAD_ID))      // READ BAD_ID
    15771664                {
    1578                     r_config_cmd_to_config_rsp_rdata = r_iommu_bad_id.read();
     1665                    rdata = r_iommu_bad_id.read();
    15791666                }
    15801667                else if( not read && (cell == IOB_INVAL_PTE))     // WRITE INVAL_PTE
    15811668                {
    15821669                    r_config_cmd_to_tlb_req   = true;
    1583                     r_config_cmd_to_tlb_vaddr = (uint32_t)p_vci_tgt_int.wdata.read();
     1670                    r_config_cmd_to_tlb_vaddr = (uint32_t)wdata;
    15841671                }
    15851672                else if( not read && (cell == IOB_WTI_ADDR_LO)) // WRITE WTI_PADDR_LO
    15861673                {
    1587                     r_iommu_wti_addr_lo = (vci_addr_t)p_vci_tgt_int.wdata.read();
     1674                    r_iommu_wti_addr_lo = (vci_addr_t)wdata;
    15881675                }
    15891676                else if( read && (cell == IOB_WTI_ADDR_LO))    // READ WTI_PADDR_LO
    15901677                {
    1591                     r_config_cmd_to_config_rsp_rdata = r_iommu_wti_addr_lo.read();
     1678                    rdata = r_iommu_wti_addr_lo.read();
    15921679                }
    15931680                else if( not read && (cell == IOB_WTI_ADDR_HI)) // WRITE WTI_PADDR_HI
    15941681                {
    1595                     r_iommu_wti_addr_hi = (vci_addr_t)p_vci_tgt_int.wdata.read();
     1682                    r_iommu_wti_addr_hi = (vci_addr_t)wdata;
    15961683                }
    15971684                else if( read && (cell == IOB_WTI_ADDR_HI))    // READ WTI_PADDR_HI
    15981685                {
    1599                     r_config_cmd_to_config_rsp_rdata = r_iommu_wti_addr_hi.read();
    1600                 }
    1601                 else if( not read && (cell == IOB_XICU_BASE)) // WRITE XICU_BASE   
    1602                 {
    1603                     r_xicu_base = (vci_addr_t)p_vci_tgt_int.wdata.read();
    1604                 }
    1605                 else if( read && (cell == IOB_XICU_BASE))    // READ XICU_BASE   
    1606                 {
    1607                     r_config_cmd_to_config_rsp_rdata = r_xicu_base.read();
    1608                 }
    1609                 else if( not read && (cell == IOB_XICU_SIZE)) // WRITE XICU_SIZE   
    1610                 {
    1611                     r_xicu_size = (vci_addr_t)p_vci_tgt_int.wdata.read();
    1612                 }
    1613                 else if( read && (cell == IOB_XICU_SIZE))    // READ XICU_SIZE   
    1614                 {
    1615                     r_config_cmd_to_config_rsp_rdata = r_xicu_size.read();
     1686                    rdata = r_iommu_wti_addr_hi.read();
    16161687                }
    16171688                else   // Error: Wrong address, or invalid operation.
    … …  
    16201691                }
    16211692                r_config_cmd_to_config_rsp_rerror = rerror;
    1622                 r_config_cmd_fsm                 = CONFIG_CMD_RSP;
     1693                r_config_cmd_to_config_rsp_rdata  = rdata;
     1694                r_config_cmd_to_config_rsp_rsrcid = p_vci_tgt_int.srcid.read();
     1695                r_config_cmd_to_config_rsp_rtrdid = p_vci_tgt_int.trdid.read();
     1696                r_config_cmd_to_config_rsp_rpktid = p_vci_tgt_int.pktid.read();
     1697                r_config_cmd_fsm                  = CONFIG_CMD_RSP;
    16231698            }
    16241699            else if ( found )                            // remote peripheral
    16251700            {
     1701                // buffer VCI command
    16261702                r_config_cmd_address = p_vci_tgt_int.address.read();
    1627                 r_config_cmd_srcid   = p_vci_tgt_int.srcid.read();
    1628                 r_config_cmd_trdid   = p_vci_tgt_int.trdid.read();
    1629                 r_config_cmd_pktid   = p_vci_tgt_int.pktid.read();
    16301703                r_config_cmd_pktid   = p_vci_tgt_int.pktid.read();
    16311704                r_config_cmd_plen    = p_vci_tgt_int.plen.read();
    … …  
    16361709                r_config_cmd_contig  = p_vci_tgt_int.contig.read();
    16371710                r_config_cmd_cfixed  = p_vci_tgt_int.cfixed.read();
    1638 
    1639                 if( eop )                                // single flit command
    1640                 {
    1641                     if ( high )     // HI word
    1642                     {
    1643                         r_config_cmd_wdata = ((ext_data_t)p_vci_tgt_int.wdata.read())<<32;
    1644                         r_config_cmd_be    = ((ext_be_t)p_vci_tgt_int.be.read())<<4;
    1645                         r_config_cmd_eop   = true;
    1646                         r_config_cmd_fsm   = CONFIG_CMD_PUT;
    1647                     }
    1648                     else            // LO word
    1649                     {
    1650                         r_config_cmd_wdata = ((ext_data_t)p_vci_tgt_int.wdata.read());
    1651                         r_config_cmd_be    = ((ext_be_t)p_vci_tgt_int.be.read());
    1652                         r_config_cmd_eop   = true;
    1653                         r_config_cmd_fsm   = CONFIG_CMD_PUT;
    1654                     }
    1655                 }
    1656                 else                                     // multi-flits write
    1657                 {
    1658                     if ( high )     // MSB word
    1659                     {
    1660                         r_config_cmd_wdata = ((ext_data_t)p_vci_tgt_int.wdata.read())<<32;
    1661                         r_config_cmd_be    = ((ext_be_t)p_vci_tgt_int.be.read())<<4;
    1662                         r_config_cmd_eop   = false;
    1663                         r_config_cmd_fsm   = CONFIG_CMD_PUT;
    1664                     }
    1665                     else            // LSB word
    1666                     {
    1667                         r_config_cmd_wdata = ((ext_data_t)p_vci_tgt_int.wdata.read());
    1668                         r_config_cmd_be    = ((ext_be_t)p_vci_tgt_int.be.read());
    1669                         r_config_cmd_eop   = false;
    1670                         r_config_cmd_fsm   = CONFIG_CMD_NEXT;
    1671                     }
    1672                 }
    1673             }
    1674             else                                         // out of segment address
    1675             {
     1711                r_config_cmd_eop     = eop;
     1712                r_config_cmd_wdata   = (wdata << (high ? 32 : 0));
     1713                r_config_cmd_be      = (be << (high ? 4 : 0));
     1714
     1715                size_t tab_index;
     1716                if (m_iox_transaction_tab.full(tab_index))
     1717                {
     1718#ifdef INSTRUMENTATION
     1719m_cpt_trt_config_full++;
     1720#endif
     1721
     1722                    // wait for an empty slot in the IOX transaction table.
     1723                    // buffer SRCID and TRDID of VCI command to store them
     1724                    // later in IOX transaction table.
     1725                    r_config_cmd_srcid = p_vci_tgt_int.srcid.read();
     1726                    r_config_cmd_trdid = p_vci_tgt_int.trdid.read();
     1727                    r_config_cmd_fsm   = CONFIG_CMD_WAIT;
     1728                    break;
     1729                }
     1730
     1731                // TRDID in IOX interconnect is the translation table index
     1732                r_config_cmd_trdid = tab_index;
     1733
     1734                // create new entry in IOX transaction table
     1735                m_iox_transaction_tab.set( tab_index,
     1736                        p_vci_tgt_int.srcid.read(),
     1737                        p_vci_tgt_int.trdid.read());
     1738
     1739                if (eop) r_config_cmd_fsm = CONFIG_CMD_PUT;
     1740                else     r_config_cmd_fsm = CONFIG_CMD_HI;
     1741
     1742#if DEBUG_CONFIG_CMD
     1743if( m_debug_activated )
     1744{
     1745std::cout << name()
     1746          << "  <IOB CONFIG_CMD_IDLE> ### new entry in IOX transaction table"
     1747          << std::endl;
     1748m_iox_transaction_tab.printTrace();
     1749}
     1750#endif
     1751
     1752            }
     1753            else if ( eop )                                   // out of segment address
     1754            {
     1755                r_config_cmd_to_config_rsp_rerror = true;
    16761756                r_config_cmd_to_config_rsp_rdata  = 0;
    1677                 r_config_cmd_to_config_rsp_rerror = true;
    1678                 if( eop ) r_config_cmd_fsm        = CONFIG_CMD_RSP;
     1757                r_config_cmd_to_config_rsp_rsrcid = p_vci_tgt_int.srcid.read();
     1758                r_config_cmd_to_config_rsp_rtrdid = p_vci_tgt_int.trdid.read();
     1759                r_config_cmd_to_config_rsp_rpktid = p_vci_tgt_int.pktid.read();
     1760                r_config_cmd_fsm                  = CONFIG_CMD_RSP;
    16791761            }
    16801762        } // end if cmdval
    … …  
    16821764    }
    16831765    /////////////////////
    1684     case CONFIG_CMD_NEXT:  // Consume the second flit for a multi-flits write
    1685     {
    1686         if ( p_vci_tgt_int.cmdval.read() )
     1766    case CONFIG_CMD_WAIT:
     1767    {
     1768        // wait for an empty slot in the translation table.
     1769        size_t tab_index;
     1770        if (m_iox_transaction_tab.full(tab_index))
     1771        {
     1772#ifdef INSTRUMENTATION
     1773m_cpt_trt_config_full_cost++;
     1774#endif
     1775            break;
     1776        }
     1777
     1778        // create new entry in IOX transaction table
     1779        m_iox_transaction_tab.set( tab_index,
     1780                r_config_cmd_srcid.read(),
     1781                r_config_cmd_trdid.read());
     1782
     1783        // TRDID in IOX interconnect is the translation table index
     1784        r_config_cmd_trdid = tab_index;
     1785        if (r_config_cmd_eop.read()) r_config_cmd_fsm = CONFIG_CMD_PUT;
     1786        else                         r_config_cmd_fsm = CONFIG_CMD_HI;
     1787
     1788#if DEBUG_CONFIG_CMD
     1789if( m_debug_activated )
     1790{
     1791std::cout << name()
     1792          << "  <IOB CONFIG_CMD_WAIT> ### new entry in IOX transaction table"
     1793          << std::endl;
     1794m_iox_transaction_tab.printTrace();
     1795}
     1796#endif
     1797        break;
     1798    }
     1799    /////////////////////
     1800    case CONFIG_CMD_HI:  // consume the second flit for a multi-flits write
     1801    {
     1802        if ( p_vci_tgt_int.cmdval.read() )
    16871803        {
    16881804            vci_addr_t paddr = p_vci_tgt_int.address.read();
    1689             bool       high  = (paddr & 0x4 == 0x4);
     1805            bool       high  = ((paddr & 0x4) == 0x4);
    16901806            bool       eop   = p_vci_tgt_int.eop.read();
    16911807
    … …  
    17021818        break;
    17031819    }
     1820    /////////////////////
     1821    case CONFIG_CMD_LO:  // consume the first flit for a multi-flits write
     1822    {
     1823        if ( p_vci_tgt_int.cmdval.read() )
     1824        {
     1825            vci_addr_t paddr = p_vci_tgt_int.address.read();
     1826            bool       high  = ((paddr & 0x4) == 0x4);
     1827            bool       eop   = p_vci_tgt_int.eop.read();
     1828
     1829            assert( (paddr == r_config_cmd_address.read() + 4) and !high and
     1830            "ERROR in vci_io_bridge : addresses must be contiguous in write burst" );
     1831
     1832            r_config_cmd_address = p_vci_tgt_int.address.read();
     1833            r_config_cmd_wdata   = (ext_data_t)p_vci_tgt_int.wdata.read();
     1834            r_config_cmd_be      = (ext_be_t)p_vci_tgt_int.be.read();
     1835            r_config_cmd_eop     = eop;
     1836
     1837            if (eop) r_config_cmd_fsm = CONFIG_CMD_PUT;
     1838            else     r_config_cmd_fsm = CONFIG_CMD_HI;
     1839        }
     1840        break;
     1841    }
    17041842    ////////////////////
    17051843    case CONFIG_CMD_PUT:   // post a command to CONFIG_CMD fifo (to IOX network)
    … …  
    17111849
    17121850#if DEBUG_CONFIG_CMD
    1713 if( m_debug_activated )
    1714 std::cout << "  <IOB CONFIG_CMD_PUT> Transmit VCI command to IOX network"
     1851if( m_debug_activated )
     1852std::cout << name()
     1853          << "  <IOB CONFIG_CMD_PUT> Transmit VCI command to IOX network"
    17151854          << " : address = " << std::hex << r_config_cmd_address.read()
    1716           << " / srcid = " << r_config_cmd_srcid.read()
     1855          << " / srcid = " << m_iox_srcid
     1856          << " / trdid = " << r_config_cmd_trdid.read()
    17171857          << " / eop = " << r_config_cmd_eop.read()
    17181858          << std::endl;
    17191859#endif
    1720             r_config_cmd_fsm = CONFIG_CMD_IDLE;
     1860            if (r_config_cmd_eop.read()) r_config_cmd_fsm = CONFIG_CMD_IDLE;
     1861            else                         r_config_cmd_fsm = CONFIG_CMD_LO;
    17211862        }
    17221863        break;
    17231864    }
    17241865    ////////////////////
    1725     case CONFIG_CMD_RSP:   // Post a request to CONFIG_RSP FSM, 
     1866    case CONFIG_CMD_RSP:   // Post a request to CONFIG_RSP FSM,
    17261867                           // if no previous pending request.
    17271868                           // r_config_cmd_to_config_rsp_rerror
    1728                            // has been set in IDLE state. 
     1869                           // has been set in IDLE state.
    17291870    {
    17301871        if ( not r_config_cmd_to_config_rsp_req.read() )
    … …  
    17331874
    17341875#if DEBUG_CONFIG_CMD
    1735 if( m_debug_activated )
    1736 std::cout << "  <IOB CONFIG_CMD_RSP> Request a response to CONFIG_RSP FSM"
     1876if( m_debug_activated )
     1877std::cout << name()
     1878          << "  <IOB CONFIG_CMD_RSP> Request a response to CONFIG_RSP FSM"
    17371879          << " / error = " << r_config_cmd_to_config_rsp_rerror.read() << std::endl;
    17381880#endif
    … …  
    17481890    // - CONFIG_CMD : response to a local config command.
    17491891    // - CONFIG_RSP : responses from peripherals on IOX network
    1750     // Regarding the responses from IOX network it handles both single flit 
    1751     // config responses, and multi-flits read responses (ROM), where data must 
    1752     // be serialised (64 bits -> 32 bits). 
     1892    // Regarding the responses from IOX network it handles both single flit
     1893    // config responses, and multi-flits read responses (ROM), where data must
     1894    // be serialised (64 bits -> 32 bits).
    17531895    // Note: We use the VCI RPKTID field to distinguish between read cached
    17541896    // (multi-flits response) and others (single flit response).
    … …  
    17591901    if ( m_config_rsp_rerror_fifo.wok() )
    17601902    {
    1761         switch( r_config_rsp_fsm.read() ) 
     1903        switch( r_config_rsp_fsm.read() )
    17621904        {
    17631905            /////////////////////////
    17641906            case CONFIG_RSP_IDLE_IOX:  // IOX requests have highest priority
    17651907                                       // no flit on IOX network is consumed
    1766             {           
     1908            {
    17671909                if ( p_vci_ini_iox.rspval.read() )  // IOX request
    1768                     {
    1769                     if ( (p_vci_ini_iox.rpktid.read() & 0x5) == 0x1 )   // multi-flits
     1910                {
     1911                    // recover srcid and trdid from the IOX transaction table
     1912                    size_t tab_index = (size_t)p_vci_ini_iox.rtrdid.read();
     1913                    r_config_rsp_rsrcid = m_iox_transaction_tab.readSrcid(tab_index);
     1914                    r_config_rsp_rtrdid = m_iox_transaction_tab.readTrdid(tab_index);
     1915
     1916                    // erase entry
     1917                    m_iox_transaction_tab.erase(tab_index);
     1918
     1919                    if ( (p_vci_ini_iox.rpktid.read() & 0x5) == 0x1 )   // multi-flits
    17701920                    {
    1771                         r_config_rsp_fsm   = CONFIG_RSP_PUT_LOW;
     1921                        r_config_rsp_fsm   = CONFIG_RSP_PUT_LO;
    17721922                    }
    1773                     else                                                // single flit   
     1923                    else                                                // single flit
    17741924                    {
    17751925                        r_config_rsp_fsm   = CONFIG_RSP_PUT_UNC;
    17761926                    }
    1777                     }
    1778                 else if ( r_config_cmd_to_config_rsp_req.read() ) // LOC request
     1927#if DEBUG_CONFIG_RSP
     1928if( m_debug_activated )
     1929{
     1930std::cout << name()
     1931          << "  <IOB CONFIG_RSP_IDLE_IOX> ### remove entry in transaction table"
     1932          << std::endl;
     1933m_iox_transaction_tab.printTrace();
     1934}
     1935#endif
     1936                }
     1937                else if ( r_config_cmd_to_config_rsp_req.read() ) // LOCAL request
    17791938                {
    17801939                    r_config_rsp_fsm = CONFIG_RSP_PUT_LOC;
    17811940                }
    1782                     break;
     1941                break;
    17831942            }
    17841943            /////////////////////////
    1785             case CONFIG_RSP_IDLE_LOC:  // LOC requests have highest priority
     1944            case CONFIG_RSP_IDLE_LOC:  // LOCAL requests have highest priority
    17861945                                       // no flit on IOX network is consumed
    1787             {           
    1788                 if ( r_config_cmd_to_config_rsp_req.read() ) // LOC request
     1946            {
     1947                if ( r_config_cmd_to_config_rsp_req.read() ) // LOCAL request
    17891948                {
    17901949                    r_config_rsp_fsm = CONFIG_RSP_PUT_LOC;
    17911950                }
    17921951                else if ( p_vci_ini_iox.rspval.read() ) // IOX request
    1793                     {
    1794                     if ( (p_vci_ini_iox.rpktid.read() & 0x5) == 0x1 )   // multi-flits
     1952                {
     1953                    // recover srcid and trdid from the IOX transaction table
     1954                    size_t tab_index = (size_t)p_vci_ini_iox.rtrdid.read();
     1955                    r_config_rsp_rsrcid = m_iox_transaction_tab.readSrcid(tab_index);
     1956                    r_config_rsp_rtrdid = m_iox_transaction_tab.readTrdid(tab_index);
     1957
     1958                    // erase entry
     1959                    m_iox_transaction_tab.erase(tab_index);
     1960
     1961                    if ( (p_vci_ini_iox.rpktid.read() & 0x5) == 0x1 )   // multi-flits
    17951962                    {
    1796                         r_config_rsp_fsm   = CONFIG_RSP_PUT_LOW;
     1963                        r_config_rsp_fsm   = CONFIG_RSP_PUT_LO;
    17971964                    }
    1798                     else                                                // single flit   
     1965                    else                                                // single flit
    17991966                    {
    18001967                        r_config_rsp_fsm   = CONFIG_RSP_PUT_UNC;
    18011968                    }
    1802                     }
    1803                 break;
     1969#if DEBUG_CONFIG_RSP
     1970if( m_debug_activated )
     1971{
     1972std::cout << name()
     1973          << "  <IOB CONFIG_RSP_IDLE_IOX> ### remove entry in transaction table"
     1974          << std::endl;
     1975m_iox_transaction_tab.printTrace();
     1976}
     1977#endif
     1978                }
     1979                break;
    18041980            }
    18051981            ////////////////////////
    1806             case CONFIG_RSP_PUT_LOW:   // put 32 low bits into CONFIG_RSP fifo
     1982            case CONFIG_RSP_PUT_LO:   // put 32 low bits into CONFIG_RSP fifo
    18071983                                       // no flit on IOX network is consumed
    18081984            {
    … …  
    18101986                config_rsp_fifo_rerror = p_vci_ini_iox.rerror.read();
    18111987                config_rsp_fifo_rdata  = (uint32_t)p_vci_ini_iox.rdata.read();
    1812                 config_rsp_fifo_rsrcid = p_vci_ini_iox.rsrcid.read();
    1813                 config_rsp_fifo_rtrdid = p_vci_ini_iox.rtrdid.read();
     1988                config_rsp_fifo_rsrcid = r_config_rsp_rsrcid.read();
     1989                config_rsp_fifo_rtrdid = r_config_rsp_rtrdid.read();
    18141990                config_rsp_fifo_rpktid = p_vci_ini_iox.rpktid.read();
    18151991                config_rsp_fifo_reop   = false;
    … …  
    18181994
    18191995#if DEBUG_CONFIG_RSP
    1820 if( m_debug_activated )
    1821 std::cout << "  <IOB CONFIG_RSP_PUT_LOW> Push multi-flit response into CONFIG_RSP FIFO"
    1822           << " / rsrcid = " << std::hex << p_vci_ini_iox.rsrcid.read()
    1823           << " / rtrdid = " << p_vci_ini_iox.rtrdid.read()
     1996if( m_debug_activated )
     1997std::cout << name()
     1998          << "  <IOB CONFIG_RSP_PUT_LO> Push multi-flit response into CONFIG_RSP FIFO"
     1999          << " / rsrcid = " << std::hex << r_config_rsp_rsrcid.read()
     2000          << " / rtrdid = " << r_config_rsp_rtrdid.read()
    18242001          << " / rpktid = " << p_vci_ini_iox.rpktid.read()
    18252002          << " / rdata = " << (uint32_t)p_vci_ini_iox.rdata.read()
    … …  
    18272004          << " / rerror = " << p_vci_ini_iox.rerror.read() << std::endl;
    18282005#endif
    1829                 break;
     2006                break;
    18302007            }
    18312008            ///////////////////////
    18322009            case CONFIG_RSP_PUT_HI:    // put 32 high bits into CONFIG_RSP fifo
    1833                                    // flit on IOX network is consumed 
     2010                                   // flit on IOX network is consumed
    18342011            {
    18352012                config_rsp_fifo_put    = true;
    18362013                config_rsp_fifo_rerror = p_vci_ini_iox.rerror.read();
    18372014                config_rsp_fifo_rdata  = (uint32_t)(p_vci_ini_iox.rdata.read() >> 32);
    1838                 config_rsp_fifo_rsrcid = p_vci_ini_iox.rsrcid.read();
    1839                 config_rsp_fifo_rtrdid = p_vci_ini_iox.rtrdid.read();
     2015                config_rsp_fifo_rsrcid = r_config_rsp_rsrcid.read();
     2016                config_rsp_fifo_rtrdid = r_config_rsp_rtrdid.read();
    18402017                config_rsp_fifo_rpktid = p_vci_ini_iox.rpktid.read();
    18412018                config_rsp_fifo_reop   = p_vci_ini_iox.reop.read();
    18422019
    18432020                if( p_vci_ini_iox.reop.read() ) r_config_rsp_fsm = CONFIG_RSP_IDLE_LOC;
    1844                 else                            r_config_rsp_fsm = CONFIG_RSP_PUT_LOW;
     2021                else                            r_config_rsp_fsm = CONFIG_RSP_PUT_LO;
    18452022
    18462023#if DEBUG_CONFIG_RSP
    1847 if( m_debug_activated )
    1848 std::cout << "  <IOB CONFIG_RSP_PUT_HI> Push multi-flit response into CONFIG_RSP FIFO"
    1849           << " / rsrcid = " << std::hex << p_vci_ini_iox.rsrcid.read()
    1850           << " / rtrdid = " << p_vci_ini_iox.rtrdid.read()
     2024if( m_debug_activated )
     2025std::cout << name()
     2026          << "  <IOB CONFIG_RSP_PUT_HI> Push multi-flit response into CONFIG_RSP FIFO"
     2027          << " / rsrcid = " << std::hex << r_config_rsp_rsrcid.read()
     2028          << " / rtrdid = " << r_config_rsp_rtrdid.read()
    18512029          << " / rpktid = " << p_vci_ini_iox.rpktid.read()
    18522030          << " / rdata = " << (uint32_t)(p_vci_ini_iox.rdata.read() >> 32)
    … …  
    18542032          << " / rerror = " << p_vci_ini_iox.rerror.read() << std::endl;
    18552033#endif
    1856                 break;
     2034                break;
    18572035            }
    18582036            ////////////////////////
    18592037            case CONFIG_RSP_PUT_UNC:   // put single flit into CONFIG_RSP fifo
    1860                                        // flit on IOX network is consumed 
    1861             {
    1862                 assert(  p_vci_ini_iox.reop.read() and 
     2038                                       // flit on IOX network is consumed
     2039            {
     2040                assert(  p_vci_ini_iox.reop.read() and
    18632041                "ERROR in vci_io_bridge : a remote config response should be one flit");
    18642042
    … …  
    18662044                config_rsp_fifo_rerror = p_vci_ini_iox.rerror.read();
    18672045                config_rsp_fifo_rdata  = (uint32_t)p_vci_ini_iox.rdata.read();
    1868                 config_rsp_fifo_rsrcid = p_vci_ini_iox.rsrcid.read();
    1869                 config_rsp_fifo_rtrdid = p_vci_ini_iox.rtrdid.read();
     2046                config_rsp_fifo_rsrcid = r_config_rsp_rsrcid.read();
     2047                config_rsp_fifo_rtrdid = r_config_rsp_rtrdid.read();
    18702048                config_rsp_fifo_rpktid = p_vci_ini_iox.rpktid.read();
    18712049                config_rsp_fifo_reop   = true;
    … …  
    18752053
    18762054#if DEBUG_CONFIG_RSP
    1877 if( m_debug_activated )
    1878 std::cout << "  <IOB CONFIG_RSP_PUT_UNC> Push single flit response into CONFIG_RSP FIFO"
    1879           << " / rsrcid = " << std::hex << p_vci_ini_iox.rsrcid.read()
    1880           << " / rtrdid = " << p_vci_ini_iox.rtrdid.read()
     2055if( m_debug_activated )
     2056std::cout << name()
     2057          << "  <IOB CONFIG_RSP_PUT_UNC> Push single flit response into CONFIG_RSP FIFO"
     2058          << " / rsrcid = " << std::hex << r_config_rsp_rsrcid.read()
     2059          << " / rtrdid = " << r_config_rsp_rtrdid.read()
    18812060          << " / rpktid = " << p_vci_ini_iox.rpktid.read()
    18822061          << " / rdata = " << (uint32_t)p_vci_ini_iox.rdata.read()
    … …  
    18842063          << " / rerror = " << p_vci_ini_iox.rerror.read() << std::endl;
    18852064#endif
    1886                 break;
     2065                break;
    18872066            }
    18882067            ////////////////////////
    18892068            case CONFIG_RSP_PUT_LOC:   // put single flit into CONFIG_RSP fifo
    1890                                        // no flit on IOX network is consumed 
     2069                                       // no flit on IOX network is consumed
    18912070            {
    18922071                config_rsp_fifo_put    = true;
    18932072                config_rsp_fifo_rerror = r_config_cmd_to_config_rsp_rerror.read();
    18942073                config_rsp_fifo_rdata  = r_config_cmd_to_config_rsp_rdata.read();
    1895                 config_rsp_fifo_rsrcid = r_config_cmd_srcid.read();
    1896                 config_rsp_fifo_rtrdid = r_config_cmd_trdid.read();
    1897                 config_rsp_fifo_rpktid = r_config_cmd_pktid.read();
     2074                config_rsp_fifo_rsrcid = r_config_cmd_to_config_rsp_rsrcid.read();
     2075                config_rsp_fifo_rtrdid = r_config_cmd_to_config_rsp_rtrdid.read();
     2076                config_rsp_fifo_rpktid = r_config_cmd_to_config_rsp_rpktid.read();
    18982077                config_rsp_fifo_reop   = true;
    18992078
    1900                 // acknowledge request 
     2079                // acknowledge request
    19012080                r_config_cmd_to_config_rsp_req = false;
    19022081
    … …  
    19052084
    19062085#if DEBUG_CONFIG_RSP
    1907 if( m_debug_activated )
    1908 std::cout << "  <IOB CONFIG_RSP_PUT_UNC> Push single flit response into CONFIG_RSP FIFO"
    1909           << " / rsrcid = " << std::hex << r_config_cmd_srcid.read()
    1910           << " / rtrdid = " << r_config_cmd_trdid.read()
    1911           << " / rpktid = " << r_config_cmd_pktid.read()
     2086if( m_debug_activated )
     2087std::cout << name()
     2088          << "  <IOB CONFIG_RSP_PUT_UNC> Push single flit response into CONFIG_RSP FIFO"
     2089          << " / rsrcid = " << std::hex << r_config_cmd_to_config_rsp_rsrcid.read()
     2090          << " / rtrdid = " << r_config_cmd_to_config_rsp_rtrdid.read()
     2091          << " / rpktid = " << r_config_cmd_to_config_rsp_rpktid.read()
    19122092          << " / rdata = "  << r_config_cmd_to_config_rsp_rdata.read()
    19132093          << " / reop  = "  << true
    19142094          << " / rerror = " << r_config_cmd_to_config_rsp_rerror.read() << std::endl;
    19152095#endif
    1916                 break;
     2096                break;
    19172097            }
    19182098        } // end switch CONFIG_RSP FSM
    … …  
    19272107    //    MISS_WTI_RSP FSM only when the response is received.
    19282108    // 2. WTI requests from DMA_CMD FSM :
    1929     //    These requestsare non blocking events, and the r_dma_cmd_to_miss_wti_cmd_req 
    1930     //    flip-flop is reset as soon as the WTI command has been sent. 
     2109    //    These requestsare non blocking events, and the r_dma_cmd_to_miss_wti_cmd_req
     2110    //    flip-flop is reset as soon as the WTI command has been sent.
    19312111    //    There is two types of WTI requests:
    19322112    //    - external WTI from peripherals on IOX network.
    19332113    //    - internal WTI caused by illegal DMA requests.
    19342114    ////////////////////////////////////////////////////////////////////////////////////
    1935  
    1936     if ( r_tlb_to_miss_wti_cmd_req.read() and 
     2115
     2116    if ( r_tlb_to_miss_wti_cmd_req.read() and
    19372117         m_miss_wti_cmd_addr_fifo.wok() )                   // put MISS READ
    19382118    {
    19392119        miss_wti_cmd_fifo_put     = true;
    1940         miss_wti_cmd_fifo_address = r_tlb_paddr.read();     
    1941         miss_wti_cmd_fifo_wdata   = 0;                 
     2120        miss_wti_cmd_fifo_address = r_tlb_paddr.read();
     2121        miss_wti_cmd_fifo_wdata   = 0;
    19422122        miss_wti_cmd_fifo_cmd     = vci_param_int::CMD_READ;
    19432123        miss_wti_cmd_fifo_pktid   = PKTID_MISS;
    … …  
    19472127#if DEBUG_MISS_WTI_CMD
    19482128if( m_debug_activated )
    1949 std::cout << "  <IOB MISS_WTI_CMD_WTI> push MISS TLB command into MISS_WTI FIFO"
     2129std::cout << name()
     2130          << "  <IOB MISS_WTI_CMD_WTI> push MISS TLB command into MISS_WTI FIFO"
    19502131          << " / PADDR = " << miss_wti_cmd_fifo_address << std::endl;
    19512132#endif
    19522133
    19532134    }
    1954     else if ( r_dma_cmd_to_miss_wti_cmd_req.read() and 
     2135    else if ( r_dma_cmd_to_miss_wti_cmd_req.read() and
    19552136              m_miss_wti_cmd_addr_fifo.wok() )               // put WTI READ / WRITE
    19562137    {
    … …  
    19672148#if DEBUG_MISS_WTI_CMD
    19682149if( m_debug_activated )
    1969 std::cout << "  <IOB MISS_WTI_CMD_WTI> push WTI command into MISS_WTI FIFO"
     2150std::cout << name()
     2151          << "  <IOB MISS_WTI_CMD_WTI> push WTI command into MISS_WTI FIFO"
    19702152          << " / CMD = " << miss_wti_cmd_fifo_cmd
    19712153          << " / PADDR = " << miss_wti_cmd_fifo_address << std::endl;
    19722154#endif
    19732155
    1974     }     
     2156    }
    19752157
    19762158    ///////////////////////////////////////////////////////////////////////////////////
    19772159    // The MISS_WTI_RSP FSM handles VCI responses from the INT network:
    19782160    // - for a TLB MISS (multi-flits read transaction), the cache line
    1979     //   is written in r_tlb_buf_data[], and r_tlb_to_miss_wti_cmd_req flip-flop is reset. 
     2161    //   is written in r_tlb_buf_data[], and r_tlb_to_miss_wti_cmd_req flip-flop is reset.
    19802162    // - for a WTI_IOX (single flit write transaction), the response must be
    19812163    //   forwarded to the source peripheral on the INT network
    19822164    // - for a WTI_MMU (single flit write transaction), there is nothing to do.
    19832165    //
    1984     // TODO VCI addressing errors for TLB MISS or for WTI_MMU (i.e. kernel errors...) 
     2166    // TODO VCI addressing errors for TLB MISS or for WTI_MMU (i.e. kernel errors...)
    19852167    // are registered in the r_miss_wti_rsp_error_miss & r_miss_wti_rsp_error_wti
    19862168    // flip-flops, and simulation stops... They could be signaled to OS by a WTI.
    19872169    ////////////////////////////////////////////////////////////////////////////////////
    1988  
    1989     switch ( r_miss_wti_rsp_fsm.read() ) 
     2170
     2171    switch ( r_miss_wti_rsp_fsm.read() )
    19902172    {
    19912173        ///////////////////////
    … …  
    19932175                                  // no VCI flit is consumed
    19942176        {
    1995             if ( p_vci_ini_int.rspval.read() ) 
    1996             {
    1997                 if ( p_vci_ini_int.rpktid.read() == PKTID_WTI_IOX ) 
     2177            if ( p_vci_ini_int.rspval.read() )
     2178            {
     2179                if ( p_vci_ini_int.rpktid.read() == PKTID_WTI_IOX )
    19982180                {
    19992181                    r_miss_wti_rsp_fsm   = MISS_WTI_RSP_WTI_IOX;
    20002182                }
    2001                 else if ( p_vci_ini_int.rpktid.read() == PKTID_WTI_MMU ) 
     2183                else if ( p_vci_ini_int.rpktid.read() == PKTID_WTI_MMU )
    20022184                {
    20032185                    r_miss_wti_rsp_fsm   = MISS_WTI_RSP_WTI_MMU;
    … …  
    20222204                                     // if no pending previous request.
    20232205        {
    2024             assert( p_vci_ini_int.reop.read() and 
    2025             "VCI_IO_BRIDGE ERROR: WTI_IOX response should have one single flit" ); 
    2026                    
     2206            assert( p_vci_ini_int.reop.read() and
     2207            "VCI_IO_BRIDGE ERROR: WTI_IOX response should have one single flit" );
     2208
    20272209            if ( not r_miss_wti_rsp_to_dma_rsp_req.read() ) // no previous pending request
    20282210            {
    … …  
    20372219#if DEBUG_MISS_WTI_RSP
    20382220if( m_debug_activated )
    2039 std::cout << "  <IOB MISS_WTI_RSP_WTI_IOX> Transfer response to a WTI_IOX" << std::endl;
     2221std::cout << name()
     2222          << "  <IOB MISS_WTI_RSP_WTI_IOX> Transfer response to a WTI_IOX" << std::endl;
    20402223#endif
    20412224            }
    20422225            break;
    20432226        }
    2044         ////////////////////////// 
     2227        //////////////////////////
    20452228        case MISS_WTI_RSP_WTI_MMU:   // Handling response to an iommu WTI
    20462229                                     // consume VCI flit and test VCI error.
    20472230        {
    2048             assert( p_vci_ini_int.reop.read() and 
    2049             "VCI_IO_BRIDGE ERROR: WTI_MMU response should have one single flit" ); 
    2050                  
     2231            assert( p_vci_ini_int.reop.read() and
     2232            "VCI_IO_BRIDGE ERROR: WTI_MMU response should have one single flit" );
     2233
    20512234            if ( (p_vci_ini_int.rerror.read()&0x1) != 0 )  // error reported
    20522235            {
    20532236                // set the specific error flip-flop
    20542237                r_miss_wti_rsp_error_wti = true;
    2055                 assert( false and 
     2238                assert( false and
    20562239                "VCI_IO_BRIDGE ERROR: VCI error response for a WTI_MMU transaction");
    20572240            }
    20582241
    20592242#if DEBUG_MISS_WTI_RSP
    2060 if( m_debug_activated )
    2061 std::cout << " <IOB MISS_WTI_RSP_WTI_MMU> Receive response to a WTI_MMU" << std::endl;
     2243if( m_debug_activated )
     2244std::cout << name()
     2245          << " <IOB MISS_WTI_RSP_WTI_MMU> Receive response to a WTI_MMU" << std::endl;
    20622246#endif
    20632247            break;
    20642248        }
    20652249        ///////////////////////
    2066         case MISS_WTI_RSP_MISS:   // Handling response to a TLB MISS 
     2250        case MISS_WTI_RSP_MISS:   // Handling response to a TLB MISS
    20672251                                  // write cache line in r_tlb_buf buffer
    20682252                                  // and analyse possible VCI error
    20692253                                  // VCI flit is consumed.
    20702254        {
    2071             if ( p_vci_ini_int.rspval.read() ) 
     2255            if ( p_vci_ini_int.rspval.read() )
    20722256            {
    20732257                if ( (p_vci_ini_int.rerror.read()&0x1) != 0 )  // error reported
    … …  
    20752259                    // set the specific error flip-flop
    20762260                    r_miss_wti_rsp_error_miss = true;
    2077                     assert( false and 
     2261                    assert( false and
    20782262                    "VCI_IO_BRIDGE ERROR: VCI error response for a TLB MISS transaction");
    20792263
    … …  
    20822266                {
    20832267
    2084 #if DEBUG_MISS_WTI_CMD
    2085 if( m_debug_activated )
    2086 std::cout << "  <IOB MISS_WTI_RSP_MISS> Receive response to a TLB MISS"
     2268#if DEBUG_MISS_WTI_CMD
     2269if( m_debug_activated )
     2270std::cout << name()
     2271          << "  <IOB MISS_WTI_RSP_MISS> Receive response to a TLB MISS"
    20872272          << " / Count = " << r_miss_wti_rsp_count.read()
    2088           << " / Data = " << std::hex << p_vci_ini_int.rdata.read() << std::endl; 
     2273          << " / Data = " << std::hex << p_vci_ini_int.rdata.read() << std::endl;
    20892274#endif
    20902275                    r_tlb_buf_data[r_miss_wti_rsp_count.read()] = p_vci_ini_int.rdata.read();
    20912276                }
    2092                    
     2277
    20932278                if ( p_vci_ini_int.reop.read() )               // last flit
    2094                 {   
     2279                {
    20952280                    bool eop = p_vci_ini_int.eop.read();
    2096                     assert(((eop == (r_miss_wti_rsp_count.read() == (m_words-1)))) and 
     2281                    assert(((eop == (r_miss_wti_rsp_count.read() == (m_words-1)))) and
    20972282                    "VCI_IO_BRIDGE ERROR: invalid length for a TLB MISS response");
    20982283
    20992284                    r_miss_wti_rsp_count      = 0;
    21002285                    r_miss_wti_rsp_fsm        = MISS_WTI_RSP_IDLE;
    2101                     r_tlb_to_miss_wti_cmd_req = false; 
    2102                 }
    2103                 else                                           // not the last flit 
     2286                    r_tlb_to_miss_wti_cmd_req = false;
     2287                }
     2288                else                                           // not the last flit
    21042289                {
    21052290                    r_miss_wti_rsp_count = r_miss_wti_rsp_count.read() + 1;
    … …  
    21422327    m_dma_cmd_srcid_fifo.update(  dma_cmd_fifo_get,
    21432328                                  dma_cmd_fifo_put,
    2144                                   p_vci_tgt_iox.srcid.read() );
     2329                                  dma_cmd_fifo_srcid );
    21452330    m_dma_cmd_trdid_fifo.update(  dma_cmd_fifo_get,
    21462331                                  dma_cmd_fifo_put,
    … …  
    21512336    m_dma_cmd_data_fifo.update(   dma_cmd_fifo_get,
    21522337                                  dma_cmd_fifo_put,
    2153                                   p_vci_tgt_iox.wdata.read() ); 
     2338                                  p_vci_tgt_iox.wdata.read() );
    21542339    m_dma_cmd_be_fifo.update(     dma_cmd_fifo_get,
    21552340                                  dma_cmd_fifo_put,
    2156                                   p_vci_tgt_iox.be.read() ); 
     2341                                  p_vci_tgt_iox.be.read() );
    21572342    m_dma_cmd_eop_fifo.update(    dma_cmd_fifo_get,
    21582343                                  dma_cmd_fifo_put,
    … …  
    21692354    m_dma_rsp_rsrcid_fifo.update( dma_rsp_fifo_get,
    21702355                                  dma_rsp_fifo_put,
    2171                                   dma_rsp_fifo_rsrcid ); 
     2356                                  dma_rsp_fifo_rsrcid );
    21722357    m_dma_rsp_rtrdid_fifo.update( dma_rsp_fifo_get,
    21732358                                  dma_rsp_fifo_put,
    2174                                   dma_rsp_fifo_rtrdid ); 
     2359                                  dma_rsp_fifo_rtrdid );
    21752360    m_dma_rsp_rpktid_fifo.update( dma_rsp_fifo_get,
    21762361                                  dma_rsp_fifo_put,
    2177                                   dma_rsp_fifo_rpktid ); 
     2362                                  dma_rsp_fifo_rpktid );
    21782363    m_dma_rsp_reop_fifo.update(   dma_rsp_fifo_get,
    21792364                                  dma_rsp_fifo_put,
    2180                                   dma_rsp_fifo_reop );     
     2365                                  dma_rsp_fifo_reop );
    21812366    m_dma_rsp_rerror_fifo.update( dma_rsp_fifo_get,
    21822367                                  dma_rsp_fifo_put,
    … …  
    21902375    m_config_cmd_addr_fifo.update(   config_cmd_fifo_get,
    21912376                                     config_cmd_fifo_put,
    2192                                      r_config_cmd_address.read() ); 
     2377                                     r_config_cmd_address.read() );
    21932378    m_config_cmd_cmd_fifo.update(    config_cmd_fifo_get,
    21942379                                     config_cmd_fifo_put,
    2195                                      r_config_cmd_cmd.read() ); 
     2380                                     r_config_cmd_cmd.read() );
    21962381    m_config_cmd_contig_fifo.update( config_cmd_fifo_get,
    21972382                                     config_cmd_fifo_put,
    2198                                      r_config_cmd_contig.read() ); 
     2383                                     r_config_cmd_contig.read() );
    21992384    m_config_cmd_cons_fifo.update(   config_cmd_fifo_get,
    22002385                                     config_cmd_fifo_put,
    2201                                      r_config_cmd_cons.read() ); 
     2386                                     r_config_cmd_cons.read() );
    22022387    m_config_cmd_plen_fifo.update(   config_cmd_fifo_get,
    22032388                                     config_cmd_fifo_put,
    2204                                      r_config_cmd_plen.read() ); 
     2389                                     r_config_cmd_plen.read() );
    22052390    m_config_cmd_wrap_fifo.update(   config_cmd_fifo_get,
    22062391                                     config_cmd_fifo_put,
    2207                                      r_config_cmd_wrap.read() ); 
     2392                                     r_config_cmd_wrap.read() );
    22082393    m_config_cmd_cfixed_fifo.update( config_cmd_fifo_get,
    22092394                                     config_cmd_fifo_put,
    2210                                      r_config_cmd_cfixed.read() ); 
     2395                                     r_config_cmd_cfixed.read() );
    22112396    m_config_cmd_clen_fifo.update(   config_cmd_fifo_get,
    22122397                                     config_cmd_fifo_put,
    2213                                      r_config_cmd_clen.read() );
    2214     m_config_cmd_srcid_fifo.update(  config_cmd_fifo_get,
    2215                                      config_cmd_fifo_put,
    2216                                      r_config_cmd_srcid.read() );
     2398                                     r_config_cmd_clen.read() );
    22172399    m_config_cmd_trdid_fifo.update(  config_cmd_fifo_get,
    22182400                                     config_cmd_fifo_put,
    … …  
    22302412                                     config_cmd_fifo_put,
    22312413                                     r_config_cmd_eop.read() );
    2232    
     2414
    22332415    //////////////////////////////////////////////////////////////////////////
    22342416    // CONFIG_RSP fifo update
    … …  
    22382420    m_config_rsp_data_fifo.update(   config_rsp_fifo_get,
    22392421                                     config_rsp_fifo_put,
    2240                                      config_rsp_fifo_rdata ); 
     2422                                     config_rsp_fifo_rdata );
    22412423    m_config_rsp_rsrcid_fifo.update( config_rsp_fifo_get,
    22422424                                     config_rsp_fifo_put,
    … …  
    22542436                                     config_rsp_fifo_put,
    22552437                                     config_rsp_fifo_rerror );
    2256      
     2438
    22572439    ////////////////////////////////////////////////////////////////
    22582440    // MISS_WTI_CMD fifo update
    … …  
    22622444    m_miss_wti_cmd_addr_fifo.update(   miss_wti_cmd_fifo_get,
    22632445                                       miss_wti_cmd_fifo_put,
    2264                                        miss_wti_cmd_fifo_address ); 
     2446                                       miss_wti_cmd_fifo_address );
    22652447    m_miss_wti_cmd_cmd_fifo.update(    miss_wti_cmd_fifo_get,
    22662448                                       miss_wti_cmd_fifo_put,
    2267                                        miss_wti_cmd_fifo_cmd ); 
     2449                                       miss_wti_cmd_fifo_cmd );
    22682450    m_miss_wti_cmd_contig_fifo.update( config_cmd_fifo_get,
    22692451                                       miss_wti_cmd_fifo_put,
    … …  
    23022484                                       miss_wti_cmd_fifo_put,
    23032485                                       true );
    2304    
     2486
    23052487} // end transition()
    23062488
    … …  
    23132495    // VCI initiator command on RAM network
    23142496    // directly the content of the dma_cmd FIFO
    2315     p_vci_ini_ram.cmdval  = m_dma_cmd_addr_fifo.rok(); 
     2497    p_vci_ini_ram.cmdval  = m_dma_cmd_addr_fifo.rok();
    23162498    p_vci_ini_ram.address = m_dma_cmd_addr_fifo.read();
    23172499    p_vci_ini_ram.be      = m_dma_cmd_be_fifo.read();
    23182500    p_vci_ini_ram.cmd     = m_dma_cmd_cmd_fifo.read();
    23192501    p_vci_ini_ram.contig  = m_dma_cmd_contig_fifo.read();
    2320     p_vci_ini_ram.wdata   = m_dma_cmd_data_fifo.read(); 
     2502    p_vci_ini_ram.wdata   = m_dma_cmd_data_fifo.read();
    23212503    p_vci_ini_ram.eop     = m_dma_cmd_eop_fifo.read();
    23222504    p_vci_ini_ram.cons    = m_dma_cmd_cons_fifo.read();
    … …  
    23282510    p_vci_ini_ram.pktid   = m_dma_cmd_pktid_fifo.read();
    23292511    p_vci_ini_ram.srcid   = m_dma_cmd_srcid_fifo.read();
    2330    
     2512
    23312513    // VCI initiator response on the RAM Network
    23322514    // depends on the DMA_RSP FSM state
    2333         p_vci_ini_ram.rspack = m_dma_rsp_data_fifo.wok() and
    2334                            (r_dma_rsp_fsm.read() == DMA_RSP_PUT_DMA); 
     2515    p_vci_ini_ram.rspack = m_dma_rsp_data_fifo.wok() and
     2516                           (r_dma_rsp_fsm.read() == DMA_RSP_PUT_DMA);
    23352517
    23362518    /////////////////  p_vci_tgt_iox  /////////////////////////////
    … …  
    23422524    p_vci_tgt_iox.rtrdid  = m_dma_rsp_rtrdid_fifo.read();
    23432525    p_vci_tgt_iox.rpktid  = m_dma_rsp_rpktid_fifo.read();
    2344     p_vci_tgt_iox.rdata   = m_dma_rsp_data_fifo.read(); 
     2526    p_vci_tgt_iox.rdata   = m_dma_rsp_data_fifo.read();
    23452527    p_vci_tgt_iox.rerror  = m_dma_rsp_rerror_fifo.read();
    23462528    p_vci_tgt_iox.reop    = m_dma_rsp_reop_fifo.read();
    … …  
    23482530    // VCI target command ack on IOX network
    23492531    // depends on the DMA_CMD FSM state
    2350     switch ( r_dma_cmd_fsm.read() ) 
    2351     {
    2352         case DMA_CMD_IDLE:             
    2353              p_vci_tgt_iox.cmdack  = false; 
     2532    switch ( r_dma_cmd_fsm.read() )
     2533    {
     2534        case DMA_CMD_IDLE:
     2535             p_vci_tgt_iox.cmdack  = false;
    23542536             break;
    23552537        case DMA_CMD_DMA_REQ:
    2356              p_vci_tgt_iox.cmdack  = m_dma_cmd_addr_fifo.wok(); 
     2538             p_vci_tgt_iox.cmdack  = m_dma_cmd_addr_fifo.wok();
    23572539             break;
    23582540        case DMA_CMD_WTI_IOX_REQ:
    2359              p_vci_tgt_iox.cmdack  = not r_dma_cmd_to_miss_wti_cmd_req.read(); 
     2541             p_vci_tgt_iox.cmdack  = not r_dma_cmd_to_miss_wti_cmd_req.read();
    23602542             break;
    23612543        case DMA_CMD_ERR_WTI_REQ:
    2362              p_vci_tgt_iox.cmdack  = false; 
     2544             p_vci_tgt_iox.cmdack  = false;
    23632545             break;
    2364         case DMA_CMD_ERR_WAIT_EOP: 
    2365              p_vci_tgt_iox.cmdack  = true; 
     2546        case DMA_CMD_ERR_WAIT_EOP:
     2547             p_vci_tgt_iox.cmdack  = true;
    23662548             break;
    2367         case DMA_CMD_ERR_RSP_REQ: 
    2368              p_vci_tgt_iox.cmdack  = false; 
     2549        case DMA_CMD_ERR_RSP_REQ:
     2550             p_vci_tgt_iox.cmdack  = false;
    23692551             break;
    2370         case DMA_CMD_TLB_MISS_WAIT: 
    2371              p_vci_tgt_iox.cmdack  = false; 
     2552        case DMA_CMD_TLB_MISS_WAIT:
     2553             p_vci_tgt_iox.cmdack  = false;
    23722554             break;
    23732555    }
    … …  
    23822564    p_vci_ini_iox.cmd     = m_config_cmd_cmd_fifo.read();
    23832565    p_vci_ini_iox.contig  = m_config_cmd_contig_fifo.read();
    2384     p_vci_ini_iox.wdata   = m_config_cmd_data_fifo.read(); 
     2566    p_vci_ini_iox.wdata   = m_config_cmd_data_fifo.read();
    23852567    p_vci_ini_iox.eop     = m_config_cmd_eop_fifo.read();
    23862568    p_vci_ini_iox.cons    = m_config_cmd_cons_fifo.read();
    … …  
    23912573    p_vci_ini_iox.trdid   = m_config_cmd_trdid_fifo.read();
    23922574    p_vci_ini_iox.pktid   = m_config_cmd_pktid_fifo.read();
    2393     p_vci_ini_iox.srcid   = m_config_cmd_srcid_fifo.read();
    2394    
     2575    p_vci_ini_iox.srcid   = m_iox_srcid;
     2576
    23952577    // VCI initiator response on IOX Network
    23962578    // it depends on the CONFIG_RSP FSM state
    2397         p_vci_ini_iox.rspack = m_config_rsp_data_fifo.wok() and
     2579    p_vci_ini_iox.rspack = m_config_rsp_data_fifo.wok() and
    23982580                           ( (r_config_rsp_fsm.read() == CONFIG_RSP_PUT_UNC) or
    23992581                             (r_config_rsp_fsm.read() == CONFIG_RSP_PUT_HI) );
    … …  
    24042586    // directly the content of the CONFIG_RSP FIFO
    24052587    p_vci_tgt_int.rspval  = m_config_rsp_data_fifo.rok();
    2406         p_vci_tgt_int.rsrcid  = m_config_rsp_rsrcid_fifo.read();
     2588    p_vci_tgt_int.rsrcid  = m_config_rsp_rsrcid_fifo.read();
    24072589    p_vci_tgt_int.rtrdid  = m_config_rsp_rtrdid_fifo.read();
    24082590    p_vci_tgt_int.rpktid  = m_config_rsp_rpktid_fifo.read();
    … …  
    24102592    p_vci_tgt_int.rerror  = m_config_rsp_rerror_fifo.read();
    24112593    p_vci_tgt_int.reop    = m_config_rsp_reop_fifo.read();
    2412    
     2594
    24132595    // VCI target command ack on INT network
    24142596    // it depends on the CONFIG_CMD FSM state
    2415     switch ( r_config_cmd_fsm.read() ) 
     2597    switch ( r_config_cmd_fsm.read() )
    24162598    {
    24172599    case CONFIG_CMD_IDLE:
    2418         p_vci_tgt_int.cmdack  = true;
    2419         break;
    2420     case CONFIG_CMD_NEXT: 
    2421         p_vci_tgt_int.cmdack  = true;
    2422         break;
    2423     case CONFIG_CMD_PUT:         
    2424         p_vci_tgt_int.cmdack  = false;
    2425         break;
    2426     case CONFIG_CMD_RSP:         
    2427         p_vci_tgt_int.cmdack  = false;
     2600        p_vci_tgt_int.cmdack = true;
     2601        break;
     2602    case CONFIG_CMD_WAIT:
     2603        p_vci_tgt_int.cmdack = false;
     2604        break;
     2605    case CONFIG_CMD_HI:
     2606        p_vci_tgt_int.cmdack = true;
     2607        break;
     2608    case CONFIG_CMD_LO:
     2609        p_vci_tgt_int.cmdack = true;
     2610        break;
     2611    case CONFIG_CMD_PUT:
     2612        p_vci_tgt_int.cmdack = false;
     2613        break;
     2614    case CONFIG_CMD_RSP:
     2615        p_vci_tgt_int.cmdack = false;
    24282616        break;
    24292617    }
    … …  
    24312619    /////////////////  p_vci_ini_int  ////////////////////////////////
    24322620
    2433     // VCI initiator command  on INT network 
    2434     // directly the content of the MISS_WTI_CMD FIFO 
     2621    // VCI initiator command  on INT network
     2622    // directly the content of the MISS_WTI_CMD FIFO
    24352623    p_vci_ini_int.cmdval  = m_miss_wti_cmd_addr_fifo.rok();
    24362624    p_vci_ini_int.address = m_miss_wti_cmd_addr_fifo.read();
    … …  
    24382626    p_vci_ini_int.cmd     = m_miss_wti_cmd_cmd_fifo.read();
    24392627    p_vci_ini_int.contig  = m_miss_wti_cmd_contig_fifo.read();
    2440     p_vci_ini_int.wdata   = m_miss_wti_cmd_data_fifo.read(); 
     2628    p_vci_ini_int.wdata   = m_miss_wti_cmd_data_fifo.read();
    24412629    p_vci_ini_int.eop     = m_miss_wti_cmd_eop_fifo.read();
    24422630    p_vci_ini_int.cons    = m_miss_wti_cmd_cons_fifo.read();

  • trunk/modules/vci_io_bridge/include/soclib/io_bridge.h

    r712 r715  
    4141    IOB_WTI_ADDR_LO      = 7,     // R/W  : IOB WTI address (32 LSB bits)
    4242    IOB_WTI_ADDR_HI      = 8,     // R/W  : IOB WTI address (32 MSB bits)
    43     IOB_XICU_BASE        = 9,     // R/W  : XICU pbase address in cluster 0
    44     IOB_XICU_SIZE        = 10,    // R/W  : XICU segment size
    4543    /**/
    4644    IOB_SPAN             = 16,                               
Note: See TracChangeset for help on using the changeset viewer.