Changeset 549


Ignore:
Timestamp:
Oct 17, 2013, 8:50:46 PM (11 years ago)
Author:
alain
Message:

Compliance with mapping_table defined in release 2462
Introducing the dspin_router_tsar component used in tsar_generic_iob
platform to implement the RAM networt (between L2 & L3).

Location:
trunk/modules
Files:
9 added
9 edited

Legend:

Unmodified
Added
Removed

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

    r408 r549  
    3939                parameter.IntTab('tgtid'),
    4040                parameter.String('filename'),
    41                     parameter.Int('block_size'),
    42                     parameter.Int('burst_size'),
    43                     parameter.Int('latency'),
     41                    parameter.Int('block_size', default=512),
     42                    parameter.Int('burst_size', default=64),
     43                    parameter.Int('latency',    default=0),
    4444        ],
    4545

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

    r487 r549  
    296296
    297297    // STRUCTURAL PARAMETERS
    298     soclib::common::AddressDecodingTable<uint32_t, bool> m_cacheability_table;
     298    soclib::common::AddressDecodingTable<uint64_t, bool> m_cacheability_table;
    299299
    300300    const size_t                        m_srcid;
    … …  
    394394    // communication between ICACHE FSM and CC_SEND FSM
    395395    sc_signal<bool>         r_icache_cc_send_req;           // ICACHE cc_send request
    396     sc_signal<cc_send_t>    r_icache_cc_send_type;          // ICACHE cc_send request type
     396    sc_signal<int>          r_icache_cc_send_type;          // ICACHE cc_send request type
    397397    sc_signal<paddr_t>      r_icache_cc_send_nline;         // ICACHE cc_send nline
    398398    sc_signal<size_t>       r_icache_cc_send_way;           // ICACHE cc_send way
    … …  
    491491    // communication between DCACHE FSM and CC_SEND FSM
    492492    sc_signal<bool>         r_dcache_cc_send_req;           // DCACHE cc_send request
    493     sc_signal<cc_send_t>    r_dcache_cc_send_type;          // DCACHE cc_send request type
     493    sc_signal<int>          r_dcache_cc_send_type;          // DCACHE cc_send request type
    494494    sc_signal<paddr_t>      r_dcache_cc_send_nline;         // DCACHE cc_send nline
    495495    sc_signal<size_t>       r_dcache_cc_send_way;           // DCACHE cc_send way
    … …  
    542542    // communication between CC_RECEIVE FSM and ICACHE FSM
    543543    sc_signal<bool>         r_cc_receive_icache_req;        // cc_receive to icache request
    544     sc_signal<cc_receive_t> r_cc_receive_icache_type;       // cc_receive type of request
     544    sc_signal<int>          r_cc_receive_icache_type;       // cc_receive type of request
    545545    sc_signal<size_t>       r_cc_receive_icache_way;        // cc_receive to icache way
    546546    sc_signal<size_t>       r_cc_receive_icache_set;        // cc_receive to icache set
    … …  
    550550    // communication between CC_RECEIVE FSM and DCACHE FSM
    551551    sc_signal<bool>         r_cc_receive_dcache_req;        // cc_receive to dcache request
    552     sc_signal<cc_receive_t> r_cc_receive_dcache_type;       // cc_receive type of request
     552    sc_signal<int>          r_cc_receive_dcache_type;       // cc_receive type of request
    553553    sc_signal<size_t>       r_cc_receive_dcache_way;        // cc_receive to dcache way
    554554    sc_signal<size_t>       r_cc_receive_dcache_set;        // cc_receive to dcache set

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

    r532 r549  
    11551155                // cacheability
    11561156                if ( not (r_mmu_mode.read() & INS_CACHE_MASK) ) cacheable = false;
    1157                 else     cacheable = m_cacheability_table[m_ireq.addr];
     1157                else     cacheable = m_cacheability_table[(uint64_t)m_ireq.addr];
    11581158            }
    11591159            else                                                        // itlb activated
    … …  
    26472647
    26482648                    if ( not (r_mmu_mode.read() & DATA_CACHE_MASK) ) cacheable = false;
    2649                     else cacheable = m_cacheability_table[m_dreq.addr];
     2649                    else cacheable = m_cacheability_table[(uint64_t)m_dreq.addr];
    26502650                }
    26512651                else                                                                       // dtlb activated

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

    r451 r549  
    9393    };
    9494
    95 const char *miss_wti_fsm_state_str[] = {
    96         "MISS_WTI_IDLE_MISS",
    97         "MISS_WTI_IDLE_WTI",
     95const char *miss_wti_cmd_state_str[] =
     96    { 
     97        "MISS_WTI_CMD_IDLE",
    9898        "MISS_WTI_CMD_WTI",
     99        "MISS_WTI_CMD_MISS",
     100    };
     101const char *miss_wti_rsp_state_str[] =
     102    { 
     103        "MISS_WTI_RSP_IDLE",
    99104        "MISS_WTI_RSP_WTI",
    100         "MISS_WTI_CMD_MISS",
    101105        "MISS_WTI_RSP_MISS",
    102106    };
    … …  
    268272        std::cout << "    => segment " << int_seg->name()
    269273                  << " / base = " << std::hex << int_seg->baseAddress()
    270                   << " / size = " << int_seg->size() << std::endl;
     274                  << " / size = " << int_seg->size()
     275                  << " / special = " << int_seg->special() << std::endl;
    271276    }
    272277
    … …  
    332337////////////////////////////////////
    333338{
    334     // b0 : IOtlb trace
     339    // b0 : IOTLB trace
    335340
    336341    std::cout << std::dec << "IO_BRIDGE " << name() << std::endl;
    … …  
    341346              << " | " << config_cmd_fsm_state_str[r_config_cmd_fsm.read()]
    342347              << " | " << config_rsp_fsm_state_str[r_config_rsp_fsm.read()]
    343               << " | " << miss_wti_fsm_state_str[r_miss_wti_cmd_fsm.read()]
     348              << " | " << miss_wti_cmd_state_str[r_miss_wti_cmd_fsm.read()]
     349              << " | " << miss_wti_rsp_state_str[r_miss_wti_rsp_fsm.read()]
    344350              << std::endl;
    345351
    … …  
    348354        std::cout << "  IOTLB" << std::endl;
    349355        r_iotlb.printTrace();
    350     }
    351     if(mode & 0x02)
    352     {
    353        
    354356    }
    355357}
    … …  
    12481250            // chek segments
    12491251            std::list<soclib::common::Segment>::iterator seg;
    1250             bool found = false;
     1252            bool found   = false;
     1253            bool special = false;
    12511254            for ( seg = m_int_seglist.begin() ;
    12521255                  seg != m_int_seglist.end() and not found ; seg++ )
    12531256            {
    1254                 if ( seg->contains(paddr) )  found = true;
     1257                if ( seg->contains(paddr) ) 
     1258                {
     1259                   found   = true;
     1260                   special = seg->special();
     1261                }
    12551262            }
    12561263           
    1257             if ( found and seg->special() )  // IO_BRIDGE itself
     1264            if ( found and special )  // IO_BRIDGE itself
    12581265            {
    12591266                uint32_t      rdata  = 0;
    … …  
    19881995
    19891996    // VCI initiator command  on INT network
    1990     // it depends on the MISS_WTI_CMD FSM state
     1997    // it depends on the MISS_WTI_CMD FSM state   
     1998    // - WTI : single flit WRITE
     1999    // - MISS TLB : multi-flit READ for a complete cache line
    19912000
    19922001    // default values
    … …  
    19972006    p_vci_ini_int.wrap    = false;
    19982007    p_vci_ini_int.clen    = 0;
    1999     p_vci_ini_int.contig  = false;
    2000     p_vci_ini_int.cons    = true;
    2001     p_vci_ini_int.be      = 0xFF;
     2008    p_vci_ini_int.contig  = true;
     2009    p_vci_ini_int.cons    = false;
     2010    p_vci_ini_int.be      = 0xF;
    20022011   
    20032012    switch ( r_miss_wti_cmd_fsm.read() )

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

    r451 r549  
    2727 */
    2828
    29 //////////////////////////////////////////////////////////////////////////////
     29////////////////////////////////////////////////////////////////////////////////
    3030// This component emulates an external IO bus such as PCIe or Hypertransport,
    31 // but respect the VCI protocol.
    32 // It is considered as a local interconnect that must be attached to
    33 // one OR SEVERAL clusters in a global interconnect.
    34 // It uses two different routing table:
    35 // - the cmd_routing_table decodes the local field of the VCI address
    36 //   to return the target port
    37 // - The rsp_routing_table decodes the local field of the VCI srcid
     31// but respect the VCI protocol. It can be attached to one OR SEVERAL clusters,
     32// using a vci_io_bridge component.
     33// It is considered as a local interconnect, for the ADDRESS or SRCID
     34// decoding tables:
     35// - the CMD routing_table decodes the local field of the VCI ADDRESS
     36//   to return the local target port
     37// - The RSP routing_table decodes the local field of the VCI SRCID
    3838//   to return the initator port
    3939// It is implemented as two independant crossbars, for VCI commands and
    4040// VCI responses respectively.
    41 // - The CMD crossbar has nb_ini input ports, and nb_tgt output ports.
     41// - The CMD crossbar has nb_ini input ports, and nb_tgt output ports,
     42//   including the ports to the vci_io_bridge component(s).
    4243// - The RSP crossbar has nb_tgt input ports, and nb_ini output ports.
     44//   including the ports to the vci_io_bridge component(s).
    4345// For both crossbars, output ports allocation policy is round robin.
    44 //////////////////////////////////////////////////////////////////////////////
     46////////////////////////////////////////////////////////////////////////////////
    4547
    4648#ifndef VCI_IOX_NETWORK_H
    … …  
    9193
    9294    AddressDecodingTable<uint64_t,size_t>    m_cmd_rt;    // routing table for CMD
    93     AddressDecodingTable<uint64_t,size_t>    m_rsp_rt;    // routing table for RSP
     95    AddressDecodingTable<uint32_t,size_t>    m_rsp_rt;    // routing table for RSP
    9496
    9597    void transition();
    … …  
    108110    VciIoxNetwork( sc_module_name                      name,
    109111                                   const soclib::common::MappingTable  &mt,
    110                    size_t                              cluster_id,
    111112                                   size_t                              nb_tgt,
    112113                                   size_t                              nb_ini );

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

    r471 r549  
    2626 */
    2727
     28////////////////////////////////////////////////////////////////////////////////
     29// This component emulates an external IO bus such as PCIe or Hypertransport,
     30// but respect the VCI protocol. It can be attached to one OR SEVERAL clusters,
     31// using a vci_io_bridge component.
     32// It is considered as a local interconnect, for the ADDRESS or SRCID
     33// decoding tables:
     34// - the CMD routing_table decodes the local field of the VCI ADDRESS
     35//   to return the local target port
     36// - The RSP routing_table decodes the local field of the VCI SRCID
     37//   to return the initator port
     38// It is implemented as two independant crossbars, for VCI commands and
     39// VCI responses respectively.
     40// - The CMD crossbar has nb_ini input ports, and nb_tgt output ports,
     41//   including the ports to the vci_io_bridge component(s).
     42// - The RSP crossbar has nb_tgt input ports, and nb_ini output ports.
     43//   including the ports to the vci_io_bridge component(s).
     44// For both crossbars, output ports allocation policy is round robin.
     45////////////////////////////////////////////////////////////////////////////////
     46
    2847#include <systemc>
    2948#include <cassert>
    … …  
    5069    typedef typename pkt_t::output_port_t   output_port_t;
    5170
    52     const bool                              m_is_cmd;         // CMD XBAR if true
    53     const size_t                                    m_inputs;         // number of inputs
    54     const size_t                                    m_outputs;        // number of outputs
    55     AddressDecodingTable<uint64_t,size_t>*  m_rt;             // pointer on routing table (CMD or RSP)
    56 
    57     sc_signal<bool>*                            r_out_allocated;  // for each output: allocation state
    58     sc_signal<size_t>*                          r_out_origin;     // for each output: input port index
    59     sc_signal<bool>*                            r_in_allocated;   // for each input: allocation state
    60     sc_signal<size_t>*                          r_in_dest;        // for each input: output port index
     71    const bool            m_is_cmd;         // CMD XBAR if true
     72    const size_t                  m_inputs;         // number of inputs
     73    const size_t                  m_outputs;        // number of outputs
     74    void*                 m_rt;             // pointer on routing table (CMD or RSP)
     75
     76    sc_signal<bool>*      r_out_allocated;  // for each output: allocation state
     77    sc_signal<size_t>*    r_out_origin;     // for each output: input port index
     78    sc_signal<bool>*      r_in_allocated;   // for each input: allocation state
     79    sc_signal<size_t>*    r_in_dest;        // for each input: output port index
    6180
    6281public:
    6382    ///////////////////////
    64     IoXbar( bool                                    is_cmd,
    65             size_t                                  nb_inputs,
    66             size_t                                  nb_outputs,
    67                 AddressDecodingTable<uint64_t,size_t>*  rt )
     83    IoXbar( bool   is_cmd,
     84            size_t nb_inputs,
     85            size_t nb_outputs,
     86                void*  rt )
    6887        : m_is_cmd( is_cmd ),
    6988      m_inputs( nb_inputs ),
    … …  
    150169                        if ( m_is_cmd )
    151170                        {
    152                             req = ((AddressDecodingTable<uint64_t,size_t>*)m_rt)->get_value(
    153                                    (uint64_t)(input_port[in]->address.read()) );
     171                            AddressDecodingTable<uint64_t, size_t>* rt =
     172                               (AddressDecodingTable<uint64_t, size_t>*)m_rt;
     173                            req = rt->get_value((uint64_t)(input_port[in]->address.read()));
    154174                        }
    155175                        else           
    156176                        {
    157                             req = ((AddressDecodingTable<uint64_t,size_t>*)m_rt)->get_value(
    158                                    (uint64_t)(input_port[in]->rsrcid.read()) );
     177                            AddressDecodingTable<uint32_t, size_t>* rt =
     178                               (AddressDecodingTable<uint32_t, size_t>*)m_rt;
     179                            req = rt->get_value((uint32_t)(input_port[in]->rsrcid.read()));
    159180                        }
    160181                        // allocate the output port if requested
    … …  
    260281tmpl(/**/)::VciIoxNetwork( sc_core::sc_module_name             name,
    261282                               const soclib::common::MappingTable  &mt,
    262                            size_t                              cluster_id,
    263283                                           size_t                              nb_tgt,
    264284                                           size_t                              nb_ini )
    … …  
    274294           m_nb_ini( nb_ini ),
    275295
    276            m_cmd_rt( mt.getPortidFromAddress(cluster_id) ),
    277            m_rsp_rt( mt.getPortidFromSrcid(cluster_id) )
     296           m_cmd_rt( mt.getLocalIndexFromAddress(0) ),
     297           m_rsp_rt( mt.getLocalIndexFromSrcid(0) )
    278298{
    279299    std::cout << "    Building VciIoxNetwork : " << name << std::endl;

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

    r535 r549  
    516516
    517517      void print_stats(bool activity_counters, bool stats);
    518       void print_trace();
     518      void print_trace( size_t detailed = 0 );
    519519      void cache_monitor(addr_t addr);
    520520      void start_monitor(addr_t addr, addr_t length);

  • trunk/modules/vci_mem_cache/caba/source/include/xram_transaction.h

    r489 r549  
    2929    bool                        proc_read;          // read request from processor
    3030    size_t                  read_length;    // length of the read (for the response)
    31     size_t                  word_index;         // index of the first read word (for the response)
     31    size_t                  word_index;         // index of the first read word (for response)
    3232    std::vector<data_t> wdata;          // write buffer (one cache line)
    3333    std::vector<be_t>   wdata_be;       // be for each data in the write buffer
    … …  
    4848    /////////////////////////////////////////////////////////////////////
    4949    // The alloc() function initializes the vectors of an entry
    50     // Its arguments are :
    51     // - n_words : number of words per line in the cache
     50    // The "n_words" argument is the number of words in a cache line.
    5251    /////////////////////////////////////////////////////////////////////
    5352    void alloc(size_t n_words)
    … …  
    6463    ////////////////////////////////////////////////////////////////////
    6564    // The copy() function copies an existing entry
    66     // Its arguments are :
    67     // - source : the transaction tab entry to copy
    6865    ////////////////////////////////////////////////////////////////////
    6966    void copy(const TransactionTabEntry &source)
    … …  
    8683
    8784    ////////////////////////////////////////////////////////////////////
    88     // The print() function prints the entry
    89     ////////////////////////////////////////////////////////////////////
    90     void print()
    91     {
    92         std::cout << "------- TRT entry -------" << std::endl;
    93         std::cout << "valid       = " << valid        << std::endl;
    94         std::cout << "xram_read   = " << xram_read    << std::endl;
    95         std::cout << "nline       = " << std::hex << nline << std::endl;
    96         std::cout << "srcid       = " << srcid        << std::endl;
    97         std::cout << "trdid       = " << trdid        << std::endl;
    98         std::cout << "pktid       = " << pktid        << std::endl;
    99         std::cout << "proc_read   = " << proc_read    << std::endl;
    100         std::cout << "read_length = " << read_length  << std::endl;
    101         std::cout << "word_index  = " << word_index   << std::endl;
    102         for(size_t i=0; i<wdata_be.size() ; i++)
    103         {
    104             std::cout << "wdata_be[" << std::dec << i << "] = "
    105                       << std::hex << wdata_be[i] << std::endl;
    106         }
    107         for(size_t i=0; i<wdata.size() ; i++)
    108         {
    109             std::cout << "wdata[" << std::dec << i << "] = "
    110                       << std::hex << wdata[i] << std::endl;
    111         }
    112         std::cout << "rerror      = " << rerror       << std::endl;
    113         std::cout << "ll_key      = " << ll_key       << std::endl;
    114         std::cout << "config      = " << config       << std::endl;
    115         std::cout << std::endl;
     85    // The print() function prints the entry identified by "index".
     86    ////////////////////////////////////////////////////////////////////
     87    void print( size_t index, size_t mode )
     88    {
     89        std::cout << "  TRT[" << std::dec << index << "] "
     90                  << " valid = " << valid
     91                  << " / error = " << rerror
     92                  << " / get = " << xram_read
     93                  << " / config = " << config << std::hex
     94                  << " / address = " << nline*4*wdata.size()
     95                  << " / srcid = " << srcid << std::endl;
     96        if ( mode )
     97        {
     98            std::cout << "        trdid = " << trdid
     99                      << " / pktid = " << pktid << std::dec
     100                      << " / proc_read = " << proc_read
     101                      << " / read_length = " << read_length
     102                      << " / word_index  = " << word_index << std::hex
     103                      << " / ll_key = " << ll_key << std::endl;
     104            std::cout << "        wdata = ";
     105            for(size_t i=0; i<wdata.size() ; i++)
     106            {
     107                std::cout << std::hex << wdata[i] << " / ";
     108            }
     109            std::cout << std::endl;
     110        }
    116111    }
    117112
    … …  
    228223    }
    229224    /////////////////////////////////////////////////////////////////////
    230     // The print() function prints a transaction tab entry
    231     // Arguments :
    232     // - index : the index of the entry to print
    233     /////////////////////////////////////////////////////////////////////
    234     void print(const size_t index)
    235     {
    236         assert( (index < size_tab) and
    237         "MEMC ERROR: The selected entry is out of range in TRT write_data_mask()");
    238 
    239         tab[index].print();
    240         return;
     225    // The print() function prints TRT content.
     226    // Detailed content if detailed argument is non zero.
     227    /////////////////////////////////////////////////////////////////////
     228    void print( size_t detailed = 0 )
     229    {
     230        std::cout << "  < TRT content in " <<  tab_name << " >" << std::endl;
     231        for ( size_t id = 0 ; id < size_tab ; id++ )
     232        {
     233            tab[id].print( id , detailed );
     234        }
    241235    }
    242236    /////////////////////////////////////////////////////////////////////

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

    r537 r549  
    654654
    655655    //////////////////////////////////////////////////
    656     tmpl(void)::print_trace()
     656    tmpl(void)::print_trace( size_t detailed )
    657657    //////////////////////////////////////////////////
    658658    {
    … …  
    676676            << " | " << alloc_ivt_fsm_str[r_alloc_ivt_fsm.read()]
    677677            << " | " << alloc_heap_fsm_str[r_alloc_heap_fsm.read()] << std::endl;
     678
     679        if ( detailed ) m_trt.print(0);
    678680    }
    679681
    … …  
    40114013
    40124014                        assert( ((p_vci_ixr.rerror.read() & 0x1) == 0) and
    4013                                 "MEMC ERROR in IXR_RSP state: XRAM response error !");
     4015                        "MEMC ERROR in IXR_RSP state: XRAM response error !");
    40144016
    40154017                        if (p_vci_ixr.reop.read())   // PUT
    … …  
    40184020
    40194021#if DEBUG_MEMC_IXR_RSP
    4020                             if (m_debug)
    4021                                 std::cout << "  <MEMC " << name()
    4022                                     << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
     4022if (m_debug)
     4023std::cout << "  <MEMC " << name()
     4024          << " IXR_RSP_IDLE> Response from XRAM to a put transaction" << std::endl;
    40234025#endif
    40244026                        }
    … …  
    40284030
    40294031#if DEBUG_MEMC_IXR_RSP
    4030                             if (m_debug)
    4031                                 std::cout << "  <MEMC " << name()
    4032                                     << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
    4033 #endif
    4034                         }
    4035                     }
    4036                     break;
    4037                 }
    4038                 ////////////////////////
     4032if (m_debug)
     4033std::cout << "  <MEMC " << name()
     4034          << " IXR_RSP_IDLE> Response from XRAM to a get transaction" << std::endl;
     4035#endif
     4036                        }
     4037                    }
     4038                    break;
     4039                }
     4040            ////////////////////////
    40394041            case IXR_RSP_TRT_ERASE:   // erase the entry in the TRT
    4040                 // decrease the line counter if config request
    4041                 {
    4042                     if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
    4043                     {
    4044                         size_t  index = r_ixr_rsp_trt_index.read();
    4045                         if (m_trt.is_config(index)) r_config_rsp_lines = r_config_rsp_lines.read() - 1;
    4046                         m_trt.erase(index);
     4042                                      // decrease the line counter if config request
     4043            {
     4044                if (r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP)
     4045                {
     4046                    size_t  index = r_ixr_rsp_trt_index.read();
     4047                    if (m_trt.is_config(index))
     4048                        r_config_rsp_lines = r_config_rsp_lines.read() - 1;
     4049                    m_trt.erase(index);
     4050                    r_ixr_rsp_fsm = IXR_RSP_IDLE;
     4051
     4052#if DEBUG_MEMC_IXR_RSP
     4053if (m_debug)
     4054std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
     4055          << r_ixr_rsp_trt_index.read() << std::endl;
     4056#endif
     4057                }
     4058                break;
     4059            }
     4060            //////////////////////
     4061            case IXR_RSP_TRT_READ:    // write a 64 bits data word in TRT
     4062            {
     4063                if ((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
     4064                {
     4065                    size_t      index    = r_ixr_rsp_trt_index.read();
     4066                    size_t      word     = r_ixr_rsp_cpt.read();
     4067                    bool        eop      = p_vci_ixr.reop.read();
     4068                    wide_data_t data     = p_vci_ixr.rdata.read();
     4069                    bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
     4070
     4071                    assert(((eop == (word == (m_words-2))) or error) and
     4072                    "MEMC ERROR in IXR_RSP_TRT_READ state : invalid response from XRAM");
     4073
     4074                    m_trt.write_rsp( index, word, data );
     4075
     4076                    r_ixr_rsp_cpt = word + 2;
     4077
     4078                    if (eop )
     4079                    {
     4080                        r_ixr_rsp_to_xram_rsp_rok[r_ixr_rsp_trt_index.read()] = true;
    40474081                        r_ixr_rsp_fsm = IXR_RSP_IDLE;
     4082                    }
    40484083
    40494084#if DEBUG_MEMC_IXR_RSP
    4050                         if (m_debug)
    4051                             std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_ERASE> Erase TRT entry "
    4052                                 << r_ixr_rsp_trt_index.read() << std::endl;
    4053 #endif
    4054                     }
    4055                     break;
    4056                 }
    4057                 //////////////////////
    4058             case IXR_RSP_TRT_READ:    // write a 64 bits data word in TRT
    4059                 {
    4060                     if ((r_alloc_trt_fsm.read() == ALLOC_TRT_IXR_RSP) and  p_vci_ixr.rspval)
    4061                     {
    4062                         size_t      index    = r_ixr_rsp_trt_index.read();
    4063                         size_t      word     = r_ixr_rsp_cpt.read();
    4064                         bool        eop      = p_vci_ixr.reop.read();
    4065                         wide_data_t data     = p_vci_ixr.rdata.read();
    4066                         bool        error    = ((p_vci_ixr.rerror.read() & 0x1) == 1);
    4067 
    4068                         assert(((eop == (word == (m_words-2))) or error) and
    4069                                 "MEMC ERROR in IXR_RSP_TRT_READ state : invalid response from XRAM");
    4070 
    4071                         m_trt.write_rsp( index,
    4072                                 word,
    4073                                 data );
    4074 
    4075                         r_ixr_rsp_cpt = word + 2;
    4076 
    4077                         if (eop )
    4078                         {
    4079                             r_ixr_rsp_to_xram_rsp_rok[r_ixr_rsp_trt_index.read()] = true;
    4080                             r_ixr_rsp_fsm = IXR_RSP_IDLE;
    4081                         }
    4082 
    4083 #if DEBUG_MEMC_IXR_RSP
    4084                         if (m_debug)
    4085                             std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing 2 words in TRT : "
    4086                                 << " index = " << std::dec << index
    4087                                 << " / word = " << word
    4088                                 << " / data = " << std::hex << data << std::endl;
    4089 #endif
    4090                     }
    4091                     break;
    4092                 }
     4085if (m_debug)
     4086std::cout << "  <MEMC " << name() << " IXR_RSP_TRT_READ> Writing 2 words in TRT : "
     4087          << " index = " << std::dec << index
     4088          << " / word = " << word
     4089          << " / data = " << std::hex << data << std::endl;
     4090#endif
     4091                }
     4092                break;
     4093            }
    40934094        } // end swich r_ixr_rsp_fsm
    40944095
Note: See TracChangeset for help on using the changeset viewer.