source: trunk/lib/vci_ring_initiator/caba/source/include/vci_ring_initiator.h @ 34

Last change on this file since 34 was 34, checked in by simerabe, 14 years ago

fixing bug : (cast after shift) rsrcid

File size: 23.2 KB
Line 
1 /* SOCLIB_LGPL_HEADER_BEGIN
2 *
3 * This file is part of SoCLib, GNU LGPLv2.1.
4 *
5 * SoCLib is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU Lesser General Public License as published
7 * by the Free Software Foundation; version 2.1 of the License.
8 *
9 * SoCLib is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with SoCLib; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301 USA
18 *
19 * SOCLIB_LGPL_HEADER_END
20 *
21 * Author   : Abdelmalek SI MERABET
22 * Date     : March 2010
23 * Copyright: UPMC - LIP6
24 */
25///////////////////////////////////////////////////////////////////////////////////
26//   Ring : Read Command Packet Format : 2 flits                                 //
27//---------------------------------------------------------------------------------
28//  1st flit    | eop |                address* = (X,Y)(10) + OFFSET(28)        |0|
29//     (40)       (1)                      (38)                                 (1) 
30//---------------------------------------------------------------------------------
31//  2nd flit    | eop | res | srcid  | cmd | contig |const | plen | pktid | trdid |
32//     (39)       (1)    5     (14)    (2)    (1)     (1)    (8)    (4)      (4)   
33///////////////////////////////////////////////////////////////////////////////////
34//   Ring : Write Command Packet Format : 2 + N flits                            //
35//---------------------------------------------------------------------------------
36//  1st flit    | eop |                   address                               |0|
37//     (40)       (1)                      (38)                                 (1)
38//---------------------------------------------------------------------------------
39//  2nd flit    | eop | res | srcid  | cmd | contig |const | plen | pktid | trdid |
40//     (40)       (1)    3     (14)    (2)    (1)     (1)    (8)    (4)      (4)   
41//---------------------------------------------------------------------------------
42//  next flits  | eop |res| be |              wdata                               |
43//    (40)        (1)  (3)  (4)                (32)                                 
44///////////////////////////////////////////////////////////////////////////////////
45//   Ring : Read & write Response Packet Format : 1 + N flits     //
46//-----------------------------------------------------------------
47//  1st flit    | eop | res  |  rsrcid  | rerror | rpktid | rtrdid |
48//     (33)       (1)    6       (14)      (4)      (4)      (4)
49//-----------------------------------------------------------------
50//  next flits  | eop |                   data                    |
51//     (33)       (1)                     (32)                 
52/////////////////////////////////////////////////////////////////////////////////////
53//   Ring : Broadcast : 2 flits                                                    //
54//-----------------------------------------------------------------------------------
55//  1st flit    | eop | res |  srcid | trdid |xmin  |xmax  |ymin  |ymax  |1|
56//     (40)       (1)    4     (14)     (4)    (4)    (4)    (4)    (4)  (1)
57//-----------------------------------------------------------------------------------
58// confinement broadcast : pour 16 clusters
59// xmin = 0, xmax = F, ymin = 0, ymax = F d'où conf = 0x0F0F
60//-----------------------------------------------------------------------------------
61//  next flits  | eop |res| be |                wdata                               |
62//    (40)        (1)  (3)  (4)                 (32)                                 
63//  next flit   | eop | res |                   nline                               |
64//     (40)       (1)   (5)                     (34)                                   
65/////////////////////////////////////////////////////////////////////////////////////
66
67#include "vci_target.h"
68#include "generic_fifo.h"
69#include "mapping_table.h"
70#include "ring_signals_2.h"
71#include <systemc.h>
72
73//#define I_DEBUG
74//#define IR_DEBUG
75//#define I_DEBUG_FSM
76
77namespace soclib { namespace caba {
78
79using namespace sc_core;
80
81#ifdef I_DEBUG_FSM
82namespace {
83        const char *vci_cmd_fsm_state_str_i[] = {
84                "CMD_FIRST_HEADER",
85                "CMD_SECOND_HEADER",
86                "WDATA",
87        };
88        const char *vci_rsp_fsm_state_str_i[] = {
89                "RSP_HEADER",
90                "RSP_DATA",
91        };
92        const char *ring_cmd_fsm_state_str_i[] = {
93                "CMD_IDLE",
94                "DEFAULT",
95                "KEEP",
96        };
97        const char *ring_rsp_fsm_state_str_i[] = {
98                "RSP_IDLE",
99                "LOCAL",
100                "RING",
101        };
102}
103#endif
104
105template<typename vci_param, int ring_cmd_data_size, int ring_rsp_data_size>
106class VciRingInitiator
107{
108
109typedef soclib::caba::VciTarget<vci_param> vci_target_t;
110typedef RingSignals2 ring_signal_t;
111
112private:
113        enum vci_cmd_fsm_state_e {
114            CMD_FIRST_HEADER,     // first  flit for a ring cmd packet (read or write)
115            CMD_SECOND_HEADER,   //  second flit for a ring cmd packet
116            WDATA,              //   data flit for a ring cmd write packet
117        };
118       
119        enum vci_rsp_fsm_state_e {
120            RSP_HEADER,     // first flit for a ring rsp packet (read or write)
121            RSP_DATA,       // next  flit for a ring rsp packet
122           
123        };
124       
125        enum ring_rsp_fsm_state_e {
126                RSP_IDLE,    // waiting for first flit of a response packet
127                LOCAL,      // next flit of a local rsp packet
128                RING,       // next flit of a ring rsp packet
129            };
130       
131        // cmd token allocation fsm
132        enum ring_cmd_fsm_state_e {
133                CMD_IDLE,           
134                DEFAULT,       
135                KEEP,               
136            };
137       
138        // structural parameters
139        bool                m_alloc_init;
140        uint32_t            m_srcid;
141        std::string         m_name;
142 
143        // internal registers
144        sc_signal<int>      r_ring_cmd_fsm;    // ring command packet FSM (distributed)
145        sc_signal<int>      r_ring_rsp_fsm;    // ring response packet FSM
146        sc_signal<int>      r_vci_cmd_fsm;    // vci command packet FSM
147        sc_signal<int>      r_vci_rsp_fsm;    // vci response packet FSM
148       
149        sc_signal<bool>     r_read_ack;       // vci ack  if vci cmd read
150         
151        sc_signal<sc_uint<vci_param::S> >      r_srcid_save;
152        sc_signal<sc_uint<vci_param::T> >      r_trdid_save;
153        sc_signal<sc_uint<vci_param::P> >      r_pktid_save;
154        sc_signal<sc_uint<vci_param::E> >      r_error_save;
155           
156        // internal fifos
157        GenericFifo<uint64_t > m_cmd_fifo;     // fifo for the local command packet
158        GenericFifo<uint64_t > m_rsp_fifo;     // fifo for the local response packet
159       
160        // routing table
161        soclib::common::AddressMaskingTable<uint32_t> m_rt;
162        soclib::common::AddressDecodingTable<uint32_t, bool> m_lt;
163
164bool trace(int sc_time_stamp)
165{
166int time_stamp=0;
167char *ctime_stamp= getenv("FROM_CYCLE");
168
169if (ctime_stamp) time_stamp=atoi(ctime_stamp); 
170
171return sc_time_stamp >= time_stamp;
172
173}
174
175public :
176
177VciRingInitiator(
178        const char     *name,
179        bool            alloc_init,
180        const int       &wrapper_fifo_depth,
181        const soclib::common::MappingTable &mt,
182        const soclib::common::IntTab &ringid,
183        const uint32_t &srcid)
184      : m_name(name),
185        m_alloc_init(alloc_init),
186        m_cmd_fifo("m_cmd_fifo", wrapper_fifo_depth),
187        m_rsp_fifo("m_rsp_fifo", wrapper_fifo_depth),
188        m_rt(mt.getIdMaskingTable(ringid.level())),
189        m_lt(mt.getIdLocalityTable(ringid)),
190        m_srcid(srcid),
191        r_ring_cmd_fsm("r_ring_cmd_fsm"),
192        r_ring_rsp_fsm("r_ring_rsp_fsm"),
193        r_vci_cmd_fsm("r_vci_cmd_fsm"),
194        r_vci_rsp_fsm("r_vci_rsp_fsm")
195 
196 {} //  end constructor
197
198void reset()
199{
200        if(m_alloc_init)
201                r_ring_cmd_fsm = DEFAULT;
202        else
203                r_ring_cmd_fsm = CMD_IDLE;
204
205        r_vci_cmd_fsm = CMD_FIRST_HEADER;
206        r_vci_rsp_fsm = RSP_HEADER;
207        r_ring_rsp_fsm = RSP_IDLE;
208        m_cmd_fifo.init();
209        m_rsp_fifo.init();
210}
211
212void transition(const vci_target_t &p_vci, const ring_signal_t p_ring_in)       
213{
214
215        bool      cmd_fifo_get = false;
216        bool      cmd_fifo_put = false;
217        uint64_t  cmd_fifo_data = 0;
218
219        bool      rsp_fifo_get = false;
220        bool      rsp_fifo_put = false;
221        uint64_t  rsp_fifo_data = 0;
222
223#ifdef I_DEBUG_FSM
224if( trace(sc_time_stamp()))
225    std::cout << sc_time_stamp() << " - " << m_name
226                                 << " - vci cmd = " << vci_cmd_fsm_state_str_i[r_vci_cmd_fsm]
227                                 << " - vci rsp = " << vci_rsp_fsm_state_str_i[r_vci_rsp_fsm]
228                                 << " - ring cmd = " << ring_cmd_fsm_state_str_i[r_ring_cmd_fsm] 
229                                 << " - ring rsp = " << ring_rsp_fsm_state_str_i[r_ring_rsp_fsm]
230                                 << std::endl;
231#endif
232//////////// VCI CMD FSM /////////////////////////
233        switch ( r_vci_cmd_fsm ) 
234        {
235                case CMD_FIRST_HEADER:       
236                        if ( p_vci.cmdval.read() ) 
237                        { 
238#ifdef I_DEBUG
239if( trace(sc_time_stamp()))
240std::cout << sc_time_stamp() << " -- " << m_name 
241          << " -- r_vci_cmd_fsm -- CMD_FIRST_HEADER "
242          << " -- vci_cmdval : " << p_vci.cmdval.read()
243          << " -- vci_address : " << std::hex << p_vci.address.read()
244          << " -- vci_srcid : " << p_vci.srcid.read()
245          << " -- fifo_wok : " << m_cmd_fifo.wok()
246          << std::endl;
247#endif
248                                cmd_fifo_data = (uint64_t) ((p_vci.address.read() >> 2) << 1); 
249                                r_read_ack = p_vci.eop.read() 
250                                                && ((p_vci.cmd.read() == vci_param::CMD_READ) 
251                                                ||  (p_vci.cmd.read() == vci_param::CMD_LOCKED_READ)); 
252
253                                if(m_cmd_fifo.wok())
254                                {       
255                                        cmd_fifo_put  = true;
256
257                                        // test sur broadcast
258                                        if ((p_vci.address.read() & 0x3) == 0x3)     
259                                        {
260
261                                              cmd_fifo_data = cmd_fifo_data | ((uint64_t) 0x1) |
262                                                                              (((uint64_t) 0x5) << 1) | 
263                                                                              (((uint64_t) p_vci.srcid.read()) << 20) | 
264                                                                              (((uint64_t) (p_vci.trdid.read() & 0xF)) << 16);
265
266                                              r_vci_cmd_fsm = WDATA;
267   
268                                        }
269                                        else
270                                        {
271                                                r_vci_cmd_fsm = CMD_SECOND_HEADER;
272     
273                                        }                                   
274                                } // end fifo wok
275
276
277                        } // end if cmdval             
278                break;
279   
280                case CMD_SECOND_HEADER:
281
282#ifdef I_DEBUG
283if( trace(sc_time_stamp()))
284         std::cout << sc_time_stamp() << " -- " << m_name 
285              << " -- r_vci_cmd_fsm -- CMD_SECOND_HEADER "
286              << " -- vci_cmdval : " << p_vci.cmdval.read()
287              << " -- fifo_wok : " << m_cmd_fifo.wok()
288              << " -- vci_cmd : " << std::hex << p_vci.cmd.read()
289              << " -- vci_plen : " << p_vci.plen.read()             
290              << std::endl;
291#endif
292                        if ( p_vci.cmdval.read() && m_cmd_fifo.wok() ) 
293                        {
294
295                                cmd_fifo_put  = true;
296                                cmd_fifo_data =  (((uint64_t) p_vci.srcid.read()) << 20)| 
297                                                 (((uint64_t) (p_vci.cmd.read()   & 0x3))  << 18) |
298                                                 (((uint64_t) (p_vci.plen.read()  & 0xFF)) << 8) | 
299                                                 (((uint64_t) (p_vci.pktid.read() & 0xF))  << 4) | 
300                                                 (uint64_t) (p_vci.trdid.read() & 0xF); 
301                                if (p_vci.contig == true)
302                                        cmd_fifo_data = cmd_fifo_data | ((uint64_t) 0x1) << 17; 
303                                if (p_vci.cons == true)
304                                        cmd_fifo_data = cmd_fifo_data | ((uint64_t) 0x1) << 16;
305                                if(r_read_ack)
306                                {
307                                        cmd_fifo_data =  cmd_fifo_data | (((uint64_t) 0x1) << (ring_cmd_data_size-1)); //39
308                                        r_vci_cmd_fsm = CMD_FIRST_HEADER;
309                                } 
310                                else     // write command
311                                {
312                                        r_vci_cmd_fsm = WDATA;         
313                                }                                     
314                        } // endif cmdval
315                break;   
316
317                case WDATA: 
318
319 #ifdef I_DEBUG
320if( trace(sc_time_stamp()))
321         std::cout << sc_time_stamp() << " -- " << m_name 
322              << " -- r_vci_cmd_fsm -- WDATA "
323              << " -- vci_cmdval : " << p_vci.cmdval.read()
324              << " -- fifo_wok : " << m_cmd_fifo.wok()
325              << " -- vci_wdata : " << std::hex << p_vci.wdata.read()
326              << " -- vci_be : " << p_vci.be.read() 
327              << " -- vci_eop : " << p_vci.eop.read()             
328              << std::endl;
329#endif
330                        if ( p_vci.cmdval.read() && m_cmd_fifo.wok() ) 
331                        {
332
333
334
335                                cmd_fifo_put  = true;
336                                cmd_fifo_data =  ((uint64_t) p_vci.wdata.read()) | (((uint64_t) p_vci.be.read()) << 32);
337                                if ( p_vci.eop.read() == true ) 
338                                {
339                                        r_vci_cmd_fsm = CMD_FIRST_HEADER;
340                                        cmd_fifo_data = cmd_fifo_data | (((uint64_t) 0x1) << (ring_cmd_data_size-1)); //39
341                                }
342                                else 
343                                        r_vci_cmd_fsm = WDATA;
344                        } // end if cmdval
345                break;
346       
347        } // end switch r_vci_cmd_fsm 
348
349/////////// VCI RSP FSM /////////////////////////
350        switch ( r_vci_rsp_fsm ) 
351        {
352                case RSP_HEADER:
353 
354                        if ( m_rsp_fifo.rok() ) 
355                        {
356
357#ifdef I_DEBUG
358if( trace(sc_time_stamp()))
359         std::cout << sc_time_stamp() << " -- " << m_name 
360              << " -- r_vci_rsp_fsm -- RSP_HEADER "
361              << " -- fifo_rsp_rok : " << m_rsp_fifo.rok()
362              << std::endl;
363#endif
364                                rsp_fifo_get = true;
365                                r_srcid_save = (sc_uint<vci_param::S>)  (m_rsp_fifo.read() >> 12);
366                                r_trdid_save = (sc_uint<vci_param::T>)  (m_rsp_fifo.read() & 0xF); 
367                                r_pktid_save = ((sc_uint<vci_param::P>) (m_rsp_fifo.read() >> 4)) & 0xF;           
368                                r_error_save = ((sc_uint<vci_param::E>) (m_rsp_fifo.read() >> 8)) & 0x1;
369                                r_vci_rsp_fsm = RSP_DATA;
370                        }       
371                break;
372
373                case RSP_DATA:
374#ifdef I_DEBUG
375if( trace(sc_time_stamp()))
376         std::cout << sc_time_stamp() << " -- " << m_name
377              << " -- r_vci_rsp_fsm -- RSP_DATA "
378              << " -- fifo rok : " << m_rsp_fifo.rok()
379              << " -- rspack : " <<  p_vci.rspack.read()
380              << " -- rsrcid : " << std::hex << r_srcid_save.read()
381              << " -- rdata : " <<  m_rsp_fifo.read()
382              << " -- rerror : " << r_error_save.read()
383              << std::endl;
384#endif
385                        if ( p_vci.rspack.read() && m_rsp_fifo.rok() ) 
386                        {
387
388                                rsp_fifo_get = true;           
389                                if(((m_rsp_fifo.read()  >> 32) & 0x1) == 0x1) 
390                                        r_vci_rsp_fsm = RSP_HEADER;                   
391                        } // endif rspack && rok
392                break;
393
394        } // end switch r_vci_rsp_fsm
395
396//////////// RING CMD FSM /////////////////////////
397        switch( r_ring_cmd_fsm ) 
398        {
399                case CMD_IDLE:   
400#ifdef IR_DEBUG
401if( trace(sc_time_stamp())) 
402std::cout << sc_time_stamp() << " -- " << m_name << " -- r_ring_cmd_fsm : CMD_IDLE "
403          << " -- fifo ROK : " << m_cmd_fifo.rok()
404          << " -- in grant : " << p_ring_in.cmd_grant
405          << " -- fifo _data : " << std::hex << m_cmd_fifo.read()
406          << std::endl;
407
408#endif
409   
410                        if ( p_ring_in.cmd_grant && m_cmd_fifo.rok() ) 
411                        {
412// debug above is here
413                                r_ring_cmd_fsm = KEEP; 
414                        }
415                break;
416
417                case DEFAULT: 
418#ifdef IR_DEBUG
419if( trace(sc_time_stamp())) 
420std::cout << sc_time_stamp() << " -- " << m_name << " -- r_ring_cmd_fsm : DEFAULT "
421          << " -- fifo ROK : " << m_cmd_fifo.rok()
422          << " -- in grant : " << p_ring_in.cmd_grant
423          << " -- fifo _data : " << std::hex << m_cmd_fifo.read()
424          << std::endl;
425
426#endif
427
428       
429                        if ( m_cmd_fifo.rok() ) 
430                        {
431// debug above is here
432                                cmd_fifo_get = p_ring_in.cmd_r; 
433                                r_ring_cmd_fsm = KEEP;             
434                        }   
435                        else if ( !p_ring_in.cmd_grant )
436                                r_ring_cmd_fsm = CMD_IDLE; 
437                break;
438
439                case KEEP:   
440#ifdef IR_DEBUG
441if( trace(sc_time_stamp())) 
442std::cout << sc_time_stamp() << " -- " << m_name
443          << " -- r_ring_cmd_fsm : KEEP "
444          << " -- fifo_rok : " << m_cmd_fifo.rok()
445          << " -- in grant : " << p_ring_in.cmd_grant
446          << " -- ring_in_wok : " << p_ring_in.cmd_r
447          << " -- fifo_out_data : " << std::hex << m_cmd_fifo.read()
448          << std::endl;
449#endif
450                         
451                        if(m_cmd_fifo.rok() && p_ring_in.cmd_r ) 
452                        {
453// debug above is here
454                                cmd_fifo_get = true; 
455                                if (((int) (m_cmd_fifo.read() >> (ring_cmd_data_size - 1) ) & 0x1) == 1)  // 39
456                                { 
457                                        if ( p_ring_in.cmd_grant )
458                                                r_ring_cmd_fsm = DEFAULT; 
459                                        else   
460                                                r_ring_cmd_fsm = CMD_IDLE; 
461                                }       
462                        }     
463                break;
464
465        } // end switch ring cmd fsm
466 
467/////////// RING RSP FSM ////////////////////////
468   
469        switch( r_ring_rsp_fsm ) 
470        {
471                case RSP_IDLE: 
472                {
473                        int  rsrcid  = (int)  ((p_ring_in.rsp_data >> 12) & 0x3FFF);
474                        bool islocal = m_lt[rsrcid] && (m_rt[rsrcid] == m_srcid);
475                        bool reop     = ((p_ring_in.rsp_data >> (ring_rsp_data_size - 1)) & 0x1) == 1; 
476#ifdef IR_DEBUG
477if( trace(sc_time_stamp()))
478        std::cout << sc_time_stamp() << " -- " << m_name 
479              << " -- ring_rsp_fsm -- RSP_IDLE "
480              << " -- islocal : " << islocal
481              << " -- eop : " << reop
482              << " -- rsrcid : " << std::hex << rsrcid
483              << " -- in rok : " << p_ring_in.rsp_w
484              << " -- in wok : " << p_ring_in.rsp_r
485              << " -- fifo wok : " <<  m_rsp_fifo.wok()         
486              << std::endl;
487#endif
488                        if (p_ring_in.rsp_w  &&  !reop && islocal) 
489                        {   
490                                r_ring_rsp_fsm = LOCAL;
491                                rsp_fifo_put  = m_rsp_fifo.wok();
492                                rsp_fifo_data = p_ring_in.rsp_data;
493                        }
494                        if (p_ring_in.rsp_w  &&  !reop && !islocal) 
495                        {
496                                r_ring_rsp_fsm = RING; 
497                        }
498                        if (!p_ring_in.rsp_w  || reop ) 
499                        {                       
500                                r_ring_rsp_fsm = RSP_IDLE;
501                        }
502                }
503                break;
504
505                case LOCAL:
506                {
507                        bool reop     = ((p_ring_in.rsp_data >> (ring_rsp_data_size - 1)) & 0x1) == 1;
508
509#ifdef IR_DEBUG
510if( trace(sc_time_stamp()))
511         std::cout << sc_time_stamp() << " -- " << m_name 
512              << " -- ring_rsp_fsm -- LOCAL "
513              << " -- in rok : " << p_ring_in.rsp_w
514              << " -- fifo wok : " <<  m_rsp_fifo.wok()   
515              << " -- in data : " << std::hex << p_ring_in.rsp_data
516              << " -- eop : " << reop
517              << std::endl;
518#endif
519
520
521                        if (p_ring_in.rsp_w && m_rsp_fifo.wok() && reop)         
522                        {
523
524                                rsp_fifo_put  = true;
525                                rsp_fifo_data = p_ring_in.rsp_data;
526                                r_ring_rsp_fsm = RSP_IDLE;             
527                        }
528                        if (!p_ring_in.rsp_w || !m_rsp_fifo.wok() || !reop)         
529                        {
530
531                                rsp_fifo_put  = p_ring_in.rsp_w && m_rsp_fifo.wok();
532                                rsp_fifo_data = p_ring_in.rsp_data;
533                                r_ring_rsp_fsm = LOCAL;             
534                        }
535                } 
536                break;
537
538                case RING:   
539                {
540                        bool reop     = ((p_ring_in.rsp_data >> (ring_rsp_data_size - 1)) & 0x1) == 1;
541
542#ifdef IR_DEBUG
543if( trace(sc_time_stamp()))
544         std::cout << sc_time_stamp() << " -- " << m_name 
545              << " -- ring_rsp_fsm -- RING "
546              << " -- in rok : " << p_ring_in.rsp_w
547              << " -- in wok : " <<  p_ring_in.rsp_r   
548              << " -- in data : " << std::hex << p_ring_in.rsp_data
549              << " -- eop : " << reop   
550              << std::endl;
551#endif
552
553
554                        if (p_ring_in.rsp_w && reop)
555                        {
556                                r_ring_rsp_fsm = RSP_IDLE; 
557                        }
558                        else
559                        {
560                                r_ring_rsp_fsm = RING;
561                        }
562                }       
563                break;
564
565        } // end switch rsp fsm
566     
567    ////////////////////////
568    //  fifos update      //
569   ////////////////////////
570
571// local cmd fifo update
572        if (  cmd_fifo_put &&  cmd_fifo_get ) m_cmd_fifo.put_and_get(cmd_fifo_data);
573        else if (  cmd_fifo_put && !cmd_fifo_get ) m_cmd_fifo.simple_put(cmd_fifo_data);
574        else if ( !cmd_fifo_put &&  cmd_fifo_get ) m_cmd_fifo.simple_get();
575       
576// local rsp fifo update
577        if (  rsp_fifo_put &&  rsp_fifo_get ) m_rsp_fifo.put_and_get(rsp_fifo_data);
578        else if (  rsp_fifo_put && !rsp_fifo_get ) m_rsp_fifo.simple_put(rsp_fifo_data);
579        else if ( !rsp_fifo_put &&  rsp_fifo_get ) m_rsp_fifo.simple_get();
580     
581}  // end Transition()
582
583///////////////////////////////////////////////////////////////////
584void genMoore(vci_target_t &p_vci)
585///////////////////////////////////////////////////////////////////
586{
587
588        switch ( r_vci_cmd_fsm ) 
589        {
590                case CMD_FIRST_HEADER:
591                        p_vci.cmdack = false;
592                break;
593
594                case CMD_SECOND_HEADER:
595                        p_vci.cmdack = r_read_ack;
596                break;
597
598                case WDATA:
599                        p_vci.cmdack = m_cmd_fifo.wok();
600                break;   
601
602        } // end switch fsm
603
604        switch ( r_vci_rsp_fsm ) 
605        {
606                case RSP_HEADER:
607                        p_vci.rspval = false;
608                break;
609       
610                case RSP_DATA:
611                        p_vci.rspval = m_rsp_fifo.rok();
612                        p_vci.rsrcid = r_srcid_save;
613                        p_vci.rtrdid = r_trdid_save;
614                        p_vci.rpktid = r_pktid_save;
615                        p_vci.rerror = r_error_save;
616                        p_vci.rdata  = (sc_uint<32>) (m_rsp_fifo.read());       
617                        if (((m_rsp_fifo.read() >> 32) & 0x1) == 0x1)
618                                p_vci.reop   = true;
619                        else 
620                                p_vci.reop   = false;
621                break;
622       
623        } // end switch fsm
624} // end genMoore
625
626///////////////////////////////////////////////////////////////////
627void update_ring_signals(ring_signal_t p_ring_in, ring_signal_t &p_ring_out)
628///////////////////////////////////////////////////////////////////
629{   
630        switch( r_ring_cmd_fsm ) 
631        {
632                case CMD_IDLE:
633                        p_ring_out.cmd_grant = p_ring_in.cmd_grant && !m_cmd_fifo.rok();
634
635                        p_ring_out.cmd_r     = p_ring_in.cmd_r;
636
637                        p_ring_out.cmd_w     = p_ring_in.cmd_w;
638                        p_ring_out.cmd_data  = p_ring_in.cmd_data;
639                break;
640       
641                case DEFAULT:       
642                        p_ring_out.cmd_grant = !( m_cmd_fifo.rok()); 
643
644                        p_ring_out.cmd_r    = 1;
645
646                        p_ring_out.cmd_w    =  m_cmd_fifo.rok();
647                        p_ring_out.cmd_data =  m_cmd_fifo.read();
648                break;
649       
650                case KEEP: 
651                        int cmd_fifo_eop = (int) ((m_cmd_fifo.read() >> (ring_cmd_data_size - 1)) & 0x1) ; //39
652                        p_ring_out.cmd_grant = m_cmd_fifo.rok() && p_ring_in.cmd_r && (cmd_fifo_eop == 1);
653
654                        p_ring_out.cmd_r    = 1;       
655
656                        p_ring_out.cmd_w    =  m_cmd_fifo.rok();
657                        p_ring_out.cmd_data =  m_cmd_fifo.read();
658                break;
659       
660        } // end switch
661
662        p_ring_out.rsp_grant = p_ring_in.rsp_grant;
663
664        p_ring_out.rsp_w    = p_ring_in.rsp_w;
665        p_ring_out.rsp_data = p_ring_in.rsp_data;
666
667        switch( r_ring_rsp_fsm ) 
668        {
669                case RSP_IDLE: 
670                {
671                        int  rsrcid   = (int)  ((p_ring_in.rsp_data >> 12 ) & 0x3FFF);
672                        bool islocal  = m_lt[rsrcid] && (m_rt[rsrcid] == m_srcid);
673                        bool reop     = ((p_ring_in.rsp_data >> (ring_rsp_data_size - 1)) & 0x1) == 1;
674
675                        if(p_ring_in.rsp_w && !reop && islocal) {
676                                p_ring_out.rsp_r = m_rsp_fifo.wok();
677                        }
678                        if(p_ring_in.rsp_w && !reop && !islocal) {
679                                p_ring_out.rsp_r = p_ring_in.rsp_r;
680                        }
681                        if(!p_ring_in.rsp_w || reop)  {
682                                p_ring_out.rsp_r = p_ring_in.rsp_r;
683                        }
684 
685                }
686                break;
687       
688                case LOCAL:
689                        p_ring_out.rsp_r = m_rsp_fifo.wok();
690                break;
691       
692                case RING:
693                        p_ring_out.rsp_r = p_ring_in.rsp_r;
694                break;   
695        } // end switch
696
697
698} // end update_ring_signals
699
700};
701
702}} // end namespace
703
704
Note: See TracBrowser for help on using the repository browser.