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

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

new ring components for systemcass

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