Changeset 824


Ignore:
Timestamp:
Sep 30, 2014, 4:53:01 PM (8 years ago)
Author:
devigne
Message:

RWT Commit : cc_vcache_wrapper cosmetic (remove trailing whitespace and tabulation)

Location:
branches/RWT/modules/vci_cc_vcache_wrapper/caba/source
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r805 r824  
    5656
    5757////////////////////////////////////////////
    58 template<typename vci_param, 
     58template<typename vci_param,
    5959         size_t   dspin_in_width,
    6060         size_t   dspin_out_width,
     
    6767    typedef typename vci_param::fast_addr_t  paddr_t;
    6868
    69     enum icache_fsm_state_e 
     69    enum icache_fsm_state_e
    7070    {
    7171        ICACHE_IDLE,
     
    9494    };
    9595
    96     enum dcache_fsm_state_e 
     96    enum dcache_fsm_state_e
    9797    {
    9898        DCACHE_IDLE,
     
    108108        DCACHE_TLB_LR_WAIT,
    109109        DCACHE_TLB_RETURN,
    110             // handling processor XTN requests
     110        // handling processor XTN requests
    111111        DCACHE_XTN_SWITCH,
    112112        DCACHE_XTN_SYNC,
     
    128128        DCACHE_DIRTY_GET_PTE,
    129129        DCACHE_DIRTY_WAIT,
    130             // handling processor miss requests
     130        // handling processor miss requests
    131131        DCACHE_MISS_SELECT,
    132132        DCACHE_MISS_CLEAN,
     
    148148    };
    149149
    150     enum cmd_fsm_state_e 
     150    enum cmd_fsm_state_e
    151151    {
    152152        CMD_IDLE,
     
    162162    };
    163163
    164     enum rsp_fsm_state_e 
     164    enum rsp_fsm_state_e
    165165    {
    166166        RSP_IDLE,
     
    173173    };
    174174
    175     enum cc_receive_fsm_state_e 
     175    enum cc_receive_fsm_state_e
    176176    {
    177177        CC_RECEIVE_IDLE,
     
    190190    };
    191191
    192     enum cc_send_fsm_state_e 
     192    enum cc_send_fsm_state_e
    193193    {
    194194        CC_SEND_IDLE,
     
    228228
    229229    // cc_send_type
    230     typedef enum 
     230    typedef enum
    231231    {
    232232        CC_TYPE_CLEANUP,
     
    235235
    236236    // cc_receive_type
    237     typedef enum 
     237    typedef enum
    238238    {
    239239        CC_TYPE_CLACK,
     
    244244
    245245    // TLB Mode : ITLB / DTLB / ICACHE / DCACHE
    246     enum 
     246    enum
    247247    {
    248248        INS_TLB_MASK    = 0x8,
     
    256256    {
    257257        MMU_NONE                      = 0x0000, // None
    258         MMU_WRITE_PT1_UNMAPPED        = 0x0001, // Write & Page fault on PT1
    259         MMU_WRITE_PT2_UNMAPPED        = 0x0002, // Write & Page fault on PT2
     258        MMU_WRITE_PT1_UNMAPPED        = 0x0001, // Write & Page fault on PT1
     259        MMU_WRITE_PT2_UNMAPPED        = 0x0002, // Write & Page fault on PT2
    260260        MMU_WRITE_PRIVILEGE_VIOLATION = 0x0004, // Write & Protected access in user mode
    261261        MMU_WRITE_ACCES_VIOLATION     = 0x0008, // Write to non writable page
     
    264264        MMU_WRITE_PT2_ILLEGAL_ACCESS  = 0x0080, // Write & Bus Error accessing PT2
    265265        MMU_WRITE_DATA_ILLEGAL_ACCESS = 0x0100, // Write & Bus Error in cache access
    266         MMU_READ_PT1_UNMAPPED         = 0x1001, // Read & Page fault on PT1
    267         MMU_READ_PT2_UNMAPPED         = 0x1002, // Read & Page fault on PT2
     266        MMU_READ_PT1_UNMAPPED         = 0x1001, // Read & Page fault on PT1
     267        MMU_READ_PT2_UNMAPPED         = 0x1002, // Read & Page fault on PT2
    268268        MMU_READ_PRIVILEGE_VIOLATION  = 0x1004, // Read & Protected access in user mode
    269269        MMU_READ_EXEC_VIOLATION       = 0x1010, // Read & Exec access to a non exec page
    270         MMU_READ_UNDEFINED_XTN        = 0x1020, // Read & Undefined external access
     270        MMU_READ_UNDEFINED_XTN        = 0x1020, // Read & Undefined external access
    271271        MMU_READ_PT1_ILLEGAL_ACCESS   = 0x1040, // Read & Bus Error accessing PT1
    272272        MMU_READ_PT2_ILLEGAL_ACCESS   = 0x1080, // Read & Bus Error accessing PT2
     
    310310    const size_t                        m_cc_global_id;
    311311    const size_t                        m_nline_width;
    312     const size_t                                                m_itlb_ways;
    313     const size_t                                                m_itlb_sets;
    314     const size_t                                                m_dtlb_ways;
    315     const size_t                                                m_dtlb_sets;
    316     const size_t                                                m_icache_ways;
    317     const size_t                                                m_icache_sets;
    318     const paddr_t                                               m_icache_yzmask;
    319     const size_t                                                m_icache_words;
    320     const size_t                                                m_dcache_ways;
    321     const size_t                                                m_dcache_sets;
    322     const paddr_t                                               m_dcache_yzmask;
    323     const size_t                                                m_dcache_words;
     312    const size_t                        m_itlb_ways;
     313    const size_t                        m_itlb_sets;
     314    const size_t                        m_dtlb_ways;
     315    const size_t                        m_dtlb_sets;
     316    const size_t                        m_icache_ways;
     317    const size_t                        m_icache_sets;
     318    const paddr_t                       m_icache_yzmask;
     319    const size_t                        m_icache_words;
     320    const size_t                        m_dcache_ways;
     321    const size_t                        m_dcache_sets;
     322    const paddr_t                       m_dcache_yzmask;
     323    const size_t                        m_dcache_words;
    324324    const size_t                        m_x_width;
    325325    const size_t                        m_y_width;
    326326    const size_t                        m_proc_id;
    327     const uint32_t                                              m_max_frozen_cycles;
    328     const size_t                                                m_paddr_nbits;
     327    const uint32_t                      m_max_frozen_cycles;
     328    const size_t                        m_paddr_nbits;
    329329    uint32_t                            m_debug_start_cycle;
    330330    bool                                m_debug_ok;
     
    342342
    343343    /////////////////////////////////////////////
    344     // debug variables 
     344    // debug variables
    345345    /////////////////////////////////////////////
    346346    bool                                m_debug_previous_i_hit;
     
    351351    // Software visible REGISTERS
    352352    ///////////////////////////////
    353     sc_signal<uint32_t>     r_mmu_ptpr;                 // page table pointer register
    354     sc_signal<uint32_t>     r_mmu_mode;                 // mmu mode register
    355     sc_signal<uint32_t>     r_mmu_word_lo;              // mmu misc data low
    356     sc_signal<uint32_t>     r_mmu_word_hi;              // mmu misc data hight
    357     sc_signal<uint32_t>     r_mmu_ibvar;                // mmu bad instruction address
    358     sc_signal<uint32_t>     r_mmu_dbvar;                // mmu bad data address
    359     sc_signal<uint32_t>     r_mmu_ietr;                 // mmu instruction error type
    360     sc_signal<uint32_t>     r_mmu_detr;                 // mmu data error type
    361     uint32_t                r_mmu_params;                       // read-only
    362     uint32_t                r_mmu_release;                      // read_only
     353    sc_signal<uint32_t>     r_mmu_ptpr;      // page table pointer register
     354    sc_signal<uint32_t>     r_mmu_mode;      // mmu mode register
     355    sc_signal<uint32_t>     r_mmu_word_lo;   // mmu misc data low
     356    sc_signal<uint32_t>     r_mmu_word_hi;   // mmu misc data hight
     357    sc_signal<uint32_t>     r_mmu_ibvar;     // mmu bad instruction address
     358    sc_signal<uint32_t>     r_mmu_dbvar;     // mmu bad data address
     359    sc_signal<uint32_t>     r_mmu_ietr;      // mmu instruction error type
     360    sc_signal<uint32_t>     r_mmu_detr;      // mmu data error type
     361    uint32_t                r_mmu_params;    // read-only
     362    uint32_t                r_mmu_release;   // read_only
    363363
    364364
     
    368368    sc_signal<int>          r_icache_fsm;               // state register
    369369    sc_signal<int>          r_icache_fsm_save;          // return state for coherence op
    370     sc_signal<paddr_t>      r_icache_vci_paddr;         // physical address
     370    sc_signal<paddr_t>      r_icache_vci_paddr;         // physical address
    371371    sc_signal<uint32_t>     r_icache_vaddr_save;        // virtual address from processor
    372372
    373373    // icache miss handling
    374     sc_signal<size_t>       r_icache_miss_way;              // selected way for cache update
    375     sc_signal<size_t>       r_icache_miss_set;              // selected set for cache update
    376     sc_signal<size_t>       r_icache_miss_word;             // word index ( cache update)
     374    sc_signal<size_t>       r_icache_miss_way;          // selected way for cache update
     375    sc_signal<size_t>       r_icache_miss_set;          // selected set for cache update
     376    sc_signal<size_t>       r_icache_miss_word;         // word index ( cache update)
    377377    sc_signal<bool>         r_icache_miss_inval;        // coherence request matching a miss
    378378    sc_signal<bool>         r_icache_miss_clack;        // waiting for a cleanup acknowledge
    379379
    380380    // coherence request handling
    381     sc_signal<size_t>       r_icache_cc_way;                // selected way for cc update/inval
    382     sc_signal<size_t>       r_icache_cc_set;                // selected set for cc update/inval
    383     sc_signal<size_t>       r_icache_cc_word;               // word counter for cc update
     381    sc_signal<size_t>       r_icache_cc_way;            // selected way for cc update/inval
     382    sc_signal<size_t>       r_icache_cc_set;            // selected set for cc update/inval
     383    sc_signal<size_t>       r_icache_cc_word;           // word counter for cc update
    384384    sc_signal<bool>         r_icache_cc_need_write;     // activate the cache for writing
    385385
    386386    // coherence clack handling
    387387    sc_signal<bool>         r_icache_clack_req;         // clack request
    388     sc_signal<size_t>       r_icache_clack_way;             // clack way
    389     sc_signal<size_t>       r_icache_clack_set;             // clack set
     388    sc_signal<size_t>       r_icache_clack_way;         // clack way
     389    sc_signal<size_t>       r_icache_clack_set;         // clack set
    390390
    391391    // icache flush handling
    392     sc_signal<size_t>       r_icache_flush_count;           // slot counter used for cache flush
     392    sc_signal<size_t>       r_icache_flush_count;       // slot counter used for cache flush
    393393
    394394    // communication between ICACHE FSM and VCI_CMD FSM
     
    397397
    398398    // communication between ICACHE FSM and DCACHE FSM
    399     sc_signal<bool>             r_icache_tlb_miss_req;       // (set icache/reset dcache)
     399    sc_signal<bool>         r_icache_tlb_miss_req;       // (set icache/reset dcache)
    400400    sc_signal<bool>         r_icache_tlb_rsp_error;      // tlb miss response error
    401401
    402402    // Flip-Flop in ICACHE FSM for saving the cleanup victim request
    403     sc_signal<bool>         r_icache_cleanup_victim_req; 
     403    sc_signal<bool>         r_icache_cleanup_victim_req;
    404404    sc_signal<paddr_t>      r_icache_cleanup_victim_nline;
    405405
     
    427427    sc_signal<uint32_t>     r_dcache_save_be;           // byte enable (from proc)
    428428    sc_signal<paddr_t>      r_dcache_save_paddr;        // physical address
    429     sc_signal<size_t>       r_dcache_save_cache_way;    // selected way (from dcache)
    430     sc_signal<size_t>       r_dcache_save_cache_set;    // selected set (from dcache)
    431     sc_signal<size_t>       r_dcache_save_cache_word;   // selected word (from dcache)
     429    sc_signal<size_t>       r_dcache_save_cache_way;    // selected way (from dcache)
     430    sc_signal<size_t>       r_dcache_save_cache_set;    // selected set (from dcache)
     431    sc_signal<size_t>       r_dcache_save_cache_word;   // selected word (from dcache)
    432432    // registers used by the Dirty bit sub-fsm
    433433    sc_signal<paddr_t>      r_dcache_dirty_paddr;       // PTE physical address
    434     sc_signal<size_t>       r_dcache_dirty_way;         // way to invalidate in dcache
    435     sc_signal<size_t>       r_dcache_dirty_set;         // set to invalidate in dcache
     434    sc_signal<size_t>       r_dcache_dirty_way;         // way to invalidate in dcache
     435    sc_signal<size_t>       r_dcache_dirty_set;         // set to invalidate in dcache
    436436
    437437    // communication between DCACHE FSM and VCI_CMD FSM
    438     sc_signal<paddr_t>      r_dcache_vci_paddr;             // physical address for VCI command
    439     sc_signal<uint32_t>     r_dcache_vci_wdata;             // write unc data for VCI command
     438    sc_signal<paddr_t>      r_dcache_vci_paddr;         // physical address for VCI command
     439    sc_signal<uint32_t>     r_dcache_vci_wdata;         // write unc data for VCI command
    440440    sc_signal<bool>         r_dcache_vci_miss_req;      // read miss request
    441441    sc_signal<bool>         r_dcache_vci_unc_req;       // uncacheable request (read/write)
     
    456456
    457457    // register used for XTN inval
    458     sc_signal<size_t>       r_dcache_xtn_way;               // selected way (from dcache)
    459     sc_signal<size_t>       r_dcache_xtn_set;               // selected set (from dcache)
     458    sc_signal<size_t>       r_dcache_xtn_way;           // selected way (from dcache)
     459    sc_signal<size_t>       r_dcache_xtn_set;           // selected set (from dcache)
    460460
    461461    // handling dcache miss
    462     sc_signal<int>              r_dcache_miss_type;                 // depending on the requester
    463     sc_signal<size_t>       r_dcache_miss_word;             // word index for cache update
    464     sc_signal<size_t>       r_dcache_miss_way;              // selected way for cache update
    465     sc_signal<size_t>       r_dcache_miss_set;              // selected set for cache update
     462    sc_signal<int>          r_dcache_miss_type;         // depending on the requester
     463    sc_signal<size_t>       r_dcache_miss_word;         // word index for cache update
     464    sc_signal<size_t>       r_dcache_miss_way;          // selected way for cache update
     465    sc_signal<size_t>       r_dcache_miss_set;          // selected set for cache update
    466466    sc_signal<bool>         r_dcache_miss_inval;        // coherence request matching a miss
    467467    sc_signal<bool>         r_dcache_miss_clack;        // waiting for a cleanup acknowledge
    468468
    469469    // handling coherence requests
    470     sc_signal<size_t>       r_dcache_cc_way;                // selected way for cc update/inval
    471     sc_signal<size_t>       r_dcache_cc_set;                // selected set for cc update/inval
     470    sc_signal<size_t>       r_dcache_cc_way;            // selected way for cc update/inval
     471    sc_signal<size_t>       r_dcache_cc_set;            // selected set for cc update/inval
    472472    sc_signal<int>          r_dcache_cc_state;          // state of selected cache slot
    473     sc_signal<size_t>       r_dcache_cc_word;               // word counter for cc update
     473    sc_signal<size_t>       r_dcache_cc_word;           // word counter for cc update
    474474    sc_signal<bool>         r_dcache_cc_need_write;     // activate the cache for writing
    475475    sc_signal<paddr_t>      r_dcache_cc_inval_addr;     // address for a cleanup transaction
     
    478478    // coherence clack handling
    479479    sc_signal<bool>         r_dcache_clack_req;         // clack request
    480     sc_signal<size_t>       r_dcache_clack_way;             // clack way
    481     sc_signal<size_t>       r_dcache_clack_set;             // clack set
     480    sc_signal<size_t>       r_dcache_clack_way;         // clack way
     481    sc_signal<size_t>       r_dcache_clack_set;         // clack set
    482482
    483483    // dcache flush handling
    484     sc_signal<size_t>       r_dcache_flush_count;           // slot counter used for cache flush
     484    sc_signal<size_t>       r_dcache_flush_count;       // slot counter used for cache flush
    485485
    486486    // ll response handling
    487     sc_signal<size_t>       r_dcache_ll_rsp_count;          // flit counter used for ll rsp
     487    sc_signal<size_t>       r_dcache_ll_rsp_count;      // flit counter used for ll rsp
    488488
    489489    // used by the TLB miss sub-fsm
    490     sc_signal<uint32_t>     r_dcache_tlb_vaddr;             // virtual address for a tlb miss
    491     sc_signal<bool>         r_dcache_tlb_ins;               // target tlb (itlb if true)
    492     sc_signal<paddr_t>      r_dcache_tlb_paddr;             // physical address of pte
    493     sc_signal<uint32_t>     r_dcache_tlb_pte_flags;         // pte1 or first word of pte2
    494     sc_signal<uint32_t>     r_dcache_tlb_pte_ppn;           // second word of pte2
    495     sc_signal<size_t>       r_dcache_tlb_cache_way;         // selected way in dcache
    496     sc_signal<size_t>       r_dcache_tlb_cache_set;         // selected set in dcache
    497     sc_signal<size_t>       r_dcache_tlb_cache_word;    // selected word in dcache
    498     sc_signal<size_t>       r_dcache_tlb_way;               // selected way in tlb
    499     sc_signal<size_t>       r_dcache_tlb_set;               // selected set in tlb
     490    sc_signal<uint32_t>     r_dcache_tlb_vaddr;         // virtual address for a tlb miss
     491    sc_signal<bool>         r_dcache_tlb_ins;           // target tlb (itlb if true)
     492    sc_signal<paddr_t>      r_dcache_tlb_paddr;         // physical address of pte
     493    sc_signal<uint32_t>     r_dcache_tlb_pte_flags;     // pte1 or first word of pte2
     494    sc_signal<uint32_t>     r_dcache_tlb_pte_ppn;       // second word of pte2
     495    sc_signal<size_t>       r_dcache_tlb_cache_way;     // selected way in dcache
     496    sc_signal<size_t>       r_dcache_tlb_cache_set;     // selected set in dcache
     497    sc_signal<size_t>       r_dcache_tlb_cache_word;    // selected word in dcache
     498    sc_signal<size_t>       r_dcache_tlb_way;           // selected way in tlb
     499    sc_signal<size_t>       r_dcache_tlb_set;           // selected set in tlb
    500500
    501501    // ITLB and DTLB invalidation
    502     sc_signal<paddr_t>      r_dcache_tlb_inval_line;    // line index
     502    sc_signal<paddr_t>      r_dcache_tlb_inval_line;    // line index
    503503    sc_signal<size_t>       r_dcache_tlb_inval_set;     // tlb set counter
    504504
     
    508508
    509509    // Filp-Flop in DCACHE FSM for saving the cleanup victim request
    510     sc_signal<bool>         r_dcache_cleanup_victim_req; 
     510    sc_signal<bool>         r_dcache_cleanup_victim_req;
    511511    sc_signal<bool>         r_dcache_cleanup_victim_line_ncc;
    512512    sc_signal<bool>         r_dcache_cleanup_victim_updt_data;
     
    551551    ///////////////////////////////////
    552552    sc_signal<int>          r_vci_cmd_fsm;
    553     sc_signal<size_t>       r_vci_cmd_min;                      // used for write bursts
    554     sc_signal<size_t>       r_vci_cmd_max;                      // used for write bursts
    555     sc_signal<size_t>       r_vci_cmd_cpt;                      // used for write bursts
    556     sc_signal<bool>         r_vci_cmd_imiss_prio;               // round-robin between imiss & dmiss
     553    sc_signal<size_t>       r_vci_cmd_min;                  // used for write bursts
     554    sc_signal<size_t>       r_vci_cmd_max;                  // used for write bursts
     555    sc_signal<size_t>       r_vci_cmd_cpt;                  // used for write bursts
     556    sc_signal<bool>         r_vci_cmd_imiss_prio;           // round-robin between imiss & dmiss
    557557
    558558    ///////////////////////////////////
     
    563563    sc_signal<bool>         r_vci_rsp_ins_error;
    564564    sc_signal<bool>         r_vci_rsp_data_error;
    565     GenericFifo<uint32_t>   r_vci_rsp_fifo_icache;              // response FIFO to ICACHE FSM
    566     GenericFifo<uint32_t>   r_vci_rsp_fifo_dcache;              // response FIFO to DCACHE FSM
     565    GenericFifo<uint32_t>   r_vci_rsp_fifo_icache;          // response FIFO to ICACHE FSM
     566    GenericFifo<uint32_t>   r_vci_rsp_fifo_dcache;          // response FIFO to DCACHE FSM
    567567
    568568
     
    595595    sc_signal<size_t>       r_cc_receive_icache_set;        // cc_receive to icache set
    596596    sc_signal<size_t>       r_cc_receive_icache_updt_tab_idx;  // cc_receive update table index
    597     sc_signal<paddr_t>      r_cc_receive_icache_nline;      // cache line physical address
     597    sc_signal<paddr_t>      r_cc_receive_icache_nline;      // cache line physical address
    598598
    599599    // communication between CC_RECEIVE FSM and DCACHE FSM
     
    603603    sc_signal<size_t>       r_cc_receive_dcache_set;              // cc_receive to dcache set
    604604    sc_signal<size_t>       r_cc_receive_dcache_updt_tab_idx;     // cc_receive update table index
    605     sc_signal<paddr_t>      r_cc_receive_dcache_nline;            // cache line physical address
     605    sc_signal<paddr_t>      r_cc_receive_dcache_nline;            // cache line physical address
    606606    sc_signal<bool>         r_cc_receive_dcache_inval_is_config;  // inval from memcache is config
    607607
     
    611611    sc_signal<bool>         r_dspin_clack_req;
    612612    sc_signal<uint64_t>     r_dspin_clack_flit;
    613    
     613
    614614    //////////////////////////////////////////////////////////////////
    615615    // processor, write buffer, caches , TLBs
     
    617617
    618618    iss_t                       r_iss;
    619     MultiWriteBuffer<paddr_t>   r_wbuf;
    620     GenericCache<paddr_t>       r_icache;
    621     GenericCache<paddr_t>       r_dcache;
    622     GenericTlb<paddr_t>         r_itlb;
    623     GenericTlb<paddr_t>         r_dtlb;
     619    MultiWriteBuffer<paddr_t>   r_wbuf;
     620    GenericCache<paddr_t>       r_icache;
     621    GenericCache<paddr_t>       r_dcache;
     622    GenericTlb<paddr_t>         r_itlb;
     623    GenericTlb<paddr_t>         r_dtlb;
    624624
    625625    //////////////////////////////////////////////////////////////////
     
    648648    uint32_t m_cpt_icache_dir_write;           // ICACHE DIR WRITE
    649649
    650     uint32_t m_cpt_frz_cycles;                 // number of cycles where the cpu is frozen
    651     uint32_t m_cpt_total_cycles;                   // total number of cycles
     650    uint32_t m_cpt_frz_cycles;                 // number of cycles where the cpu is frozen
     651    uint32_t m_cpt_total_cycles;               // total number of cycles
    652652
    653653    // Cache activity counters
     
    764764    uint32_t m_cpt_fsm_cc_send    [64];
    765765
    766     uint32_t m_cpt_stop_simulation;             // used to stop simulation if frozen
    767     bool     m_monitor_ok;                      // used to debug cache output 
    768     uint32_t m_monitor_base;               
    769     uint32_t m_monitor_length;             
     766    uint32_t m_cpt_stop_simulation;     // used to stop simulation if frozen
     767    bool     m_monitor_ok;              // used to debug cache output
     768    uint32_t m_monitor_base;
     769    uint32_t m_monitor_length;
    770770
    771771protected:
     
    807807    void start_monitor(paddr_t,paddr_t);
    808808    void stop_monitor();
    809     inline void iss_set_debug_mask(uint v) 
    810     {
    811             r_iss.set_debug_mask(v);
     809    inline void iss_set_debug_mask(uint v)
     810    {
     811        r_iss.set_debug_mask(v);
    812812    }
    813813
  • branches/RWT/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r805 r824  
    3434#include "../include/vci_cc_vcache_wrapper.h"
    3535
    36 #define DEBUG_DCACHE            1
    37 #define DEBUG_ICACHE            1
    38 #define DEBUG_CMD               0
     36#define DEBUG_DCACHE        1
     37#define DEBUG_ICACHE        1
     38#define DEBUG_CMD           0
    3939#define INSTRUMENTATION     1
    4040
     
    137137const char *vci_pktid_type_str[] = {
    138138        "TYPE_DATA_UNC",
    139         "TYPE_READ_DATA_MISS",           
    140         "TYPE_READ_INS_UNC",         
     139        "TYPE_READ_DATA_MISS",
     140        "TYPE_READ_INS_UNC",
    141141        "TYPE_READ_INS_MISS",
    142142        "TYPE_WRITE",
     
    199199/////////////////////////////////
    200200tmpl(/**/)::VciCcVCacheWrapper(
    201     sc_module_name                      name,
    202     const int                           proc_id,
    203     const MappingTable      &mtd,
    204     const IntTab                &srcid,
    205     const size_t                cc_global_id,
    206     const size_t                        itlb_ways,
    207     const size_t                        itlb_sets,
    208     const size_t                        dtlb_ways,
    209     const size_t                        dtlb_sets,
    210     const size_t                        icache_ways,
    211     const size_t                        icache_sets,
    212     const size_t                        icache_words,
    213     const size_t                        dcache_ways,
    214     const size_t                        dcache_sets,
    215     const size_t                        dcache_words,
    216     const size_t                        wbuf_nlines,
    217     const size_t                        wbuf_nwords,
    218     const size_t                        x_width,
    219     const size_t                        y_width,
    220     const uint32_t                      max_frozen_cycles,
    221     const uint32_t                      debug_start_cycle,
    222     const bool                          debug_ok )
     201    sc_module_name          name,
     202    const int               proc_id,
     203    const MappingTable      &mtd,
     204    const IntTab            &srcid,
     205    const size_t            cc_global_id,
     206    const size_t            itlb_ways,
     207    const size_t            itlb_sets,
     208    const size_t            dtlb_ways,
     209    const size_t            dtlb_sets,
     210    const size_t            icache_ways,
     211    const size_t            icache_sets,
     212    const size_t            icache_words,
     213    const size_t            dcache_ways,
     214    const size_t            dcache_sets,
     215    const size_t            dcache_words,
     216    const size_t            wbuf_nlines,
     217    const size_t            wbuf_nwords,
     218    const size_t            x_width,
     219    const size_t            y_width,
     220    const uint32_t          max_frozen_cycles,
     221    const uint32_t          debug_start_cycle,
     222    const bool              debug_ok )
    223223    : soclib::caba::BaseModule(name),
    224224
     
    379379      r_vci_rsp_ins_error("r_vci_rsp_ins_error"),
    380380      r_vci_rsp_data_error("r_vci_rsp_data_error"),
    381       r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2),        // 2 words depth
    382       r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),        // 2 words depth
     381      r_vci_rsp_fifo_icache("r_vci_rsp_fifo_icache", 2),    // 2 words depth
     382      r_vci_rsp_fifo_dcache("r_vci_rsp_fifo_dcache", 2),    // 2 words depth
    383383      r_vci_rsp_fifo_rpktid("r_vci_rsp_fifo_rpktid", 2),    // 2 words depth
    384384      r_cc_send_data_fifo("r_cc_send_data_fifo", 16),
     
    390390      r_cc_receive_data_ins("r_cc_receive_data_ins"),
    391391      r_cc_receive_word_idx("r_cc_receive_word_idx"),
    392       r_cc_receive_updt_fifo_be("r_cc_receive_updt_fifo_be", 2),        // 2 words depth
    393       r_cc_receive_updt_fifo_data("r_cc_receive_updt_fifo_data", 2),    // 2 words depth
    394       r_cc_receive_updt_fifo_eop("r_cc_receive_updt_fifo_eop", 2),      // 2 words depth
     392      r_cc_receive_updt_fifo_be("r_cc_receive_updt_fifo_be", 2),     // 2 words depth
     393      r_cc_receive_updt_fifo_data("r_cc_receive_updt_fifo_data", 2), // 2 words depth
     394      r_cc_receive_updt_fifo_eop("r_cc_receive_updt_fifo_eop", 2),   // 2 words depth
    395395
    396396      r_cc_receive_icache_req("r_cc_receive_icache_req"),
     
    559559{
    560560    bool        cache_hit;
    561     size_t          cache_way = 0;
    562     size_t          cache_set = 0;
    563     size_t          cache_word = 0;
    564     uint32_t    cache_rdata = 0;
     561    size_t      cache_way = 0;
     562    size_t      cache_set = 0;
     563    size_t      cache_word = 0;
     564    uint32_t    cache_rdata = 0;
    565565
    566566    cache_hit = r_dcache.read_neutral( addr,
     
    574574        std::cout << "Monitor PROC " << name()
    575575                  << " DCACHE at cycle " << std::dec << m_cpt_total_cycles
    576                   << " / HIT = " << cache_hit 
     576                  << " / HIT = " << cache_hit
    577577                  << " / PADDR = " << std::hex << addr
    578                   << " / DATA = " << cache_rdata 
     578                  << " / DATA = " << cache_rdata
    579579                  << " / WAY = " << cache_way << std::endl;
    580             m_debug_previous_d_hit = cache_hit;
     580        m_debug_previous_d_hit = cache_hit;
    581581    }
    582582
     
    591591        std::cout << "Monitor PROC " << name()
    592592                  << " ICACHE at cycle " << std::dec << m_cpt_total_cycles
    593                   << " / HIT = " << cache_hit 
     593                  << " / HIT = " << cache_hit
    594594                  << " / PADDR = " << std::hex << addr
    595                   << " / DATA = " << cache_rdata 
     595                  << " / DATA = " << cache_rdata
    596596                  << " / WAY = " << cache_way << std::endl;
    597             m_debug_previous_i_hit = cache_hit;
     597        m_debug_previous_i_hit = cache_hit;
    598598    }
    599599}
     
    810810        r_mmu_mode = 0x3;
    811811
    812             // No request from ICACHE FSM to CMD FSM
     812        // No request from ICACHE FSM to CMD FSM
    813813        r_icache_miss_req          = false;
    814814        r_icache_unc_req           = false;
     
    865865        m_debug_previous_i_hit     = false;
    866866        m_debug_previous_d_hit     = false;
    867         m_debug_activated              = false;
     867        m_debug_activated          = false;
    868868
    869869        // SPECIAL REGISTERS ODCCP
     
    944944        m_cost_data_tlb_occup_cache_frz  = 0;
    945945
    946         m_cpt_ins_tlb_inval       = 0;
    947         m_cpt_data_tlb_inval      = 0;
    948         m_cost_ins_tlb_inval_frz  = 0;
    949         m_cost_data_tlb_inval_frz = 0;
     946        m_cpt_ins_tlb_inval       = 0;
     947        m_cpt_data_tlb_inval      = 0;
     948        m_cost_ins_tlb_inval_frz  = 0;
     949        m_cost_data_tlb_inval_frz = 0;
    950950
    951951        m_cpt_cc_broadcast   = 0;
    952952
    953             m_cost_updt_data_frz  = 0;
    954             m_cost_inval_ins_frz  = 0;
    955             m_cost_inval_data_frz = 0;
    956             m_cost_broadcast_frz  = 0;
    957 
    958             m_cpt_cc_cleanup_data = 0;
    959             m_cpt_cc_cleanup_ins  = 0;
     953        m_cost_updt_data_frz  = 0;
     954        m_cost_inval_ins_frz  = 0;
     955        m_cost_inval_data_frz = 0;
     956        m_cost_broadcast_frz  = 0;
     957
     958        m_cpt_cc_cleanup_data = 0;
     959        m_cpt_cc_cleanup_ins  = 0;
    960960
    961961        m_cpt_cleanup_data_not_dirty  = 0;
     
    986986        m_cpt_read              = 0;
    987987        m_cpt_write             = 0;
    988             m_cpt_cc_update_data = 0;
    989             m_cpt_cc_inval_ins   = 0;
    990             m_cpt_cc_inval_data  = 0;
     988        m_cpt_cc_update_data = 0;
     989        m_cpt_cc_inval_ins   = 0;
     990        m_cpt_cc_inval_data  = 0;
    991991*/
    992992
     
    11061106    {
    11071107    /////////////////
    1108     case ICACHE_IDLE:   // In this state, we handle processor requests, XTN requests,
     1108    case ICACHE_IDLE:   // In this state, we handle processor requests, XTN requests,
    11091109                        // and coherence requests with a fixed priority:
    11101110                        // 1/ Coherence requests                        => ICACHE_CC_CHECK
     
    11831183        if ( m_ireq.valid )
    11841184        {
    1185             bool            cacheable;
    1186             paddr_t         paddr;
     1185            bool        cacheable;
     1186            paddr_t     paddr;
    11871187            bool        tlb_hit = false;
    11881188            pte_info_t  tlb_flags;
     
    12421242            //   and there is no access rights checking
    12431243
    1244             if ( not (r_mmu_mode.read() & INS_TLB_MASK) )       // tlb not activated:
     1244            if ( not (r_mmu_mode.read() & INS_TLB_MASK) )   // tlb not activated:
    12451245            {
    12461246                // cacheability
     
    12481248                else     cacheable = m_cacheability_table[(uint64_t)m_ireq.addr];
    12491249            }
    1250             else                                                        // itlb activated
    1251             {
    1252                 if ( tlb_hit )  // ITLB hit
     1250            else                          // itlb activated
     1251            {
     1252                if ( tlb_hit )  // ITLB hit
    12531253                {
    12541254                    // cacheability
     
    12951295            {
    12961296
    1297                 if (cache_state == CACHE_SLOT_STATE_EMPTY)          // cache miss
     1297                if (cache_state == CACHE_SLOT_STATE_EMPTY)      // cache miss
    12981298                {
    12991299
     
    13051305#if DEBUG_ICACHE
    13061306if ( m_debug_activated )
    1307 std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache" 
     1307std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ MISS in icache"
    13081308          << " : PADDR = " << std::hex << paddr << std::endl;
    13091309#endif
    13101310                   r_icache_miss_req = true;
    13111311                }
    1312                 else if (cache_state == CACHE_SLOT_STATE_ZOMBI )        // pending cleanup
     1312                else if (cache_state == CACHE_SLOT_STATE_ZOMBI )    // pending cleanup
    13131313                {
    13141314                    // stalled until cleanup is acknowledged
    13151315                    r_icache_fsm       = ICACHE_IDLE;
    13161316                }
    1317                 else                                                // cache hit
     1317                else                                       // cache hit
    13181318                {
    13191319
     
    13271327#if DEBUG_ICACHE
    13281328if ( m_debug_activated )
    1329 std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache" 
     1329std::cout << "  <PROC " << name() << " ICACHE_IDLE> READ HIT in icache"
    13301330          << " : PADDR = " << std::hex << paddr
    13311331          << " / INST  = " << cache_inst << std::dec << std::endl;
     
    13331333                }
    13341334            }
    1335             else                // non cacheable read
     1335            else               // non cacheable read
    13361336            {
    13371337                r_icache_unc_req  = true;
     
    13421342{
    13431343    std::cout << "  <PROC " << name()
    1344               << " ICACHE_IDLE> READ UNCACHEABLE in icache" 
     1344              << " ICACHE_IDLE> READ UNCACHEABLE in icache"
    13451345              << " : PADDR = " << std::hex << paddr << std::endl;
    13461346}
     
    13511351    }
    13521352    /////////////////////
    1353     case ICACHE_TLB_WAIT:       // Waiting the itlb update by the DCACHE FSM after a tlb miss
     1353    case ICACHE_TLB_WAIT:   // Waiting the itlb update by the DCACHE FSM after a tlb miss
    13541354                            // the itlb is udated by the DCACHE FSM, as well as the
    13551355                            // r_mmu_ietr and r_mmu_ibvar registers in case of error.
     
    13861386                r_icache_fsm             = ICACHE_IDLE;
    13871387            }
    1388             else                                // tlb updated : return to IDLE state
     1388            else                // tlb updated : return to IDLE state
    13891389            {
    13901390                r_icache_fsm  = ICACHE_IDLE;
     
    13941394    }
    13951395    //////////////////////////
    1396     case ICACHE_XTN_TLB_FLUSH:          // invalidate in one cycle all non global TLB entries
     1396    case ICACHE_XTN_TLB_FLUSH:      // invalidate in one cycle all non global TLB entries
    13971397    {
    13981398        r_itlb.flush();
     
    14021402    }
    14031403    ////////////////////////////
    1404     case ICACHE_XTN_CACHE_FLUSH:        // Invalidate sequencially all cache lines, using
     1404    case ICACHE_XTN_CACHE_FLUSH:    // Invalidate sequencially all cache lines, using
    14051405                                    // r_icache_flush_count as a slot counter,
    1406                                         // looping in this state until all slots are visited.
     1406                                    // looping in this state until all slots are visited.
    14071407                                    // It can require two cycles per slot:
    14081408                                    // We test here the slot state, and make the actual inval
    14091409                                    // (if line is valid) in ICACHE_XTN_CACHE_FLUSH_GO state.
    1410                                         // A cleanup request is generated for each valid line
     1410                                    // A cleanup request is generated for each valid line
    14111411    {
    14121412        // coherence clack interrupt
     
    14301430            int       state;
    14311431            paddr_t   tag;
    1432             size_t        way = r_icache_flush_count.read()/m_icache_sets;
    1433             size_t        set = r_icache_flush_count.read()%m_icache_sets;
     1432            size_t    way = r_icache_flush_count.read()/m_icache_sets;
     1433            size_t    set = r_icache_flush_count.read()%m_icache_sets;
    14341434
    14351435#ifdef INSTRUMENTATION
     
    14571457                      (m_icache_sets*m_icache_ways - 1) )  // last slot
    14581458            {
    1459                 r_dcache_xtn_req = false;
     1459                r_dcache_xtn_req = false;
    14601460                m_drsp.valid     = true;
    1461                 r_icache_fsm    = ICACHE_IDLE;
     1461                r_icache_fsm    = ICACHE_IDLE;
    14621462            }
    14631463
     
    14721472    }
    14731473    ///////////////////////////////
    1474     case ICACHE_XTN_CACHE_FLUSH_GO:         // Switch slot state to ZOMBI for an XTN flush
    1475     {
    1476         size_t    way = r_icache_miss_way.read();
    1477         size_t    set = r_icache_miss_set.read();
     1474    case ICACHE_XTN_CACHE_FLUSH_GO:     // Switch slot state to ZOMBI for an XTN flush
     1475    {
     1476        size_t  way = r_icache_miss_way.read();
     1477        size_t  set = r_icache_miss_set.read();
    14781478
    14791479#ifdef INSTRUMENTATION
     
    14881488                      (m_icache_sets*m_icache_ways - 1) )  // last slot
    14891489        {
    1490                 r_dcache_xtn_req = false;
     1490            r_dcache_xtn_req = false;
    14911491            m_drsp.valid     = true;
    1492                 r_icache_fsm    = ICACHE_IDLE;
     1492            r_icache_fsm    = ICACHE_IDLE;
    14931493        }
    14941494        else
     
    15001500
    15011501    //////////////////////////
    1502     case ICACHE_XTN_TLB_INVAL:          // invalidate one TLB entry selected by the virtual address
    1503                                                     // stored in the r_dcache_save_wdata register
     1502    case ICACHE_XTN_TLB_INVAL:      // invalidate one TLB entry selected by the virtual address
     1503                                    // stored in the r_dcache_save_wdata register
    15041504    {
    15051505        r_itlb.inval(r_dcache_save_wdata.read());
     
    15091509    }
    15101510    ///////////////////////////////
    1511     case ICACHE_XTN_CACHE_INVAL_VA:     // Selective cache line invalidate with virtual address
     1511    case ICACHE_XTN_CACHE_INVAL_VA: // Selective cache line invalidate with virtual address
    15121512                                    // requires 3 cycles (in case of hit on itlb and icache).
    1513                                                         // In this state, access TLB to translate virtual address
    1514                                                     // stored in the r_dcache_save_wdata register.
    1515     {
    1516         paddr_t         paddr;
    1517         bool            hit;
     1513                                    // In this state, access TLB to translate virtual address
     1514                                    // stored in the r_dcache_save_wdata register.
     1515    {
     1516        paddr_t paddr;
     1517        bool    hit;
    15181518
    15191519        // read physical address in TLB when MMU activated
    1520         if ( r_mmu_mode.read() & INS_TLB_MASK )         // itlb activated
     1520        if ( r_mmu_mode.read() & INS_TLB_MASK )     // itlb activated
    15211521        {
    15221522
     
    15271527                                   &paddr);
    15281528        }
    1529         else                                            // itlb not activated
    1530         {
    1531             paddr       = (paddr_t)r_dcache_save_wdata.read();
    1532             hit         = true;
    1533         }
    1534 
    1535         if ( hit )              // continue the selective inval process
     1529        else                        // itlb not activated
     1530        {
     1531            paddr   = (paddr_t)r_dcache_save_wdata.read();
     1532            hit     = true;
     1533        }
     1534
     1535        if ( hit )      // continue the selective inval process
    15361536        {
    15371537            r_icache_vci_paddr    = paddr;
    15381538            r_icache_fsm          = ICACHE_XTN_CACHE_INVAL_PA;
    15391539        }
    1540         else                    // miss : send a request to DCACHE FSM
     1540        else            // miss : send a request to DCACHE FSM
    15411541        {
    15421542
     
    15451545#endif
    15461546            r_icache_tlb_miss_req = true;
    1547                 r_icache_vaddr_save   = r_dcache_save_wdata.read();
     1547            r_icache_vaddr_save   = r_dcache_save_wdata.read();
    15481548            r_icache_fsm          = ICACHE_TLB_WAIT;
    15491549        }
     
    15511551    }
    15521552    ///////////////////////////////
    1553     case ICACHE_XTN_CACHE_INVAL_PA:     // selective invalidate cache line with physical address
     1553    case ICACHE_XTN_CACHE_INVAL_PA: // selective invalidate cache line with physical address
    15541554                                    // require 2 cycles. In this state, we read directory
    15551555                                    // with address stored in r_icache_vci_paddr register.
    15561556    {
    15571557        int         state;
    1558         size_t          way;
    1559         size_t          set;
    1560         size_t          word;
     1558        size_t      way;
     1559        size_t      set;
     1560        size_t      word;
    15611561
    15621562#ifdef INSTRUMENTATION
     
    15691569                          &word);
    15701570
    1571         if ( state == CACHE_SLOT_STATE_VALID_CC )       // inval to be done
     1571        if ( state == CACHE_SLOT_STATE_VALID_CC )   // inval to be done
    15721572        {
    15731573            r_icache_miss_way = way;
     
    15751575            r_icache_fsm      = ICACHE_XTN_CACHE_INVAL_GO;
    15761576        }
    1577         else            // miss : acknowlege the XTN request and return
     1577        else        // miss : acknowlege the XTN request and return
    15781578        {
    15791579            r_dcache_xtn_req = false;
     
    16361636        bool        found;
    16371637        bool        cleanup;
    1638         size_t          way;
    1639         size_t          set;
    1640         paddr_t         victim;
     1638        size_t      way;
     1639        size_t      set;
     1640        paddr_t     victim;
    16411641
    16421642#ifdef INSTRUMENTATION
     
    16611661                    r_icache_cc_send_nline  = victim;
    16621662                    r_icache_cc_send_way    = way;
    1663                     r_icache_cc_send_type   = CC_TYPE_CLEANUP;   
     1663                    r_icache_cc_send_type   = CC_TYPE_CLEANUP;
    16641664                }
    16651665                else
     
    16921692    }
    16931693    ///////////////////////
    1694     case ICACHE_MISS_CLEAN:              // switch the slot to zombi state
     1694    case ICACHE_MISS_CLEAN:          // switch the slot to zombi state
    16951695    {
    16961696        if (m_ireq.valid) m_cost_ins_miss_frz++;
     
    17161716    }
    17171717    //////////////////////
    1718     case ICACHE_MISS_WAIT:        // waiting response from VCI_RSP FSM
     1718    case ICACHE_MISS_WAIT:    // waiting response from VCI_RSP FSM
    17191719    {
    17201720        if (m_ireq.valid) m_cost_ins_miss_frz++;
     
    17251725            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
    17261726            r_icache_cc_send_way        = r_icache_miss_way;
    1727             r_icache_cc_send_type       = CC_TYPE_CLEANUP; 
     1727            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
    17281728            r_icache_cleanup_victim_req = false;
    1729         }   
     1729        }
    17301730
    17311731        // coherence clack interrupt
     
    17361736            break;
    17371737        }
    1738        
     1738
    17391739        // coherence interrupt
    17401740        if ( r_cc_receive_icache_req.read() and not r_icache_cc_send_req.read() and not r_icache_cleanup_victim_req.read() )
     
    17621762    }
    17631763    ///////////////////////////
    1764     case ICACHE_MISS_DATA_UPDT:   // update the cache (one word per cycle)
     1764    case ICACHE_MISS_DATA_UPDT:   // update the cache (one word per cycle)
    17651765    {
    17661766        if ( m_ireq.valid ) m_cost_ins_miss_frz++;
    17671767
    1768         if ( r_vci_rsp_fifo_icache.rok() )      // response available
     1768        if ( r_vci_rsp_fifo_icache.rok() )  // response available
    17691769        {
    17701770
     
    17901790            r_icache_miss_word = r_icache_miss_word.read() + 1;
    17911791
    1792             if ( r_icache_miss_word.read() == m_icache_words-1 )        // last word
     1792            if ( r_icache_miss_word.read() == m_icache_words-1 )   // last word
    17931793            {
    17941794                r_icache_fsm = ICACHE_MISS_DIR_UPDT;
     
    17981798    }
    17991799    //////////////////////////
    1800     case ICACHE_MISS_DIR_UPDT:  // Stalled if a victim line has been evicted,
     1800    case ICACHE_MISS_DIR_UPDT:  // Stalled if a victim line has been evicted,
    18011801                                // and the cleanup ack has not been received,
    18021802                                // as indicated by r_icache_miss_clack.
     
    18141814            r_icache_cc_send_nline      = r_icache_cleanup_victim_nline;
    18151815            r_icache_cc_send_way        = r_icache_miss_way;
    1816             r_icache_cc_send_type       = CC_TYPE_CLEANUP; 
     1816            r_icache_cc_send_type       = CC_TYPE_CLEANUP;
    18171817            r_icache_cleanup_victim_req = false;
    1818         }   
     1818        }
    18191819
    18201820        // coherence clack interrupt
     
    18951895    }
    18961896    ////////////////////
    1897     case ICACHE_UNC_WAIT:       // waiting a response to an uncacheable read from VCI_RSP FSM
     1897    case ICACHE_UNC_WAIT:  // waiting a response to an uncacheable read from VCI_RSP FSM
    18981898    {
    18991899        // coherence clack interrupt
     
    19361936    }
    19371937    /////////////////////
    1938     case ICACHE_CC_CHECK:       // This state is the entry point of a sub-fsm
     1938    case ICACHE_CC_CHECK:       // This state is the entry point of a sub-fsm
    19391939                                // handling coherence requests.
    19401940                                // if there is a matching pending miss, it is
     
    20282028        // CC request handler
    20292029
    2030         int             state = 0;
    2031         size_t      way = 0;
    2032         size_t      set = 0;
    2033         size_t      word = 0;
     2030        int         state = 0;
     2031        size_t      way = 0;
     2032        size_t      set = 0;
     2033        size_t      word = 0;
    20342034
    20352035#ifdef INSTRUMENTATION
     
    20902090    }
    20912091    /////////////////////
    2092     case ICACHE_CC_INVAL:       // hit inval : switch slot to ZOMBI state
     2092    case ICACHE_CC_INVAL:   // hit inval : switch slot to ZOMBI state
    20932093    {
    20942094        assert (not r_icache_cc_send_req.read() &&
     
    21002100#endif
    21012101
    2102         // Switch slot state to ZOMBI and send CLEANUP command 
     2102        // Switch slot state to ZOMBI and send CLEANUP command
    21032103        r_icache.write_dir( r_icache_cc_way.read(),
    21042104                            r_icache_cc_set.read(),
     
    21262126    }
    21272127    ////////////////////
    2128     case ICACHE_CC_UPDT:        // hit update : write one word per cycle
     2128    case ICACHE_CC_UPDT:    // hit update : write one word per cycle
    21292129    {
    21302130        assert (not r_icache_cc_send_req.read() &&
     
    21652165        }
    21662166
    2167         if ( r_cc_receive_updt_fifo_eop.read() )        // last word
     2167        if ( r_cc_receive_updt_fifo_eop.read() )   // last word
    21682168        {
    21692169            // no need to write in the cache anymore
     
    23062306    {
    23072307        paddr_t     paddr;                          // physical address
    2308         pte_info_t      tlb_flags;
    2309         size_t          tlb_way;
    2310         size_t          tlb_set;
    2311         paddr_t         tlb_nline = 0;
    2312         size_t          cache_way;
    2313         size_t          cache_set;
    2314         size_t          cache_word;
    2315         uint32_t        cache_rdata = 0;
    2316         bool        tlb_hit = false;
    2317         int             cache_state = CACHE_SLOT_STATE_EMPTY;
     2308        pte_info_t  tlb_flags;
     2309        size_t      tlb_way;
     2310        size_t      tlb_set;
     2311        paddr_t     tlb_nline = 0;
     2312        size_t      cache_way;
     2313        size_t      cache_set;
     2314        size_t      cache_word;
     2315        uint32_t    cache_rdata = 0;
     2316        bool        tlb_hit = false;
     2317        int         cache_state = CACHE_SLOT_STATE_EMPTY;
    23182318
    23192319        bool        tlb_inval_required = false;     // request TLB inval after cache update
     
    23412341            {
    23422342                // we take into account the paddr extension
    2343                 if (vci_param::N > 32) 
     2343                if (vci_param::N > 32)
    23442344                    paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
    23452345            }
     
    24042404            {
    24052405                tlb_inval_required       = true;
    2406                     r_dcache_tlb_inval_set   = 0;
    2407                     r_dcache_tlb_inval_line  = r_dcache_save_paddr.read()>>
     2406                r_dcache_tlb_inval_set   = 0;
     2407                r_dcache_tlb_inval_line  = r_dcache_save_paddr.read()>>
    24082408                                           (uint32_log2(m_dcache_words<<2));
    24092409
     
    26202620                    switch( xtn_opcode )
    26212621                    {
    2622                     case iss_t::XTN_PTPR:                       // itlb & dtlb must be flushed
     2622                    case iss_t::XTN_PTPR:               // itlb & dtlb must be flushed
    26232623                        r_dcache_xtn_req = true;
    26242624                        r_dcache_fsm     = DCACHE_XTN_SWITCH;
    26252625                        break;
    26262626
    2627                     case iss_t::XTN_TLB_MODE:                   // no cache or tlb access
     2627                    case iss_t::XTN_TLB_MODE:           // no cache or tlb access
    26282628                        r_mmu_mode       = m_dreq.wdata;
    26292629                        m_drsp.valid     = true;
     
    26312631                        break;
    26322632
    2633                     case iss_t::XTN_DTLB_INVAL:                 // dtlb access
     2633                    case iss_t::XTN_DTLB_INVAL:             // dtlb access
    26342634                        r_dcache_fsm     = DCACHE_XTN_DT_INVAL;
    26352635                        break;
    26362636
    2637                     case iss_t::XTN_ITLB_INVAL:                 // itlb access
     2637                    case iss_t::XTN_ITLB_INVAL:             // itlb access
    26382638                        r_dcache_xtn_req = true;
    26392639                        r_dcache_fsm     = DCACHE_XTN_IT_INVAL;
    26402640                        break;
    26412641
    2642                     case iss_t::XTN_DCACHE_INVAL:               // dcache, dtlb & itlb access
     2642                    case iss_t::XTN_DCACHE_INVAL:           // dcache, dtlb & itlb access
    26432643                        r_dcache_fsm     = DCACHE_XTN_DC_INVAL_VA;
    26442644                        break;
    26452645
    2646                     case iss_t::XTN_MMU_DCACHE_PA_INV:          // dcache, dtlb & itlb access
     2646                    case iss_t::XTN_MMU_DCACHE_PA_INV:      // dcache, dtlb & itlb access
    26472647                        r_dcache_fsm     = DCACHE_XTN_DC_INVAL_PA;
    26482648                        if (sizeof(paddr_t) <= 32)
     
    26592659                        break;
    26602660
    2661                     case iss_t::XTN_DCACHE_FLUSH:              // itlb and dtlb must be reset
     2661                    case iss_t::XTN_DCACHE_FLUSH:           // itlb and dtlb must be reset
    26622662                        r_dcache_flush_count = 0;
    26632663                        r_dcache_fsm     = DCACHE_XTN_DC_FLUSH;
    26642664                        break;
    26652665
    2666                     case iss_t::XTN_ICACHE_INVAL:               // icache and itlb access
     2666                    case iss_t::XTN_ICACHE_INVAL:           // icache and itlb access
    26672667                        r_dcache_xtn_req = true;
    26682668                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_VA;
    26692669                        break;
    26702670
    2671                     case iss_t::XTN_MMU_ICACHE_PA_INV:          // icache access
     2671                    case iss_t::XTN_MMU_ICACHE_PA_INV:      // icache access
    26722672                        r_dcache_xtn_req = true;
    26732673                        r_dcache_fsm     = DCACHE_XTN_IC_INVAL_PA;
    26742674                        break;
    26752675
    2676                     case iss_t::XTN_ICACHE_FLUSH:               // icache access
     2676                    case iss_t::XTN_ICACHE_FLUSH:           // icache access
    26772677                        r_dcache_xtn_req = true;
    26782678                        r_dcache_fsm     = DCACHE_XTN_IC_FLUSH;
    26792679                        break;
    26802680
    2681                     case iss_t::XTN_SYNC:                       // wait until write buffer empty
     2681                    case iss_t::XTN_SYNC:                   // wait until write buffer empty
    26822682                        r_dcache_fsm     = DCACHE_XTN_SYNC;
    26832683                        break;
    26842684
    2685                     case iss_t::XTN_MMU_WORD_LO:                // no cache or tlb access
     2685                    case iss_t::XTN_MMU_WORD_LO:        // no cache or tlb access
    26862686                        r_mmu_word_lo    = m_dreq.wdata;
    26872687                        m_drsp.valid     = true;
     
    26892689                        break;
    26902690
    2691                     case iss_t::XTN_MMU_WORD_HI:                // no cache or tlb access
     2691                    case iss_t::XTN_MMU_WORD_HI:        // no cache or tlb access
    26922692                        r_mmu_word_hi    = m_dreq.wdata;
    26932693                        m_drsp.valid     = true;
     
    27122712                    break;
    27132713
    2714                         case iss_t::XTN_ICACHE_PREFETCH:                // not implemented : no action
    2715                         case iss_t::XTN_DCACHE_PREFETCH:                // not implemented : no action
     2714                    case iss_t::XTN_ICACHE_PREFETCH:        // not implemented : no action
     2715                    case iss_t::XTN_DCACHE_PREFETCH:        // not implemented : no action
    27162716                        m_drsp.valid     = true;
    27172717                        r_dcache_fsm     = DCACHE_IDLE;
    2718                             break;
     2718                    break;
    27192719
    27202720                    default:
     
    27392739            else
    27402740            {
    2741                 bool        valid_req;
    2742                 bool        cacheable;
    2743 
    2744                 if ( not (r_mmu_mode.read() & DATA_TLB_MASK) )          // dtlb not activated
     2741                bool        valid_req;
     2742                bool        cacheable;
     2743
     2744                if ( not (r_mmu_mode.read() & DATA_TLB_MASK) )     // dtlb not activated
    27452745                {
    27462746                    valid_req     = true;
     
    27492749                    else cacheable = m_cacheability_table[(uint64_t)m_dreq.addr];
    27502750                }
    2751                 else                                                                       // dtlb activated
     2751                else                                               // dtlb activated
    27522752                {
    2753                     if ( tlb_hit )                                      // tlb hit
     2753                    if ( tlb_hit )                  // tlb hit
    27542754                    {
    27552755                        // cacheability
     
    28002800                        }
    28012801                    }
    2802                     else                                                // tlb miss
     2802                    else                     // tlb miss
    28032803                    {
    28042804                        valid_req            = false;
     
    28092809                }    // end DTLB activated
    28102810
    2811                 if ( valid_req )        // processor request is valid (after MMU check)
     2811                if ( valid_req )    // processor request is valid (after MMU check)
    28122812                {
    28132813                    // READ request
     
    28182818                          and not r_dcache_updt_req.read() )
    28192819                    {
    2820                         if ( cacheable )                // cacheable read
     2820                        if ( cacheable )            // cacheable read
    28212821                        {
    28222822                            if ( cache_state == CACHE_SLOT_STATE_EMPTY )   // cache miss
     
    28332833if ( m_debug_activated )
    28342834std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2835           << " READ MISS in dcache" 
     2835          << " READ MISS in dcache"
    28362836          << " / PADDR = " << std::hex << paddr << std::endl;
    28372837#endif
     
    28602860if ( m_debug_activated )
    28612861std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2862           << " READ HIT in dcache" 
    2863           << " : PADDR = " << std::hex << paddr 
     2862          << " READ HIT in dcache"
     2863          << " : PADDR = " << std::hex << paddr
    28642864          << " / DATA  = " << std::hex << cache_rdata << std::dec << std::endl;
    28652865#endif
    28662866                            }
    28672867                        }
    2868                         else                                    // uncacheable read
     2868                        else                    // uncacheable read
    28692869                        {
    28702870                            r_dcache_vci_paddr      = paddr;
     
    28762876if ( m_debug_activated )
    28772877std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2878           << " READ UNCACHEABLE in dcache" 
     2878          << " READ UNCACHEABLE in dcache"
    28792879          << " / PADDR = " << std::hex << paddr << std::endl;
    28802880#endif
     
    29112911                    {
    29122912                        if ( (r_mmu_mode.read() & DATA_TLB_MASK )
    2913                               and not tlb_flags.d )             // Dirty bit must be set
     2913                              and not tlb_flags.d )     // Dirty bit must be set
    29142914                        {
    29152915                            // The PTE physical address is obtained from the nline value (dtlb),
    29162916                            // and from the virtual address (word index)
    2917                             if ( tlb_flags.b )  // PTE1
     2917                            if ( tlb_flags.b )  // PTE1
    29182918                            {
    29192919                                r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    29202920                                                       (paddr_t)((m_dreq.addr>>19) & 0x3c);
    29212921                            }
    2922                             else                // PTE2
     2922                            else        // PTE2
    29232923                            {
    29242924                                r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
     
    29272927                            r_dcache_fsm      = DCACHE_DIRTY_GET_PTE;
    29282928                        }
    2929                         else                                    // Write request accepted
     2929                        else                    // Write request accepted
    29302930                        {
    29312931#ifdef INSTRUMENTATION
     
    29362936                                r_dcache_llsc_valid = false;
    29372937
    2938                             if (not cacheable) 
    2939                             {                           
     2938                            if (not cacheable)
     2939                            {
    29402940                                r_dcache_vci_paddr      = paddr;
    29412941                                r_dcache_vci_wdata      = m_dreq.wdata;
     
    29512951                                updt_request = true;
    29522952                                m_drsp.valid = true;
    2953                                 if ( cache_state == CACHE_SLOT_STATE_VALID_NCC ) 
     2953                                if ( cache_state == CACHE_SLOT_STATE_VALID_NCC )
    29542954                                {
    29552955                                    if ( r_dcache_content_state[cache_way*m_dcache_sets+cache_set] == LINE_CACHE_DATA_NOT_DIRTY )
     
    29962996if ( m_debug_activated )
    29972997std::cout << "  <PROC " << name() << " DCACHE_IDLE>"
    2998           << " WRITE REQ " 
     2998          << " WRITE REQ "
    29992999          << " / wbuf_request = " << wbuf_request
    30003000          << " / updt_request = " << updt_request
     
    30183018                    {
    30193019                        if ( (r_mmu_mode.read() & DATA_TLB_MASK )
    3020                               and not tlb_flags.d )                     // Dirty bit must be set
     3020                              and not tlb_flags.d )         // Dirty bit must be set
    30213021                        {
    30223022                            // The PTE physical address is obtained from the nline value (dtlb),
    30233023                            // and the word index (virtual address)
    3024                             if ( tlb_flags.b )  // PTE1
     3024                            if ( tlb_flags.b )  // PTE1
    30253025                            {
    30263026                                r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
    30273027                                                       (paddr_t)((m_dreq.addr>>19) & 0x3c);
    30283028                            }
    3029                             else                        // PTE2
     3029                            else            // PTE2
    30303030                            {
    30313031                                r_dcache_dirty_paddr = (paddr_t)(tlb_nline*(m_dcache_words<<2)) |
     
    30373037                            m_drsp.rdata = 0;
    30383038                        }
    3039                         else                                    // SC request accepted
     3039                        else                    // SC request accepted
    30403040                        {
    30413041#ifdef INSTRUMENTATION
     
    30543054                            else                                          // local fail
    30553055                            {
    3056                                     m_drsp.valid = true;
    3057                                     m_drsp.error = false;
    3058                                     m_drsp.rdata = 0x1;
     3056                                m_drsp.valid = true;
     3057                                m_drsp.error = false;
     3058                                m_drsp.rdata = 0x1;
    30593059                            }
    30603060                        }
     
    30653065
    30663066        // itlb miss request
    3067         else if ( r_icache_tlb_miss_req.read() and not wbuf_write_miss )
     3067        else if ( r_icache_tlb_miss_req.read() and not wbuf_write_miss )
    30683068        {
    30693069            r_dcache_tlb_ins    = true;
     
    30913091                          // r_mmu_ins_* or r_mmu_data* error reporting registers.
    30923092    {
    3093         uint32_t        ptba = 0;
    3094         bool            bypass;
    3095         paddr_t         pte_paddr;
     3093        uint32_t    ptba = 0;
     3094        bool        bypass;
     3095        paddr_t     pte_paddr;
    30963096
    30973097        // evaluate bypass in order to skip first level page table access
    3098         if ( r_dcache_tlb_ins.read() )                          // itlb miss
     3098        if ( r_dcache_tlb_ins.read() )  // itlb miss
    30993099        {
    31003100            bypass = r_itlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
    31013101        }
    3102         else                                                    // dtlb miss
     3102        else                            // dtlb miss
    31033103        {
    31043104            bypass = r_dtlb.get_bypass(r_dcache_tlb_vaddr.read(), &ptba);
     
    31373137    }
    31383138    /////////////////////////
    3139     case DCACHE_TLB_PTE1_GET:   // try to read a PT1 entry in dcache
     3139    case DCACHE_TLB_PTE1_GET:   // try to read a PT1 entry in dcache
    31403140    {
    31413141        // coherence clack request (from DSPIN CLACK)
     
    31553155        }
    31563156
    3157         uint32_t        entry;
    3158         size_t          way;
    3159         size_t          set;
    3160         size_t          word;
     3157        uint32_t    entry;
     3158        size_t      way;
     3159        size_t      set;
     3160        size_t      word;
    31613161        int         cache_state;
    31623162        r_dcache.read( r_dcache_tlb_paddr.read(),
     
    31743174        if (( cache_state == CACHE_SLOT_STATE_VALID_NCC ) or ( cache_state == CACHE_SLOT_STATE_VALID_CC ))
    31753175        {
    3176             if ( not (entry & PTE_V_MASK) )     // unmapped
     3176            if ( not (entry & PTE_V_MASK) ) // unmapped
    31773177            {
    31783178                if ( r_dcache_tlb_ins.read() )
     
    31953195if ( m_debug_activated )
    31963196{
    3197     std::cout << "  <PROC " << name() 
     3197    std::cout << "  <PROC " << name()
    31983198              << " DCACHE_TLB_PTE1_GET> HIT in dcache, but unmapped"
    31993199              << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    32063206
    32073207            }
    3208             else if( entry & PTE_T_MASK )       //  PTD : me must access PT2
     3208            else if( entry & PTE_T_MASK )   //  PTD : me must access PT2
    32093209            {
    32103210                // mark the cache line ac containing a PTD
     
    32123212
    32133213                // register bypass
    3214                 if ( r_dcache_tlb_ins.read() )          // itlb
     3214                if ( r_dcache_tlb_ins.read() )      // itlb
    32153215                {
    32163216                    r_itlb.set_bypass(r_dcache_tlb_vaddr.read(),
     
    32183218                                      r_dcache_tlb_paddr.read() / (m_icache_words<<2) );
    32193219                }
    3220                 else                                    // dtlb
     3220                else                    // dtlb
    32213221                {
    32223222                    r_dtlb.set_bypass(r_dcache_tlb_vaddr.read(),
     
    32323232if ( m_debug_activated )
    32333233{
    3234     std::cout << "  <PROC " << name() 
     3234    std::cout << "  <PROC " << name()
    32353235              << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    32363236              << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    32423242#endif
    32433243            }
    3244             else                        //  PTE1 :  we must update the TLB
     3244            else            //  PTE1 :  we must update the TLB
    32453245            {
    32463246                r_dcache_content_state[m_icache_sets*way+set] = LINE_CACHE_IN_TLB;
     
    32563256if ( m_debug_activated )
    32573257{
    3258     std::cout << "  <PROC " << name() 
     3258    std::cout << "  <PROC " << name()
    32593259              << " DCACHE_TLB_PTE1_GET> HIT in dcache"
    32603260              << std::hex << " / paddr = " << r_dcache_tlb_paddr.read()
     
    32723272            r_dcache_fsm   = DCACHE_TLB_PTE1_GET;
    32733273        }
    3274         else            // we must load the missing cache line in dcache
     3274        else        // we must load the missing cache line in dcache
    32753275        {
    32763276            r_dcache_vci_miss_req  = true;
     
    32833283if ( m_debug_activated )
    32843284{
    3285     std::cout << "  <PROC " << name() 
     3285    std::cout << "  <PROC " << name()
    32863286              << " DCACHE_TLB_PTE1_GET> MISS in dcache:"
    32873287              << " PTE1 address = " << std::hex << r_dcache_tlb_paddr.read() << std::endl;
     
    32923292    }
    32933293    ////////////////////////////
    3294     case DCACHE_TLB_PTE1_SELECT:        // select a slot for PTE1
    3295     {
    3296         size_t  way;
    3297         size_t  set;
     3294    case DCACHE_TLB_PTE1_SELECT:   // select a slot for PTE1
     3295    {
     3296        size_t way;
     3297        size_t set;
    32983298
    32993299        if ( r_dcache_tlb_ins.read() )
     
    33253325{
    33263326    if ( r_dcache_tlb_ins.read() )
    3327         std::cout << "  <PROC " << name() 
     3327        std::cout << "  <PROC " << name()
    33283328                  << " DCACHE_TLB_PTE1_SELECT> Select a slot in ITLB:";
    33293329    else
    3330         std::cout << "  <PROC " << name() 
     3330        std::cout << "  <PROC " << name()
    33313331                  << ".DCACHE_TLB_PTE1_SELECT> Select a slot in DTLB:";
    33323332        std::cout << " way = " << std::dec << way
     
    33373337    }
    33383338    //////////////////////////
    3339     case DCACHE_TLB_PTE1_UPDT:  // write a new PTE1 in tlb after testing the L/R bit
     3339    case DCACHE_TLB_PTE1_UPDT:  // write a new PTE1 in tlb after testing the L/R bit
    33403340                                // - if L/R bit already set, exit the sub-fsm.
    33413341                                // - if not, we update the page table but we dont write
     
    33433343                                //   the coherence mechanism.
    33443344    {
    3345         paddr_t   nline    = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
     3345        paddr_t   nline    = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    33463346        uint32_t  pte      = r_dcache_tlb_pte_flags.read();
    3347         bool      pt_updt  = false;
    3348         bool      local    = true;
     3347        bool      pt_updt  = false;
     3348        bool      local    = true;
    33493349
    33503350        // We should compute the access locality:
     
    33553355        // As long as this computation is not done, all access are local.
    33563356
    3357         if ( local )                                            // local access
     3357        if ( local )                        // local access
    33583358        {
    33593359            if ( not ((pte & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
     
    33663366            }
    33673367        }
    3368         else                                                    // remote access
     3368        else                                // remote access
    33693369        {
    33703370            if ( not ((pte & PTE_R_MASK) == PTE_R_MASK) ) // we must set the R bit
     
    33783378        }
    33793379
    3380         if ( not pt_updt )                                      // update TLB and return
     3380        if ( not pt_updt )                  // update TLB and return
    33813381        {
    33823382            if ( r_dcache_tlb_ins.read() )
    33833383            {
    3384                 r_itlb.write( true,             // 2M page
     3384                r_itlb.write( true,     // 2M page
    33853385                              pte,
    3386                               0,                // argument unused for a PTE1
     3386                              0,        // argument unused for a PTE1
    33873387                              r_dcache_tlb_vaddr.read(),
    33883388                              r_dcache_tlb_way.read(),
     
    33963396if ( m_debug_activated )
    33973397{
    3398     std::cout << "  <PROC " << name() 
     3398    std::cout << "  <PROC " << name()
    33993399              << " DCACHE_TLB_PTE1_UPDT> write PTE1 in ITLB"
    34003400              << " / set = " << std::dec << r_dcache_tlb_set.read()
     
    34063406            else
    34073407            {
    3408                 r_dtlb.write( true,             // 2M page
     3408                r_dtlb.write( true,     // 2M page
    34093409                              pte,
    3410                               0,                // argument unused for a PTE1
     3410                              0,        // argument unused for a PTE1
    34113411                              r_dcache_tlb_vaddr.read(),
    34123412                              r_dcache_tlb_way.read(),
     
    34203420if ( m_debug_activated )
    34213421{
    3422     std::cout << "  <PROC " << name() 
     3422    std::cout << "  <PROC " << name()
    34233423              << " DCACHE_TLB_PTE1_UPDT> write PTE1 in DTLB"
    34243424              << " / set = " << std::dec << r_dcache_tlb_set.read()
     
    34373437if ( m_debug_activated )
    34383438{
    3439     std::cout << "  <PROC " << name() 
     3439    std::cout << "  <PROC " << name()
    34403440              << " DCACHE_TLB_PTE1_UPDT> L/R bit update required"
    34413441              << std::endl;
     
    34463446    }
    34473447    /////////////////////////
    3448     case DCACHE_TLB_PTE2_GET:   // Try to get a PTE2 (64 bits) in the dcache
     3448    case DCACHE_TLB_PTE2_GET:   // Try to get a PTE2 (64 bits) in the dcache
    34493449    {
    34503450        // coherence clack request (from DSPIN CLACK)
     
    34643464        }
    34653465
    3466         uint32_t        pte_flags     = 0;
    3467         uint32_t        pte_ppn       = 0;
    3468         size_t          way           = 0;
    3469         size_t          set           = 0;
    3470         size_t          word          = 0;
     3466        uint32_t    pte_flags     = 0;
     3467        uint32_t    pte_ppn       = 0;
     3468        size_t      way           = 0;
     3469        size_t      set           = 0;
     3470        size_t      word          = 0;
    34713471        int         cache_state   = 0;
    34723472
     
    34843484        if ((cache_state == CACHE_SLOT_STATE_VALID_CC) or (cache_state == CACHE_SLOT_STATE_VALID_NCC))
    34853485        {
    3486             if ( not (pte_flags & PTE_V_MASK) ) // unmapped
     3486            if ( not (pte_flags & PTE_V_MASK) ) // unmapped
    34873487            {
    34883488                if ( r_dcache_tlb_ins.read() )
     
    35123512#endif
    35133513            }
    3514             else                                // mapped : we must update the TLB
     3514            else                // mapped : we must update the TLB
    35153515            {
    35163516                r_dcache_content_state[m_dcache_sets*way+set] = LINE_CACHE_IN_TLB;
     
    35273527if ( m_debug_activated )
    35283528{
    3529     std::cout << "  <PROC " << name() 
     3529    std::cout << "  <PROC " << name()
    35303530              << " DCACHE_TLB_PTE2_GET> HIT in dcache:"
    35313531              << " PTE_FLAGS = " << std::hex << pte_flags
     
    35433543if ( m_debug_activated )
    35443544{
    3545     std::cout << "  <PROC " << name() 
     3545    std::cout << "  <PROC " << name()
    35463546              << " DCACHE_TLB_PTE2_GET> ZOMBI in dcache: waiting cleanup ack"
    35473547              << std::endl;
     
    35773577        {
    35783578            r_itlb.select( r_dcache_tlb_vaddr.read(),
    3579                            false,       // PTE2
     3579                           false,   // PTE2
    35803580                           &way,
    35813581                           &set );
     
    35873587        {
    35883588            r_dtlb.select( r_dcache_tlb_vaddr.read(),
    3589                            false,       // PTE2
     3589                           false,   // PTE2
    35903590                           &way,
    35913591                           &set );
     
    36143614    }
    36153615    //////////////////////////
    3616     case DCACHE_TLB_PTE2_UPDT:  // write a new PTE2 in tlb after testing the L/R bit
     3616    case DCACHE_TLB_PTE2_UPDT:  // write a new PTE2 in tlb after testing the L/R bit
    36173617                                // - if L/R bit already set, exit the sub-fsm.
    36183618                                // - if not, we update the page table but we dont write
     
    36203620                                //   the coherence mechanism.
    36213621    {
    3622         paddr_t         nline     = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
     3622        paddr_t         nline     = r_dcache_tlb_paddr.read() >> (uint32_log2(m_dcache_words)+2);
    36233623        uint32_t        pte_flags = r_dcache_tlb_pte_flags.read();
    36243624        uint32_t        pte_ppn   = r_dcache_tlb_pte_ppn.read();
     
    36333633        // As long as this computation is not done, all access are local.
    36343634
    3635         if ( local )                                            // local access
     3635        if ( local )                        // local access
    36363636        {
    36373637            if ( not ((pte_flags & PTE_L_MASK) == PTE_L_MASK) ) // we must set the L bit
     
    36413641                r_dcache_vci_cas_new   = pte_flags | PTE_L_MASK;
    36423642                pte_flags              = pte_flags | PTE_L_MASK;
    3643                         r_dcache_tlb_pte_flags = pte_flags;
     3643                r_dcache_tlb_pte_flags = pte_flags;
    36443644            }
    36453645        }
     
    36523652                r_dcache_vci_cas_new   = pte_flags | PTE_R_MASK;
    36533653                pte_flags              = pte_flags | PTE_R_MASK;
    3654                         r_dcache_tlb_pte_flags = pte_flags;
     3654                r_dcache_tlb_pte_flags = pte_flags;
    36553655            }
    36563656        }
     
    36603660            if ( r_dcache_tlb_ins.read() )
    36613661            {
    3662                 r_itlb.write( false,    // 4K page
     3662                r_itlb.write( false,    // 4K page
    36633663                              pte_flags,
    36643664                              pte_ppn,
     
    36843684            else
    36853685            {
    3686                 r_dtlb.write( false,    // 4K page
     3686                r_dtlb.write( false,    // 4K page
    36873687                              pte_flags,
    36883688                              pte_ppn,
     
    37113711        else                                   // update page table but not TLB
    37123712        {
    3713             r_dcache_fsm = DCACHE_TLB_LR_UPDT;  // dcache and page table update
     3713            r_dcache_fsm = DCACHE_TLB_LR_UPDT; // dcache and page table update
    37143714
    37153715#if DEBUG_DCACHE
     
    37723772            }
    37733773
    3774             r_dcache_fsm = DCACHE_TLB_RETURN; 
     3774            r_dcache_fsm = DCACHE_TLB_RETURN;
    37753775        }
    37763776        else
     
    37903790    }
    37913791    ////////////////////////
    3792     case DCACHE_TLB_LR_WAIT:            // Waiting the response to SC transaction for DIRTY bit.
     3792    case DCACHE_TLB_LR_WAIT:        // Waiting the response to SC transaction for DIRTY bit.
    37933793                                    // We consume the response in rsp FIFO,
    37943794                                    // and exit the sub-fsm, but we don't
     
    38153815        }
    38163816
    3817         if ( r_vci_rsp_data_error.read() )      // bus error
     3817        if ( r_vci_rsp_data_error.read() )  // bus error
    38183818        {
    38193819            std::cout << "BUS ERROR in DCACHE_TLB_LR_WAIT state" << std::endl;
     
    38213821            exit(0);
    38223822        }
    3823         else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
    3824         {
     3823       else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     3824       {
    38253825#if DEBUG_DCACHE
    38263826if ( m_debug_activated )
     
    38363836    }
    38373837    ///////////////////////
    3838     case DCACHE_TLB_RETURN:             // return to caller depending on tlb miss type
     3838    case DCACHE_TLB_RETURN:    // return to caller depending on tlb miss type
    38393839    {
    38403840#if DEBUG_DCACHE
     
    38503850    }
    38513851    ///////////////////////
    3852     case DCACHE_XTN_SWITCH:             // The r_ptpr registers must be written,
     3852    case DCACHE_XTN_SWITCH:     // The r_ptpr registers must be written,
    38533853                                // and both itlb and dtlb must be flushed.
    38543854                                // Caution : the itlb miss requests must be taken
     
    38903890    }
    38913891    /////////////////////
    3892     case DCACHE_XTN_SYNC:               // waiting until write buffer empty
     3892    case DCACHE_XTN_SYNC:       // waiting until write buffer empty
    38933893                                // The coherence request must be taken
    38943894                                // as there is a risk of dead-lock
     
    39593959    }
    39603960    /////////////////////////
    3961     case DCACHE_XTN_DC_FLUSH:   // Invalidate sequencially all cache lines, using
     3961    case DCACHE_XTN_DC_FLUSH:   // Invalidate sequencially all cache lines, using
    39623962                                // r_dcache_flush_count as a slot counter,
    39633963                                // looping in this state until all slots have been visited.
     
    41254125    }
    41264126    /////////////////////////
    4127     case DCACHE_XTN_DT_INVAL:   // handling processor XTN_DTLB_INVAL request
     4127    case DCACHE_XTN_DT_INVAL:   // handling processor XTN_DTLB_INVAL request
    41284128    {
    41294129        r_dtlb.inval(r_dcache_save_wdata.read());
     
    41354135    case DCACHE_XTN_DC_INVAL_VA:  // selective cache line invalidate with virtual address
    41364136                                  // requires 3 cycles: access tlb, read cache, inval cache
    4137                                   // we compute the physical address in this state
     4137                                  // we compute the physical address in this state
    41384138    {
    41394139        paddr_t paddr;
    41404140        bool    hit;
    41414141
    4142         if ( r_mmu_mode.read() & DATA_TLB_MASK )        // dtlb activated
     4142        if ( r_mmu_mode.read() & DATA_TLB_MASK )    // dtlb activated
    41434143        {
    41444144
     
    41494149                                    &paddr );
    41504150        }
    4151         else                                            // dtlb not activated
     4151        else                        // dtlb not activated
    41524152        {
    41534153            paddr = (paddr_t)r_dcache_save_wdata.read();
    4154             if (vci_param::N > 32) 
     4154            if (vci_param::N > 32)
    41554155                paddr = paddr | ((paddr_t)(r_dcache_paddr_ext.read()) << 32);
    41564156            hit   = true;
    41574157        }
    41584158
    4159         if ( hit )              // tlb hit
     4159        if ( hit )      // tlb hit
    41604160        {
    41614161            r_dcache_save_paddr = paddr;
    41624162            r_dcache_fsm      = DCACHE_XTN_DC_INVAL_PA;
    41634163        }
    4164         else                    // tlb miss
    4165         {
     4164        else            // tlb miss
     4165        {
    41664166
    41674167#ifdef INSTRUMENTATION
    41684168m_cpt_data_tlb_miss++;
    41694169#endif
    4170             r_dcache_tlb_ins    = false;                // dtlb
     4170            r_dcache_tlb_ins    = false;        // dtlb
    41714171            r_dcache_tlb_vaddr  = r_dcache_save_wdata.read();
    41724172            r_dcache_fsm        = DCACHE_TLB_MISS;
     
    41904190                                  // In this state we read dcache.
    41914191    {
    4192         size_t          way;
    4193         size_t          set;
    4194         size_t          word;
     4192        size_t      way;
     4193        size_t      set;
     4194        size_t      word;
    41954195        int         state;
    41964196
     
    42044204                           &word );
    42054205
    4206         if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))      // inval to be done
     4206        if ((state == CACHE_SLOT_STATE_VALID_CC) or (state == CACHE_SLOT_STATE_VALID_NCC))  // inval to be done
    42074207        {
    42084208            r_dcache_xtn_way       = way;
     
    42104210            r_dcache_xtn_state     = state;
    42114211            r_dcache_xtn_data_addr = r_dcache_save_paddr.read()&~0x3F;
    4212            
     4212
    42134213            if( (state == CACHE_SLOT_STATE_VALID_NCC) and (r_dcache_content_state[way*m_dcache_sets+set] == LINE_CACHE_DATA_NOT_DIRTY) )
    42144214            {
     
    42164216            }
    42174217            r_dcache_fsm = DCACHE_XTN_DC_INVAL_GO;
    4218            
    4219         }
    4220         else            // miss : nothing to do
     4218
     4219        }
     4220        else        // miss : nothing to do
    42214221        {
    42224222            r_dcache_fsm      = DCACHE_IDLE;
     
    42404240    ////////////////////////////
    42414241    case DCACHE_XTN_DC_INVAL_GO:  // In this state, we invalidate the cache line
    4242                                               // Blocked if previous cleanup not completed
     4242                                  // Blocked if previous cleanup not completed
    42434243                                  // Test if itlb or dtlb inval is required
    42444244    {
     
    42464246        {
    42474247            int     state      = r_dcache_xtn_state.read();
    4248             size_t      way        = r_dcache_xtn_way.read();
    4249             size_t      set        = r_dcache_xtn_set.read();
     4248            size_t  way        = r_dcache_xtn_way.read();
     4249            size_t  set        = r_dcache_xtn_set.read();
    42504250            paddr_t nline      = r_dcache_save_paddr.read() / (m_dcache_words<<2);
    42514251
     
    43234323}
    43244324#endif
    4325             }
     4325        }
    43264326        break;
    43274327    }
     
    43634363
    43644364    //////////////////////////////
    4365     case DCACHE_XTN_DC_INVAL_END:       // send response to processor XTN request
     4365    case DCACHE_XTN_DC_INVAL_END:   // send response to processor XTN request
    43664366    {
    43674367        r_dcache_fsm = DCACHE_IDLE;
     
    45314531    }
    45324532    ///////////////////////
    4533     case DCACHE_MISS_CLEAN:             // switch the slot to ZOMBI state
     4533    case DCACHE_MISS_CLEAN:     // switch the slot to ZOMBI state
    45344534                                // and possibly request itlb or dtlb invalidate
    45354535    {
     
    45854585    }
    45864586    //////////////////////
    4587     case DCACHE_MISS_WAIT:      // waiting the response to a miss request from VCI_RSP FSM
     4587    case DCACHE_MISS_WAIT:  // waiting the response to a miss request from VCI_RSP FSM
    45884588                            // This state is in charge of error signaling
    45894589                            // There is 5 types of error depending on the requester
     
    46184618        }
    46194619
    4620         if ( r_vci_rsp_data_error.read() )                      // bus error
     4620        if ( r_vci_rsp_data_error.read() )  // bus error
    46214621        {
    46224622            switch ( r_dcache_miss_type.read() )
     
    46724672            r_vci_rsp_data_error = false;
    46734673        }
    4674         else if ( r_vci_rsp_fifo_dcache.rok() )         // valid response available
     4674        else if ( r_vci_rsp_fifo_dcache.rok() )    // valid response available
    46754675        {
    46764676            r_dcache_miss_word = 0;
    4677                 r_dcache_fsm       = DCACHE_MISS_DATA_UPDT;
     4677            r_dcache_fsm       = DCACHE_MISS_DATA_UPDT;
    46784678        }
    46794679        break;
    46804680    }
    46814681    //////////////////////////
    4682     case DCACHE_MISS_DATA_UPDT:   // update the dcache (one word per cycle)
     4682    case DCACHE_MISS_DATA_UPDT:   // update the dcache (one word per cycle)
    46834683    {
    46844684        if ( m_dreq.valid) m_cost_data_miss_frz++;
    46854685
    4686         if ( r_vci_rsp_fifo_dcache.rok() && r_vci_rsp_fifo_rpktid.rok())        // one word available
     4686        if ( r_vci_rsp_fifo_dcache.rok() && r_vci_rsp_fifo_rpktid.rok())   // one word available
    46874687        {
    46884688#ifdef INSTRUMENTATION
     
    48604860        }
    48614861
    4862         if ( r_vci_rsp_data_error.read() )      // bus error
     4862        if ( r_vci_rsp_data_error.read() )  // bus error
    48634863        {
    48644864            if(r_dcache_vci_unc_write.read())
     
    48734873            break;
    48744874        }
    4875             else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
    4876             {
     4875        else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
     4876        {
    48774877            // consume data
    48784878            vci_rsp_fifo_dcache_get = true;
     
    48824882            if ( m_dreq.valid and (m_dreq.addr == r_dcache_save_vaddr.read()) )
    48834883            {
    4884                     m_drsp.valid        = true;
     4884                m_drsp.valid        = true;
    48854885                m_drsp.error        = false;
    4886                     m_drsp.rdata        = r_vci_rsp_fifo_dcache.read();
    4887             }
    4888             }
     4886                m_drsp.rdata        = r_vci_rsp_fifo_dcache.read();
     4887            }
     4888        }
    48894889        break;
    48904890    }
     
    49084908        }
    49094909
    4910         if ( r_vci_rsp_data_error.read() )      // bus error
     4910        if ( r_vci_rsp_data_error.read() )  // bus error
    49114911        {
    49124912            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
     
    49184918            break;
    49194919        }
    4920             else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
    4921             {
     4920        else if ( r_vci_rsp_fifo_dcache.rok() )     // data available
     4921        {
    49224922            // consume data
    49234923            vci_rsp_fifo_dcache_get = true;
     
    49404940                r_dcache_fsm = DCACHE_IDLE;
    49414941            }
    4942             }
     4942        }
    49434943        break;
    49444944    }
    49454945    ////////////////////
    4946     case DCACHE_SC_WAIT:        // waiting VCI response to a SC transaction
     4946    case DCACHE_SC_WAIT:   // waiting VCI response to a SC transaction
    49474947    {
    49484948        // coherence clack request (from DSPIN CLACK)
     
    49624962        }
    49634963
    4964         if ( r_vci_rsp_data_error.read() )              // bus error
     4964        if ( r_vci_rsp_data_error.read() )     // bus error
    49654965        {
    49664966            r_mmu_detr           = MMU_READ_DATA_ILLEGAL_ACCESS;
     
    49724972            break;
    49734973        }
    4974             else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
    4975             {
     4974        else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
     4975        {
    49764976            // consume response
    49774977            vci_rsp_fifo_dcache_get = true;
     
    49794979            m_drsp.rdata            = r_vci_rsp_fifo_dcache.read();
    49804980            r_dcache_fsm            = DCACHE_IDLE;
    4981             }
     4981        }
    49824982        break;
    49834983    }
    49844984    //////////////////////////
    4985     case DCACHE_DIRTY_GET_PTE:          // This sub_fsm set the PTE Dirty bit in memory
     4985    case DCACHE_DIRTY_GET_PTE:      // This sub_fsm set the PTE Dirty bit in memory
    49864986                                    // before handling a processor WRITE or SC request
    49874987                                    // Input argument is r_dcache_dirty_paddr
     
    50835083        if (!r_cas_islocal.read())
    50845084        {
    5085             if ( r_vci_rsp_data_error.read() )  // bus error
     5085            if ( r_vci_rsp_data_error.read() )  // bus error
    50865086            {
    50875087                std::cout << "BUS ERROR in DCACHE_DIRTY_WAIT state" << std::endl;
     
    50895089                exit(0);
    50905090            }
    5091             else if ( r_vci_rsp_fifo_dcache.rok() )     // response available
     5091            else if ( r_vci_rsp_fifo_dcache.rok() ) // response available
    50925092            {
    50935093                vci_rsp_fifo_dcache_get = true;
     
    51555155//              << " DCACHE_CC_CHECK> paddr = " << paddr
    51565156//              << " r_dcache_vci_paddr = " << r_dcache_vci_paddr.read()
    5157 //              << " mask = " << mask 
    5158 //              << " (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT) = " 
     5157//              << " mask = " << mask
     5158//              << " (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT) = "
    51595159//              << (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT)
    5160 //              << " (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT) = " 
     5160//              << " (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT) = "
    51615161//              << (r_dcache_fsm_cc_save == DCACHE_MISS_DIR_UPDT)
    5162 //              << " ((r_dcache_vci_paddr.read() & mask) == (paddr & mask)) = " 
     5162//              << " ((r_dcache_vci_paddr.read() & mask) == (paddr & mask)) = "
    51635163//              << ((r_dcache_vci_paddr.read() & mask) == (paddr & mask))
    51645164//              << std::dec <<std::endl;
     
    52065206        }
    52075207
    5208        
     5208
    52095209        // Match between MISS address and CC address
    52105210        // note: In the same cycle we can handle a CLACK and a MISS match
    52115211        // because the CLACK access the directory but the MISS match dont.
    5212         if (r_cc_receive_dcache_req.read() and 
     5212        if (r_cc_receive_dcache_req.read() and
    52135213          ((r_dcache_fsm_cc_save == DCACHE_MISS_SELECT  )  or
    52145214           (r_dcache_fsm_cc_save == DCACHE_MISS_WAIT    )  or
     
    52505250
    52515251        // CC request handler
    5252        
     5252
    52535253        int    state = 0;
    52545254        size_t way   = 0;
     
    53655365                // If the type of inval request from Memcache is configuration
    53665366                // (software), we send a classic CLEANUP
    5367                 if (cache_state == CACHE_SLOT_STATE_VALID_CC or r_cc_receive_dcache_inval_is_config.read()) 
     5367                if (cache_state == CACHE_SLOT_STATE_VALID_CC or r_cc_receive_dcache_inval_is_config.read())
    53685368                {
    53695369                    r_dcache.write_dir( way,
     
    53885388        if (cache_state == CACHE_SLOT_STATE_VALID_NCC and not r_cc_receive_dcache_inval_is_config.read())
    53895389        {
    5390             r_dcache_cc_cleanup_line_ncc = true; 
     5390            r_dcache_cc_cleanup_line_ncc = true;
    53915391            if ((r_dcache_content_state[way*m_dcache_sets+set] != LINE_CACHE_DATA_NOT_DIRTY) or r_dcache_dirty_save.read() or dirty_save) //must send data
    53925392            {
     
    54045404                                    set,
    54055405                                    CACHE_SLOT_STATE_ZOMBI );
    5406  
     5406
    54075407                r_dcache_cc_cleanup_updt_data = false;
    54085408                r_dcache_fsm = r_dcache_fsm_cc_save.read();
     
    54175417        break;
    54185418    }
    5419    
     5419
    54205420    /////////////////////
    54215421    case DCACHE_CC_INVAL_DATA:
     
    54875487                        "ERROR in DCACHE_CC_INVAL: the r_dcache_cc_send_req "
    54885488                        "must not be set");
    5489        
     5489
    54905490                if ( not r_cc_receive_updt_fifo_be.rok() ) break;
    54915491
     
    55385538    }
    55395539    ///////////////////////////
    5540     case DCACHE_INVAL_TLB_SCAN:         // Scan sequencially all sets for both ITLB & DTLB
     5540    case DCACHE_INVAL_TLB_SCAN:         // Scan sequencially all sets for both ITLB & DTLB
    55415541                                        // It makes assumption: m_itlb_sets == m_dtlb_sets
    55425542                                        // All ways are handled in parallel.
     
    55545554                                        // - r_dcache_fsm_scan_save
    55555555    {
    5556         paddr_t line = r_dcache_tlb_inval_line.read();
     5556        paddr_t line = r_dcache_tlb_inval_line.read();
    55575557        size_t  set  = r_dcache_tlb_inval_set.read();
    55585558        size_t  way;
     
    56115611    if ( (m_ireq.valid and not m_irsp.valid) or (m_dreq.valid and not m_drsp.valid) )
    56125612    {
    5613         m_cpt_frz_cycles++;             // used for instrumentation
    5614         m_cpt_stop_simulation++;        // used for debug
     5613        m_cpt_frz_cycles++;         // used for instrumentation
     5614        m_cpt_stop_simulation++;    // used for debug
    56155615        if ( m_cpt_stop_simulation > m_max_frozen_cycles )
    56165616        {
     
    59425942                            {
    59435943                                std::cout << "ERROR in VCI_CC_VCACHE " << name()
    5944                                           << " VCI response packet too short" 
     5944                                          << " VCI response packet too short"
    59455945                                          << " for instruction miss" << std::endl;
    59465946                                exit(0);
     
    61316131            {
    61326132                // the new client is dcache and has a cleanup request
    6133                 if      ( (update_last_client == 0) and 
     6133                if      ( (update_last_client == 0) and
    61346134                          (r_dcache_cc_send_type.read() == CC_TYPE_CLEANUP))
    61356135                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
    61366136                // the new client is dcache and has a multi acknowledgement request
    6137                 else if ( (update_last_client == 0) and 
     6137                else if ( (update_last_client == 0) and
    61386138                          (r_dcache_cc_send_type.read() == CC_TYPE_MULTI_ACK))
    61396139                    r_cc_send_fsm = CC_SEND_MULTI_ACK;
    61406140                // the new client is icache and has a cleanup request
    6141                 else if ( (update_last_client == 1) and 
     6141                else if ( (update_last_client == 1) and
    61426142                          (r_icache_cc_send_type.read() == CC_TYPE_CLEANUP))
    61436143                    r_cc_send_fsm = CC_SEND_CLEANUP_1;
     
    62526252                }
    62536253                // test for a multi updt
    6254                 else if (receive_type == DspinRwtParam::TYPE_MULTI_UPDT_DATA) 
     6254                else if (receive_type == DspinRwtParam::TYPE_MULTI_UPDT_DATA)
    62556255                {
    62566256                    r_cc_receive_fsm = CC_RECEIVE_DATA_UPDT_HEADER;
     
    62886288            // not to actually post a request to an available cache => need a
    62896289            // flip_flop to check that ?
    6290             if (not (r_cc_receive_icache_req.read()) and 
     6290            if (not (r_cc_receive_icache_req.read()) and
    62916291                not (r_cc_receive_dcache_req.read()) and
    62926292                (p_dspin_m2p.write.read()))
     
    63336333            uint64_t receive_data = p_dspin_m2p.data.read();
    63346334            // for data INVAL, wait for dcache to take the request
    6335             if (p_dspin_m2p.write.read()           and 
     6335            if (p_dspin_m2p.write.read()           and
    63366336                not r_cc_receive_dcache_req.read() )
    63376337            {
     
    63526352            uint64_t receive_data = p_dspin_m2p.data.read();
    63536353            // for ins INVAL, wait for icache to take the request
    6354             if (p_dspin_m2p.write.read()           and 
     6354            if (p_dspin_m2p.write.read()           and
    63556355                not r_cc_receive_icache_req.read() )
    63566356            {
     
    64726472
    64736473    ///////////////// DSPIN CLACK interface ///////////////
    6474    
     6474
    64756475    uint64_t clack_type = DspinRwtParam::dspin_get(r_dspin_clack_flit.read(),
    64766476                                                     DspinRwtParam::CLACK_TYPE);
     
    65596559    p_vci.pktid  = 0;
    65606560    p_vci.srcid  = m_srcid;
    6561     p_vci.cons   = is_sc_or_cas; 
    6562     p_vci.contig = not is_sc_or_cas; 
     6561    p_vci.cons   = is_sc_or_cas;
     6562    p_vci.contig = not is_sc_or_cas;
    65636563    p_vci.wrap   = false;
    65646564    p_vci.clen   = 0;
     
    65676567    if ( m_monitor_ok ) {
    65686568        if ( p_vci.cmdack.read() == true and p_vci.cmdval == true) {
    6569             if (((p_vci.address.read()) >= m_monitor_base) and 
     6569            if (((p_vci.address.read()) >= m_monitor_base) and
    65706570                ((p_vci.address.read()) < m_monitor_base + m_monitor_length) ) {
    65716571                std::cout << "CC_VCACHE Monitor " << name() << std::hex
    6572                           << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()] 
     6572                          << " Access type = " << vci_cmd_type_str[p_vci.cmd.read()]
    65736573                          << " Pktid type = " << vci_pktid_type_str[p_vci.pktid.read()]
    65746574                          << " : address = " << p_vci.address.read()
    6575                           << " / be = " << p_vci.be.read(); 
     6575                          << " / be = " << p_vci.be.read();
    65766576                if ( p_vci.cmd.read() == vci_param::CMD_WRITE ) {
    65776577                    std::cout << " / data = " << p_vci.wdata.read();
     
    67216721    } // end switch r_vci_rsp_fsm
    67226722
    6723    
    6724     // Send coherence packets on DSPIN P2M 
    6725     // it depends on the CC_SEND FSM 
     6723
     6724    // Send coherence packets on DSPIN P2M
     6725    // it depends on the CC_SEND FSM
    67266726
    67276727    uint64_t dspin_send_data = 0;
     
    67476747            if(r_cc_send_last_client.read() == 0) // dcache active request
    67486748            {
    6749                 uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() 
    6750                                 >> (m_nline_width - m_x_width - m_y_width) 
     6749                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
     6750                                >> (m_nline_width - m_x_width - m_y_width)
    67516751                                << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    67526752                DspinRwtParam::dspin_set(dspin_send_data,
     
    67726772            else                                // icache active request
    67736773            {
    6774                 uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() 
    6775                                 >> (m_nline_width - m_x_width - m_y_width) 
     6774                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
     6775                                >> (m_nline_width - m_x_width - m_y_width)
    67766776                                << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    67776777
     
    68336833                                       r_cc_send_data_fifo.read(),
    68346834                                       DspinRwtParam::CLEANUP_DATA_UPDT);
    6835            
     6835
    68366836            p_dspin_p2m.data = dspin_send_data;
    68376837            p_dspin_p2m.write = true;
     
    68526852            if(r_cc_send_last_client.read() == 0) // dcache active request
    68536853            {
    6854                 uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read() 
    6855                                 >> (m_nline_width - m_x_width - m_y_width) 
     6854                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
     6855                                >> (m_nline_width - m_x_width - m_y_width)
    68566856                                << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6857  
     6857
    68586858                DspinRwtParam::dspin_set(dspin_send_data,
    68596859                                           dest,
     
    68666866            else                                    // icache active request
    68676867            {
    6868                 uint64_t dest = (uint64_t) r_icache_cc_send_nline.read() 
    6869                                 >> (m_nline_width - m_x_width - m_y_width) 
     6868                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
     6869                                >> (m_nline_width - m_x_width - m_y_width)
    68706870                                << (DspinRwtParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6871  
     6871
    68726872
    68736873                DspinRwtParam::dspin_set(dspin_send_data,
     
    68896889
    68906890    // Receive coherence packets
    6891     // It depends on the CC_RECEIVE FSM 
     6891    // It depends on the CC_RECEIVE FSM
    68926892    switch( r_cc_receive_fsm.read() )
    68936893    {
     
    69466946        case CC_RECEIVE_INS_UPDT_HEADER:
    69476947        {
    6948             if ( not r_cc_receive_icache_req.read()) 
     6948            if ( not r_cc_receive_icache_req.read())
    69496949                p_dspin_m2p.read = true;
    69506950            else
     
    70017001    }
    70027002
    7003     p_dspin_clack.read = dspin_clack_get; 
     7003    p_dspin_clack.read = dspin_clack_get;
    70047004} // end genMoore
    70057005
Note: See TracChangeset for help on using the changeset viewer.