Changeset 453 for branches/ODCCP


Ignore:
Timestamp:
Jul 19, 2013, 9:50:00 AM (10 years ago)
Author:
devigne
Message:

Rename dspin_dhccp_param into dspin_odccp_param

Location:
branches/ODCCP
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed
  • branches/ODCCP/communication/dspin_odccp_param/caba/metadata/dspin_odccp_param.sd

    r452 r453  
    1 Module('caba:dspin_dhccp_param',
    2            classname = 'soclib::caba::DspinDhccpParam',
    3            header_files = ['../source/include/dspin_dhccp_param.h',]
     1Module('caba:dspin_odccp_param',
     2           classname = 'soclib::caba::DspinOdccpParam',
     3           header_files = ['../source/include/dspin_odccp_param.h',]
    44)
  • branches/ODCCP/communication/dspin_odccp_param/caba/source/include/dspin_odccp_param.h

    r452 r453  
    11/* -*- c++ -*-
    2  * File         : dspin_dhccp_param.h
     2 * File         : dspin_odccp_param.h
    33 * Date         : 01/03/2013
    44 * Copyright    : UPMC / LIP6
    55 * Authors      : Cesar Fuguet
    6  *
     6 * mainteiners  : Clément Devigne
    77 * SOCLIB_LGPL_HEADER_BEGIN
    88 *
     
    2727
    2828
    29 #ifndef DSPIN_DHCCP_PARAMS_H
    30 #define DSPIN_DHCCP_PARAMS_H
     29#ifndef DSPIN_ODCCP_PARAMS_H
     30#define DSPIN_ODCCP_PARAMS_H
    3131
    3232#include <inttypes.h>
     
    3838 * L1 cache to Memory Cache command packets
    3939 *
    40  * CLEANUP
     40 * CLEANUP and N flits data if CLEANUP DATA
    4141 *
    4242 * flit 1
     
    136136    case z: x |= ((y & z##_MASK) << z##_SHIFT);break
    137137
    138 class DspinDhccpParam
     138class DspinOdccpParam
    139139{
    140140  public:
     
    335335        GET_FIELD(flit,BROADCAST_NLINE);
    336336
    337         default: assert(false && "Incorrect DHCCP DSPIN field");
     337        default: assert(false && "Incorrect ODCCP DSPIN field");
    338338      }
    339339    }
     
    376376        SET_FIELD(flit,value,BROADCAST_NLINE);
    377377
    378         default: assert(false && "Incorrect DHCCP DSPIN field");
     378        default: assert(false && "Incorrect ODCCP DSPIN field");
    379379      }
    380380    }
  • branches/ODCCP/modules/vci_cc_vcache_wrapper/caba/metadata/vci_cc_vcache_wrapper.sd

    r452 r453  
    3232                parameter.Reference('addr_size'))
    3333            ),
    34                         Uses('caba:dspin_dhccp_param'),
     34                        Uses('caba:dspin_odccp_param'),
    3535        ],
    3636
  • branches/ODCCP/modules/vci_cc_vcache_wrapper/caba/source/include/vci_cc_vcache_wrapper.h

    r452 r453  
    4242#include "vci_initiator.h"
    4343#include "dspin_interface.h"
    44 #include "dspin_dhccp_param.h"
     44#include "dspin_odccp_param.h"
    4545#include "mapping_table.h"
    4646#include "static_assert.h"
  • branches/ODCCP/modules/vci_cc_vcache_wrapper/caba/source/src/vci_cc_vcache_wrapper.cpp

    r452 r453  
    59925992                uint64_t receive_data = p_dspin_in.data.read();
    59935993                // initialize coherence packet type
    5994                 uint64_t receive_type = DspinDhccpParam::dspin_get(receive_data,
    5995                                             DspinDhccpParam::FROM_MC_TYPE);
     5994                uint64_t receive_type = DspinOdccpParam::dspin_get(receive_data,
     5995                                            DspinOdccpParam::FROM_MC_TYPE);
    59965996                // initialize data/ins flip_flop (0 data / 1 ins)
    59975997                r_cc_receive_data_ins = (bool)(receive_type & 0x1);
    59985998                // test for a broadcast
    5999                 if (DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::FROM_MC_BC))
     5999                if (DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::FROM_MC_BC))
    60006000                {
    60016001                    r_cc_receive_fsm = CC_RECEIVE_BRDCAST_HEADER;
    60026002                }
    60036003                // test for a CLACK
    6004                 else if ((receive_type == DspinDhccpParam::TYPE_CLEANUP_ACK_DATA) or
    6005                          (receive_type == DspinDhccpParam::TYPE_CLEANUP_ACK_INST))
     6004                else if ((receive_type == DspinOdccpParam::TYPE_CLEANUP_ACK_DATA) or
     6005                         (receive_type == DspinOdccpParam::TYPE_CLEANUP_ACK_INST))
    60066006                {
    60076007                    r_cc_receive_fsm = CC_RECEIVE_CLACK;
    60086008                }
    60096009                // test for a multi updt
    6010                 else if ((receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_DATA) or
    6011                          (receive_type == DspinDhccpParam::TYPE_MULTI_UPDT_INST))
     6010                else if ((receive_type == DspinOdccpParam::TYPE_MULTI_UPDT_DATA) or
     6011                         (receive_type == DspinOdccpParam::TYPE_MULTI_UPDT_INST))
    60126012                {
    60136013                    r_cc_receive_fsm = CC_RECEIVE_UPDT_HEADER;
     
    60336033                // request dcache to handle the CLACK
    60346034                r_cc_receive_dcache_req  = true;
    6035                 r_cc_receive_dcache_set  = DspinDhccpParam::dspin_get(receive_data,
    6036                                            DspinDhccpParam::CLEANUP_ACK_SET) &
     6035                r_cc_receive_dcache_set  = DspinOdccpParam::dspin_get(receive_data,
     6036                                           DspinOdccpParam::CLEANUP_ACK_SET) &
    60376037                                           ((1ULL<<(uint32_log2(m_dcache_sets)))-1);
    6038                 r_cc_receive_dcache_way  = DspinDhccpParam::dspin_get(receive_data,
    6039                                            DspinDhccpParam::CLEANUP_ACK_WAY) &
     6038                r_cc_receive_dcache_way  = DspinOdccpParam::dspin_get(receive_data,
     6039                                           DspinOdccpParam::CLEANUP_ACK_WAY) &
    60406040                                           ((1ULL<<(uint32_log2(m_dcache_ways)))-1);
    60416041                r_cc_receive_dcache_type = CC_TYPE_CLACK;
     
    60506050                // request icache to handle the CLACK
    60516051                r_cc_receive_icache_req  = true;
    6052                 r_cc_receive_icache_set  = DspinDhccpParam::dspin_get(receive_data,
    6053                                            DspinDhccpParam::CLEANUP_ACK_SET) &
     6052                r_cc_receive_icache_set  = DspinOdccpParam::dspin_get(receive_data,
     6053                                           DspinOdccpParam::CLEANUP_ACK_SET) &
    60546054                                           ((1ULL<<(uint32_log2(m_icache_sets)))-1);
    6055                 r_cc_receive_icache_way  = DspinDhccpParam::dspin_get(receive_data,
    6056                                            DspinDhccpParam::CLEANUP_ACK_WAY) &
     6055                r_cc_receive_icache_way  = DspinOdccpParam::dspin_get(receive_data,
     6056                                           DspinOdccpParam::CLEANUP_ACK_WAY) &
    60576057                                           ((1ULL<<(uint32_log2(m_icache_ways)))-1);
    60586058                r_cc_receive_icache_type = CC_TYPE_CLACK;
     
    60866086                // request dcache to handle the BROADCAST
    60876087                r_cc_receive_dcache_req  = true;
    6088                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,
    6089                                              DspinDhccpParam::BROADCAST_NLINE);
     6088                r_cc_receive_dcache_nline  = DspinOdccpParam::dspin_get(receive_data,
     6089                                             DspinOdccpParam::BROADCAST_NLINE);
    60906090                r_cc_receive_dcache_type = CC_TYPE_BRDCAST;
    60916091                // request icache to handle the BROADCAST
    60926092                r_cc_receive_icache_req  = true;
    6093                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,
    6094                                              DspinDhccpParam::BROADCAST_NLINE);
     6093                r_cc_receive_icache_nline  = DspinOdccpParam::dspin_get(receive_data,
     6094                                             DspinOdccpParam::BROADCAST_NLINE);
    60956095                r_cc_receive_icache_type = CC_TYPE_BRDCAST;
    60966096                // get back to idle state
     
    61106110                 not (r_cc_receive_dcache_req.read()))
    61116111            {
    6112                 r_cc_receive_dcache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,
    6113                                                    DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
     6112                r_cc_receive_dcache_updt_tab_idx = DspinOdccpParam::dspin_get(receive_data,
     6113                                                   DspinOdccpParam::MULTI_INVAL_UPDT_INDEX);
    61146114                r_cc_receive_fsm = CC_RECEIVE_INVAL_NLINE;
    61156115                break;
     
    61196119                 not (r_cc_receive_icache_req.read()))
    61206120            {
    6121                 r_cc_receive_icache_updt_tab_idx = DspinDhccpParam::dspin_get(receive_data,
    6122                                                    DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
     6121                r_cc_receive_icache_updt_tab_idx = DspinOdccpParam::dspin_get(receive_data,
     6122                                                   DspinOdccpParam::MULTI_INVAL_UPDT_INDEX);
    61236123                r_cc_receive_fsm = CC_RECEIVE_INVAL_NLINE;
    61246124                break;
     
    61396139                // request dcache to handle the INVAL
    61406140                r_cc_receive_dcache_req  = true;
    6141                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     6141                r_cc_receive_dcache_nline  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_INVAL_NLINE);
    61426142                r_cc_receive_dcache_type = CC_TYPE_INVAL;
    61436143                // get back to idle state
     
    61506150                // request icache to handle the INVAL
    61516151                r_cc_receive_icache_req  = true;
    6152                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_INVAL_NLINE);
     6152                r_cc_receive_icache_nline  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_INVAL_NLINE);
    61536153                r_cc_receive_icache_type = CC_TYPE_INVAL;
    61546154                // get back to idle state
     
    61686168            if ((r_cc_receive_data_ins.read() == 0) and not r_cc_receive_dcache_req.read() and r_cc_receive_updt_fifo_be.empty())
    61696169            {
    6170                 r_cc_receive_dcache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
     6170                r_cc_receive_dcache_updt_tab_idx  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_UPDT_INDEX);
    61716171                r_cc_receive_fsm = CC_RECEIVE_UPDT_NLINE;
    61726172                break;
     
    61766176            if ((r_cc_receive_data_ins.read() == 1) and not r_cc_receive_icache_req.read() and r_cc_receive_updt_fifo_be.empty())
    61776177            {
    6178                 r_cc_receive_icache_updt_tab_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
     6178                r_cc_receive_icache_updt_tab_idx  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_UPDT_INDEX);
    61796179                r_cc_receive_fsm = CC_RECEIVE_UPDT_NLINE;
    61806180                break;
     
    61956195                 (p_dspin_in.write.read()) )
    61966196            {
    6197                 r_cc_receive_dcache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
    6198                 r_cc_receive_word_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
     6197                r_cc_receive_dcache_nline  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_NLINE);
     6198                r_cc_receive_word_idx  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_WORD_INDEX);
    61996199                r_cc_receive_dcache_type = CC_TYPE_UPDT;
    62006200                // get back to idle state
     
    62096209                 (p_dspin_in.write.read()))
    62106210            {
    6211                 r_cc_receive_icache_nline  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_NLINE);
    6212                 r_cc_receive_word_idx  = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
     6211                r_cc_receive_icache_nline  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_NLINE);
     6212                r_cc_receive_word_idx  = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_WORD_INDEX);
    62136213                r_cc_receive_icache_type = CC_TYPE_UPDT;
    62146214                // get back to idle state
     
    62336233                uint64_t receive_data = p_dspin_in.data.read();
    62346234                bool     receive_eop  = p_dspin_in.eop.read();
    6235                 cc_receive_updt_fifo_be   = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_BE);
    6236                 cc_receive_updt_fifo_data = DspinDhccpParam::dspin_get(receive_data,DspinDhccpParam::MULTI_UPDT_DATA);
     6235                cc_receive_updt_fifo_be   = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_BE);
     6236                cc_receive_updt_fifo_data = DspinOdccpParam::dspin_get(receive_data,DspinOdccpParam::MULTI_UPDT_DATA);
    62376237                cc_receive_updt_fifo_eop  = receive_eop;
    62386238                cc_receive_updt_fifo_put  = true;
     
    64546454        {
    64556455            // initialize dspin send data
    6456             DspinDhccpParam::dspin_set(dspin_send_data,
     6456            DspinOdccpParam::dspin_set(dspin_send_data,
    64576457                                       m_cc_global_id,
    6458                                        DspinDhccpParam::CLEANUP_SRCID);
    6459             DspinDhccpParam::dspin_set(dspin_send_data,
     6458                                       DspinOdccpParam::CLEANUP_SRCID);
     6459            DspinOdccpParam::dspin_set(dspin_send_data,
    64606460                                       0,
    6461                                        DspinDhccpParam::FROM_L1_BC);
     6461                                       DspinOdccpParam::FROM_L1_BC);
    64626462
    64636463            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    64656465                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    64666466                                >> (m_nline_width - m_x_width - m_y_width)
    6467                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6468                 DspinDhccpParam::dspin_set(dspin_send_data,
     6467                                << (DspinOdccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6468                DspinOdccpParam::dspin_set(dspin_send_data,
    64696469                                           dest,
    6470                                            DspinDhccpParam::CLEANUP_DEST);
    6471 
    6472                 DspinDhccpParam::dspin_set(dspin_send_data,
     6470                                           DspinOdccpParam::CLEANUP_DEST);
     6471
     6472                DspinOdccpParam::dspin_set(dspin_send_data,
    64736473                                           (r_dcache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6474                                            DspinDhccpParam::CLEANUP_NLINE_MSB);
    6475 
    6476                 DspinDhccpParam::dspin_set(dspin_send_data,
     6474                                           DspinOdccpParam::CLEANUP_NLINE_MSB);
     6475
     6476                DspinOdccpParam::dspin_set(dspin_send_data,
    64776477                                           r_dcache_cc_send_way.read(),
    6478                                            DspinDhccpParam::CLEANUP_WAY_INDEX);
    6479 
    6480                 DspinDhccpParam::dspin_set(dspin_send_data,
    6481                                            DspinDhccpParam::TYPE_CLEANUP_DATA,
    6482                                            DspinDhccpParam::FROM_L1_TYPE);
     6478                                           DspinOdccpParam::CLEANUP_WAY_INDEX);
     6479
     6480                DspinOdccpParam::dspin_set(dspin_send_data,
     6481                                           DspinOdccpParam::TYPE_CLEANUP_DATA,
     6482                                           DspinOdccpParam::FROM_L1_TYPE);
    64836483                /*ODCCP*/ // If cleanup on NCC line we set the CLEANUP_NCC bit in cleanup flit
    64846484                if (r_dcache_cleanup_ncc.read())                 
    64856485                {
    6486                     DspinDhccpParam::dspin_set(dspin_send_data,
     6486                    DspinOdccpParam::dspin_set(dspin_send_data,
    64876487                                               1,
    6488                                                DspinDhccpParam::CLEANUP_NCC);
     6488                                               DspinOdccpParam::CLEANUP_NCC);
    64896489                }
    64906490                else
    64916491                {
    6492                     DspinDhccpParam::dspin_set(dspin_send_data,
     6492                    DspinOdccpParam::dspin_set(dspin_send_data,
    64936493                                               0,
    6494                                                DspinDhccpParam::CLEANUP_NCC);
     6494                                               DspinOdccpParam::CLEANUP_NCC);
    64956495                }
    64966496
     
    65006500                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
    65016501                                >> (m_nline_width - m_x_width - m_y_width)
    6502                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    6503 
    6504                 DspinDhccpParam::dspin_set(dspin_send_data,
     6502                                << (DspinOdccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6503
     6504                DspinOdccpParam::dspin_set(dspin_send_data,
    65056505                                           dest,
    6506                                            DspinDhccpParam::CLEANUP_DEST);
    6507 
    6508                 DspinDhccpParam::dspin_set(dspin_send_data,
     6506                                           DspinOdccpParam::CLEANUP_DEST);
     6507
     6508                DspinOdccpParam::dspin_set(dspin_send_data,
    65096509                                           (r_icache_cc_send_nline.read() & 0x300000000ULL)>>32,
    6510                                            DspinDhccpParam::CLEANUP_NLINE_MSB);
    6511 
    6512                 DspinDhccpParam::dspin_set(dspin_send_data,
     6510                                           DspinOdccpParam::CLEANUP_NLINE_MSB);
     6511
     6512                DspinOdccpParam::dspin_set(dspin_send_data,
    65136513                                           r_icache_cc_send_way.read(),
    6514                                            DspinDhccpParam::CLEANUP_WAY_INDEX);
    6515 
    6516                 DspinDhccpParam::dspin_set(dspin_send_data,
    6517                                            DspinDhccpParam::TYPE_CLEANUP_INST,
    6518                                            DspinDhccpParam::FROM_L1_TYPE);
     6514                                           DspinOdccpParam::CLEANUP_WAY_INDEX);
     6515
     6516                DspinOdccpParam::dspin_set(dspin_send_data,
     6517                                           DspinOdccpParam::TYPE_CLEANUP_INST,
     6518                                           DspinOdccpParam::FROM_L1_TYPE);
    65196519               
    6520                 DspinDhccpParam::dspin_set(dspin_send_data,
     6520                DspinOdccpParam::dspin_set(dspin_send_data,
    65216521                                           0,
    6522                                            DspinDhccpParam::CLEANUP_NCC);
     6522                                           DspinOdccpParam::CLEANUP_NCC);
    65236523            }
    65246524            // send flit
     
    65446544            if(r_cc_send_last_client.read() == 0) // dcache active request
    65456545            {
    6546                 DspinDhccpParam::dspin_set(dspin_send_data,
     6546                DspinOdccpParam::dspin_set(dspin_send_data,
    65476547                                           r_dcache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6548                                            DspinDhccpParam::CLEANUP_NLINE_LSB);
     6548                                           DspinOdccpParam::CLEANUP_NLINE_LSB);
    65496549            }
    65506550            else                                  // icache active request
    65516551            {
    6552                 DspinDhccpParam::dspin_set(dspin_send_data,
     6552                DspinOdccpParam::dspin_set(dspin_send_data,
    65536553                                           r_icache_cc_send_nline.read() & 0xFFFFFFFFULL,
    6554                                            DspinDhccpParam::CLEANUP_NLINE_LSB);
     6554                                           DspinOdccpParam::CLEANUP_NLINE_LSB);
    65556555            }
    65566556            // send flit
     
    65716571            }
    65726572
    6573             DspinDhccpParam::dspin_set(dspin_send_data,
     6573            DspinOdccpParam::dspin_set(dspin_send_data,
    65746574                                       r_cc_send_data_fifo.read(),
    6575                                        DspinDhccpParam::CLEANUP_DATA_UPDT);
     6575                                       DspinOdccpParam::CLEANUP_DATA_UPDT);
    65766576           
    65776577            p_dspin_out.data = dspin_send_data;
     
    65836583        {
    65846584            // initialize dspin send data
    6585 //            DspinDhccpParam::dspin_set(dspin_send_data,
     6585//            DspinOdccpParam::dspin_set(dspin_send_data,
    65866586//                                       1,
    6587 //                                       DspinDhccpParam::FROM_L1_EOP);
    6588             DspinDhccpParam::dspin_set(dspin_send_data,
     6587//                                       DspinOdccpParam::FROM_L1_EOP);
     6588            DspinOdccpParam::dspin_set(dspin_send_data,
    65896589                                       0,
    6590                                        DspinDhccpParam::FROM_L1_BC);
    6591             DspinDhccpParam::dspin_set(dspin_send_data,
    6592                                        DspinDhccpParam::TYPE_MULTI_ACK,
    6593                                        DspinDhccpParam::FROM_L1_TYPE);
     6590                                       DspinOdccpParam::FROM_L1_BC);
     6591            DspinOdccpParam::dspin_set(dspin_send_data,
     6592                                       DspinOdccpParam::TYPE_MULTI_ACK,
     6593                                       DspinOdccpParam::FROM_L1_TYPE);
    65946594
    65956595            if(r_cc_send_last_client.read() == 0) // dcache active request
     
    65976597                uint64_t dest = (uint64_t) r_dcache_cc_send_nline.read()
    65986598                                >> (m_nline_width - m_x_width - m_y_width)
    6599                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6599                                << (DspinOdccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    66006600 
    6601                 DspinDhccpParam::dspin_set(dspin_send_data,
     6601                DspinOdccpParam::dspin_set(dspin_send_data,
    66026602                                           dest,
    6603                                            DspinDhccpParam::MULTI_ACK_DEST);
    6604 
    6605                 DspinDhccpParam::dspin_set(dspin_send_data,
     6603                                           DspinOdccpParam::MULTI_ACK_DEST);
     6604
     6605                DspinOdccpParam::dspin_set(dspin_send_data,
    66066606                                           r_dcache_cc_send_updt_tab_idx.read(),
    6607                                            DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
     6607                                           DspinOdccpParam::MULTI_ACK_UPDT_INDEX);
    66086608            }
    66096609            else                                    // icache active request
     
    66116611                uint64_t dest = (uint64_t) r_icache_cc_send_nline.read()
    66126612                                >> (m_nline_width - m_x_width - m_y_width)
    6613                                 << (DspinDhccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
     6613                                << (DspinOdccpParam::GLOBALID_WIDTH - m_x_width - m_y_width);
    66146614 
    66156615
    6616                 DspinDhccpParam::dspin_set(dspin_send_data,
     6616                DspinOdccpParam::dspin_set(dspin_send_data,
    66176617                                           dest,
    6618                                            DspinDhccpParam::MULTI_ACK_DEST);
    6619 
    6620                 DspinDhccpParam::dspin_set(dspin_send_data,
     6618                                           DspinOdccpParam::MULTI_ACK_DEST);
     6619
     6620                DspinOdccpParam::dspin_set(dspin_send_data,
    66216621                                           r_icache_cc_send_updt_tab_idx.read(),
    6622                                            DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
     6622                                           DspinOdccpParam::MULTI_ACK_UPDT_INDEX);
    66236623            }
    66246624            // send flit
  • branches/ODCCP/modules/vci_mem_cache/caba/metadata/vci_mem_cache.sd

    r452 r453  
    4040            Uses('caba:generic_fifo'),
    4141            Uses('caba:generic_llsc_global_table'),
    42             Uses('caba:dspin_dhccp_param')
     42            Uses('caba:dspin_odccp_param')
    4343        ],
    4444
  • branches/ODCCP/modules/vci_mem_cache/caba/source/include/vci_mem_cache.h

    r452 r453  
    5050#include "update_tab.h"
    5151#include "dspin_interface.h"
    52 #include "dspin_dhccp_param.h"
     52#include "dspin_odccp_param.h"
    5353
    5454#define TRT_ENTRIES      4      // Number of entries in TRT
  • branches/ODCCP/modules/vci_mem_cache/caba/source/src/vci_mem_cache.cpp

    r452 r453  
    14381438        {
    14391439          uint64_t flit = m_cc_receive_to_multi_ack_fifo.read();
    1440           updt_index    = DspinDhccpParam::dspin_get(flit,
    1441                             DspinDhccpParam::MULTI_ACK_UPDT_INDEX);
     1440          updt_index    = DspinOdccpParam::dspin_get(flit,
     1441                            DspinOdccpParam::MULTI_ACK_UPDT_INDEX);
    14421442
    14431443          cc_receive_to_multi_ack_fifo_get = true;
     
    45524552      uint64_t flit = m_cc_receive_to_cleanup_fifo.read();
    45534553      uint32_t srcid =
    4554         DspinDhccpParam::dspin_get(
     4554        DspinOdccpParam::dspin_get(
    45554555            flit,
    4556             DspinDhccpParam::CLEANUP_SRCID);
     4556            DspinOdccpParam::CLEANUP_SRCID);
    45574557
    45584558      uint8_t type =
    4559         DspinDhccpParam::dspin_get(
     4559        DspinOdccpParam::dspin_get(
    45604560            flit,
    4561             DspinDhccpParam::FROM_L1_TYPE);
     4561            DspinOdccpParam::FROM_L1_TYPE);
    45624562
    45634563      r_cleanup_way_index =
    4564         DspinDhccpParam::dspin_get(
     4564        DspinOdccpParam::dspin_get(
    45654565            flit,
    4566             DspinDhccpParam::CLEANUP_WAY_INDEX);
     4566            DspinOdccpParam::CLEANUP_WAY_INDEX);
    45674567
    45684568      r_cleanup_nline =
    4569         DspinDhccpParam::dspin_get(
     4569        DspinOdccpParam::dspin_get(
    45704570            flit,
    4571             DspinDhccpParam::CLEANUP_NLINE_MSB) << 32;
     4571            DspinOdccpParam::CLEANUP_NLINE_MSB) << 32;
    45724572
    45734573      /*ODCCP*/ // Cleanup on no coherent line if 1
    45744574      r_cleanup_ncc =
    4575         DspinDhccpParam::dspin_get(
     4575        DspinOdccpParam::dspin_get(
    45764576            flit,
    4577             DspinDhccpParam::CLEANUP_NCC);
    4578 
    4579       r_cleanup_inst  = (type == DspinDhccpParam::TYPE_CLEANUP_INST);
     4577            DspinOdccpParam::CLEANUP_NCC);
     4578
     4579      r_cleanup_inst  = (type == DspinOdccpParam::TYPE_CLEANUP_INST);
    45804580      r_cleanup_srcid = srcid;
    45814581
     
    45994599          << " CLEANUP_IDLE> Cleanup request:" << std::hex
    46004600          << " / owner_id = "   << srcid
    4601           << " / owner_ins = "  << (type == DspinDhccpParam::TYPE_CLEANUP_INST) << std::endl;
     4601          << " / owner_ins = "  << (type == DspinOdccpParam::TYPE_CLEANUP_INST) << std::endl;
    46024602#endif
    46034603      break;
     
    46134613
    46144614      addr_t nline = r_cleanup_nline.read() |
    4615         DspinDhccpParam::dspin_get(flit, DspinDhccpParam::CLEANUP_NLINE_LSB);
     4615        DspinOdccpParam::dspin_get(flit, DspinOdccpParam::CLEANUP_NLINE_LSB);
    46164616     
    4617       bool eop = DspinDhccpParam::dspin_get(flit, DspinDhccpParam::FROM_L1_EOP);
     4617      bool eop = DspinOdccpParam::dspin_get(flit, DspinOdccpParam::FROM_L1_EOP);
    46184618     
    46194619      /*ODCCP*/ // if not eop (more than 2 flits) there is a cleanup no coherent with data
     
    46524652
    46534653      uint32_t data =
    4654         DspinDhccpParam::dspin_get (flit, DspinDhccpParam::CLEANUP_DATA_UPDT);
     4654        DspinOdccpParam::dspin_get (flit, DspinOdccpParam::CLEANUP_DATA_UPDT);
    46554655
    46564656      r_cleanup_data[r_cleanup_data_index.read()] = data;
     
    69826982
    69836983        uint8_t type =
    6984           DspinDhccpParam::dspin_get(
     6984          DspinOdccpParam::dspin_get(
    69856985              p_dspin_in.data.read(),
    6986               DspinDhccpParam::FROM_L1_TYPE);
    6987 
    6988         if((type == DspinDhccpParam::TYPE_CLEANUP_DATA) or
    6989            (type == DspinDhccpParam::TYPE_CLEANUP_INST))
     6986              DspinOdccpParam::FROM_L1_TYPE);
     6987
     6988        if((type == DspinOdccpParam::TYPE_CLEANUP_DATA) or
     6989           (type == DspinOdccpParam::TYPE_CLEANUP_INST))
    69906990        {
    69916991          r_cc_receive_fsm = CC_RECEIVE_CLEANUP;
     
    69936993        }
    69946994
    6995         if(type == DspinDhccpParam::TYPE_MULTI_ACK)
     6995        if(type == DspinOdccpParam::TYPE_MULTI_ACK)
    69966996        {
    69976997          r_cc_receive_fsm = CC_RECEIVE_MULTI_ACK;
     
    87138713        if(m_config_to_cc_send_inst_fifo.read())
    87148714        {
    8715           multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     8715          multi_inval_type = DspinOdccpParam::TYPE_MULTI_INVAL_INST;
    87168716        }
    87178717        else
    87188718        {
    8719           multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     8719          multi_inval_type = DspinOdccpParam::TYPE_MULTI_INVAL_DATA;
    87208720        }
    87218721
    87228722        uint64_t flit = 0;
    87238723        uint64_t dest = m_config_to_cc_send_srcid_fifo.read() <<
    8724                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8725 
    8726         DspinDhccpParam::dspin_set( flit,
     8724                        (DspinOdccpParam::SRCID_WIDTH - vci_param_int::S);
     8725
     8726        DspinOdccpParam::dspin_set( flit,
    87278727                                    dest,
    8728                                     DspinDhccpParam::MULTI_INVAL_DEST);
    8729 
    8730         DspinDhccpParam::dspin_set( flit,
     8728                                    DspinOdccpParam::MULTI_INVAL_DEST);
     8729
     8730        DspinOdccpParam::dspin_set( flit,
    87318731                                    m_cc_global_id,
    8732                                     DspinDhccpParam::MULTI_INVAL_SRCID);
    8733 
    8734         DspinDhccpParam::dspin_set( flit,
     8732                                    DspinOdccpParam::MULTI_INVAL_SRCID);
     8733
     8734        DspinOdccpParam::dspin_set( flit,
    87358735                                    r_config_to_cc_send_trdid.read(),
    8736                                     DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    8737 
    8738         DspinDhccpParam::dspin_set( flit,
     8736                                    DspinOdccpParam::MULTI_INVAL_UPDT_INDEX);
     8737
     8738        DspinOdccpParam::dspin_set( flit,
    87398739                                    multi_inval_type,
    8740                                     DspinDhccpParam::FROM_MC_TYPE);
     8740                                    DspinOdccpParam::FROM_MC_TYPE);
    87418741        p_dspin_out.write = true;
    87428742        p_dspin_out.data  = flit;
     
    87478747    {
    87488748        uint64_t flit = 0;
    8749         DspinDhccpParam::dspin_set( flit,
     8749        DspinOdccpParam::dspin_set( flit,
    87508750                                    r_config_to_cc_send_nline.read(),
    8751                                     DspinDhccpParam::MULTI_INVAL_NLINE);
     8751                                    DspinOdccpParam::MULTI_INVAL_NLINE);
    87528752        p_dspin_out.eop   = true;
    87538753        p_dspin_out.write = true;
     
    87618761        if(r_cleanup_to_cc_send_inst.read())
    87628762        {
    8763           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_INST;
     8763          cleanup_ack_type = DspinOdccpParam::TYPE_CLEANUP_ACK_INST;
    87648764        }
    87658765        else
    87668766        {
    8767           cleanup_ack_type = DspinDhccpParam::TYPE_CLEANUP_ACK_DATA;
     8767          cleanup_ack_type = DspinOdccpParam::TYPE_CLEANUP_ACK_DATA;
    87688768        }
    87698769
     
    87718771        uint64_t dest =
    87728772          r_cleanup_to_cc_send_srcid.read() <<
    8773           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8774 
    8775         DspinDhccpParam::dspin_set(
     8773          (DspinOdccpParam::SRCID_WIDTH - vci_param_int::S);
     8774
     8775        DspinOdccpParam::dspin_set(
    87768776            flit,
    87778777            dest,
    8778             DspinDhccpParam::CLEANUP_ACK_DEST);
    8779 
    8780         DspinDhccpParam::dspin_set(
     8778            DspinOdccpParam::CLEANUP_ACK_DEST);
     8779
     8780        DspinOdccpParam::dspin_set(
    87818781            flit,
    87828782            r_cleanup_to_cc_send_set_index.read(),
    8783             DspinDhccpParam::CLEANUP_ACK_SET);
    8784 
    8785         DspinDhccpParam::dspin_set(
     8783            DspinOdccpParam::CLEANUP_ACK_SET);
     8784
     8785        DspinOdccpParam::dspin_set(
    87868786            flit,
    87878787            r_cleanup_to_cc_send_way_index.read(),
    8788             DspinDhccpParam::CLEANUP_ACK_WAY);
    8789 
    8790         DspinDhccpParam::dspin_set(
     8788            DspinOdccpParam::CLEANUP_ACK_WAY);
     8789
     8790        DspinOdccpParam::dspin_set(
    87918791            flit,
    87928792            cleanup_ack_type,
    8793             DspinDhccpParam::FROM_MC_TYPE);
     8793            DspinOdccpParam::FROM_MC_TYPE);
    87948794
    87958795        p_dspin_out.eop   = true;
     
    88088808        if(m_xram_rsp_to_cc_send_inst_fifo.read())
    88098809        {
    8810           multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_INST;
     8810          multi_inval_type = DspinOdccpParam::TYPE_MULTI_INVAL_INST;
    88118811        }
    88128812        else
    88138813        {
    8814           multi_inval_type = DspinDhccpParam::TYPE_MULTI_INVAL_DATA;
     8814          multi_inval_type = DspinOdccpParam::TYPE_MULTI_INVAL_DATA;
    88158815        }
    88168816
    88178817        uint64_t flit = 0;
    88188818        uint64_t dest = m_xram_rsp_to_cc_send_srcid_fifo.read() <<
    8819                         (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8820 
    8821         DspinDhccpParam::dspin_set( flit,
     8819                        (DspinOdccpParam::SRCID_WIDTH - vci_param_int::S);
     8820
     8821        DspinOdccpParam::dspin_set( flit,
    88228822                                    dest,
    8823                                     DspinDhccpParam::MULTI_INVAL_DEST);
    8824 
    8825         DspinDhccpParam::dspin_set( flit,
     8823                                    DspinOdccpParam::MULTI_INVAL_DEST);
     8824
     8825        DspinOdccpParam::dspin_set( flit,
    88268826                                    m_cc_global_id,
    8827                                     DspinDhccpParam::MULTI_INVAL_SRCID);
    8828 
    8829         DspinDhccpParam::dspin_set( flit,
     8827                                    DspinOdccpParam::MULTI_INVAL_SRCID);
     8828
     8829        DspinOdccpParam::dspin_set( flit,
    88308830                                    r_xram_rsp_to_cc_send_trdid.read(),
    8831                                     DspinDhccpParam::MULTI_INVAL_UPDT_INDEX);
    8832 
    8833         DspinDhccpParam::dspin_set( flit,
     8831                                    DspinOdccpParam::MULTI_INVAL_UPDT_INDEX);
     8832
     8833        DspinOdccpParam::dspin_set( flit,
    88348834                                    multi_inval_type,
    8835                                     DspinDhccpParam::FROM_MC_TYPE);
     8835                                    DspinOdccpParam::FROM_MC_TYPE);
    88368836        p_dspin_out.write = true;
    88378837        p_dspin_out.data  = flit;
     
    88448844        uint64_t flit = 0;
    88458845
    8846         DspinDhccpParam::dspin_set( flit,
     8846        DspinOdccpParam::dspin_set( flit,
    88478847                                    r_xram_rsp_to_cc_send_nline.read(),
    8848                                     DspinDhccpParam::MULTI_INVAL_NLINE);
     8848                                    DspinOdccpParam::MULTI_INVAL_NLINE);
    88498849        p_dspin_out.eop   = true;
    88508850        p_dspin_out.write = true;
     
    88618861        uint64_t flit = 0;
    88628862
    8863         DspinDhccpParam::dspin_set( flit,
     8863        DspinOdccpParam::dspin_set( flit,
    88648864                                    m_broadcast_boundaries,
    8865                                     DspinDhccpParam::BROADCAST_BOX);
    8866 
    8867         DspinDhccpParam::dspin_set( flit,
     8865                                    DspinOdccpParam::BROADCAST_BOX);
     8866
     8867        DspinOdccpParam::dspin_set( flit,
    88688868                                    m_cc_global_id,
    8869                                     DspinDhccpParam::BROADCAST_SRCID);
    8870 
    8871         DspinDhccpParam::dspin_set( flit,
     8869                                    DspinOdccpParam::BROADCAST_SRCID);
     8870
     8871        DspinOdccpParam::dspin_set( flit,
    88728872                                    1ULL,
    8873                                     DspinDhccpParam::FROM_MC_BC);
     8873                                    DspinOdccpParam::FROM_MC_BC);
    88748874        p_dspin_out.write = true;
    88758875        p_dspin_out.data  = flit;
     
    88808880    {
    88818881        uint64_t flit = 0;
    8882         DspinDhccpParam::dspin_set( flit,
     8882        DspinOdccpParam::dspin_set( flit,
    88838883                                    r_xram_rsp_to_cc_send_nline.read(),
    8884                                     DspinDhccpParam::BROADCAST_NLINE);
     8884                                    DspinOdccpParam::BROADCAST_NLINE);
    88858885        p_dspin_out.write = true;
    88868886        p_dspin_out.eop   = true;
     
    88928892    {
    88938893        uint64_t flit = 0;
    8894         DspinDhccpParam::dspin_set( flit,
     8894        DspinOdccpParam::dspin_set( flit,
    88958895                                    r_config_to_cc_send_nline.read(),
    8896                                     DspinDhccpParam::BROADCAST_NLINE);
     8896                                    DspinOdccpParam::BROADCAST_NLINE);
    88978897        p_dspin_out.write = true;
    88988898        p_dspin_out.eop   = true;
     
    89048904    {
    89058905        uint64_t flit = 0;
    8906         DspinDhccpParam::dspin_set( flit,
     8906        DspinOdccpParam::dspin_set( flit,
    89078907                                    r_write_to_cc_send_nline.read(),
    8908                                     DspinDhccpParam::BROADCAST_NLINE);
     8908                                    DspinOdccpParam::BROADCAST_NLINE);
    89098909        p_dspin_out.write = true;
    89108910        p_dspin_out.eop   = true;
     
    89168916    {
    89178917        uint64_t flit = 0;
    8918         DspinDhccpParam::dspin_set( flit,
     8918        DspinOdccpParam::dspin_set( flit,
    89198919                                    r_cas_to_cc_send_nline.read(),
    8920                                     DspinDhccpParam::BROADCAST_NLINE);
     8920                                    DspinOdccpParam::BROADCAST_NLINE);
    89218921        p_dspin_out.write = true;
    89228922        p_dspin_out.eop   = true;
     
    89328932        if(m_write_to_cc_send_inst_fifo.read())
    89338933        {
    8934           multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST;
     8934          multi_updt_type = DspinOdccpParam::TYPE_MULTI_UPDT_INST;
    89358935        }
    89368936        else
    89378937        {
    8938           multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA;
     8938          multi_updt_type = DspinOdccpParam::TYPE_MULTI_UPDT_DATA;
    89398939        }
    89408940
     
    89428942        uint64_t dest =
    89438943          m_write_to_cc_send_srcid_fifo.read() <<
    8944           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    8945 
    8946         DspinDhccpParam::dspin_set(
     8944          (DspinOdccpParam::SRCID_WIDTH - vci_param_int::S);
     8945
     8946        DspinOdccpParam::dspin_set(
    89478947            flit,
    89488948            dest,
    8949             DspinDhccpParam::MULTI_UPDT_DEST);
    8950 
    8951         DspinDhccpParam::dspin_set(
     8949            DspinOdccpParam::MULTI_UPDT_DEST);
     8950
     8951        DspinOdccpParam::dspin_set(
    89528952            flit,
    89538953            m_cc_global_id,
    8954             DspinDhccpParam::MULTI_UPDT_SRCID);
    8955 
    8956         DspinDhccpParam::dspin_set(
     8954            DspinOdccpParam::MULTI_UPDT_SRCID);
     8955
     8956        DspinOdccpParam::dspin_set(
    89578957            flit,
    89588958            r_write_to_cc_send_trdid.read(),
    8959             DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
    8960 
    8961         DspinDhccpParam::dspin_set(
     8959            DspinOdccpParam::MULTI_UPDT_UPDT_INDEX);
     8960
     8961        DspinOdccpParam::dspin_set(
    89628962            flit,
    89638963            multi_updt_type,
    8964             DspinDhccpParam::FROM_MC_TYPE);
     8964            DspinOdccpParam::FROM_MC_TYPE);
    89658965
    89668966        p_dspin_out.write = true;
     
    89748974        uint64_t flit = 0;
    89758975
    8976         DspinDhccpParam::dspin_set(
     8976        DspinOdccpParam::dspin_set(
    89778977            flit,
    89788978            r_write_to_cc_send_index.read(),
    8979             DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
    8980 
    8981         DspinDhccpParam::dspin_set(
     8979            DspinOdccpParam::MULTI_UPDT_WORD_INDEX);
     8980
     8981        DspinOdccpParam::dspin_set(
    89828982            flit,
    89838983            r_write_to_cc_send_nline.read(),
    8984             DspinDhccpParam::MULTI_UPDT_NLINE);
     8984            DspinOdccpParam::MULTI_UPDT_NLINE);
    89858985
    89868986        p_dspin_out.write = true;
     
    90019001        uint64_t flit = 0;
    90029002
    9003         DspinDhccpParam::dspin_set(
     9003        DspinOdccpParam::dspin_set(
    90049004            flit,
    90059005            multi_updt_be,
    9006             DspinDhccpParam::MULTI_UPDT_BE);
    9007 
    9008         DspinDhccpParam::dspin_set(
     9006            DspinOdccpParam::MULTI_UPDT_BE);
     9007
     9008        DspinOdccpParam::dspin_set(
    90099009            flit,
    90109010            multi_updt_data,
    9011             DspinDhccpParam::MULTI_UPDT_DATA);
     9011            DspinOdccpParam::MULTI_UPDT_DATA);
    90129012
    90139013        p_dspin_out.write = true;
     
    90259025        if(m_cas_to_cc_send_inst_fifo.read())
    90269026        {
    9027           multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_INST;
     9027          multi_updt_type = DspinOdccpParam::TYPE_MULTI_UPDT_INST;
    90289028        }
    90299029        else
    90309030        {
    9031           multi_updt_type = DspinDhccpParam::TYPE_MULTI_UPDT_DATA;
     9031          multi_updt_type = DspinOdccpParam::TYPE_MULTI_UPDT_DATA;
    90329032        }
    90339033
     
    90359035        uint64_t dest =
    90369036          m_cas_to_cc_send_srcid_fifo.read() <<
    9037           (DspinDhccpParam::SRCID_WIDTH - vci_param_int::S);
    9038 
    9039         DspinDhccpParam::dspin_set(
     9037          (DspinOdccpParam::SRCID_WIDTH - vci_param_int::S);
     9038
     9039        DspinOdccpParam::dspin_set(
    90409040            flit,
    90419041            dest,
    9042             DspinDhccpParam::MULTI_UPDT_DEST);
    9043 
    9044         DspinDhccpParam::dspin_set(
     9042            DspinOdccpParam::MULTI_UPDT_DEST);
     9043
     9044        DspinOdccpParam::dspin_set(
    90459045            flit,
    90469046            m_cc_global_id,
    9047             DspinDhccpParam::MULTI_UPDT_SRCID);
    9048 
    9049         DspinDhccpParam::dspin_set(
     9047            DspinOdccpParam::MULTI_UPDT_SRCID);
     9048
     9049        DspinOdccpParam::dspin_set(
    90509050            flit,
    90519051            r_cas_to_cc_send_trdid.read(),
    9052             DspinDhccpParam::MULTI_UPDT_UPDT_INDEX);
    9053 
    9054         DspinDhccpParam::dspin_set(
     9052            DspinOdccpParam::MULTI_UPDT_UPDT_INDEX);
     9053
     9054        DspinOdccpParam::dspin_set(
    90559055            flit,
    90569056            multi_updt_type,
    9057             DspinDhccpParam::FROM_MC_TYPE);
     9057            DspinOdccpParam::FROM_MC_TYPE);
    90589058
    90599059        p_dspin_out.write = true;
     
    90679067        uint64_t flit = 0;
    90689068
    9069         DspinDhccpParam::dspin_set(
     9069        DspinOdccpParam::dspin_set(
    90709070            flit,
    90719071            r_cas_to_cc_send_index.read(),
    9072             DspinDhccpParam::MULTI_UPDT_WORD_INDEX);
    9073 
    9074         DspinDhccpParam::dspin_set(
     9072            DspinOdccpParam::MULTI_UPDT_WORD_INDEX);
     9073
     9074        DspinOdccpParam::dspin_set(
    90759075            flit,
    90769076            r_cas_to_cc_send_nline.read(),
    9077             DspinDhccpParam::MULTI_UPDT_NLINE);
     9077            DspinOdccpParam::MULTI_UPDT_NLINE);
    90789078
    90799079        p_dspin_out.write = true;
     
    90879087        uint64_t flit = 0;
    90889088
    9089         DspinDhccpParam::dspin_set(
     9089        DspinOdccpParam::dspin_set(
    90909090            flit,
    90919091            0xF,
    9092             DspinDhccpParam::MULTI_UPDT_BE);
    9093 
    9094         DspinDhccpParam::dspin_set(
     9092            DspinOdccpParam::MULTI_UPDT_BE);
     9093
     9094        DspinOdccpParam::dspin_set(
    90959095            flit,
    90969096            r_cas_to_cc_send_wdata.read(),
    9097             DspinDhccpParam::MULTI_UPDT_DATA);
     9097            DspinOdccpParam::MULTI_UPDT_DATA);
    90989098
    90999099        p_dspin_out.write = true;
     
    91089108        uint64_t flit = 0;
    91099109
    9110         DspinDhccpParam::dspin_set(
     9110        DspinOdccpParam::dspin_set(
    91119111            flit,
    91129112            0xF,
    9113             DspinDhccpParam::MULTI_UPDT_BE);
    9114 
    9115         DspinDhccpParam::dspin_set(
     9113            DspinOdccpParam::MULTI_UPDT_BE);
     9114
     9115        DspinOdccpParam::dspin_set(
    91169116            flit,
    91179117            r_cas_to_cc_send_wdata_high.read(),
    9118             DspinDhccpParam::MULTI_UPDT_DATA);
     9118            DspinOdccpParam::MULTI_UPDT_DATA);
    91199119
    91209120        p_dspin_out.write = true;
Note: See TracChangeset for help on using the changeset viewer.