source: branches/v4/platforms/tsarv4_mono_mmu_ioc/top.cpp @ 640

Last change on this file since 640 was 640, checked in by porquet, 9 years ago

add framebuffer component

File size: 12.8 KB
Line 
1/*
2 * global config
3 */
4
5#define CONFIG_GDB_SERVER
6
7
8/*
9 * headers
10 */
11
12#ifdef _OPENMP
13#include <omp.h>
14#endif
15
16#include <systemc>
17#include <iostream>
18#include <cstdlib>
19
20#ifdef CONFIG_GDB_SERVER
21#include "gdbserver.h"
22#endif
23
24#include "mapping_table.h"
25
26#include "mips32.h"
27#include "vci_cc_vcache_wrapper_v4.h"
28#include "vci_simple_ram.h"
29#include "vci_mem_cache_v4.h"
30
31#include "vci_icu.h"
32#include "vci_multi_tty.h"
33#include "vci_timer.h"
34#include "vci_block_device_tsar_v4.h"
35#include "vci_framebuffer.h"
36
37#include "vci_vgmn.h"
38
39#include "alloc_elems.h"
40
41
42/*
43 * pf global config
44 */
45
46using namespace sc_core;
47using namespace soclib::caba;
48using namespace soclib::common;
49
50#define cell_width      4
51#define address_width   32
52#define plen_width      8
53#define error_width     2
54#define clen_width      1
55#define rflag_width     1
56#define srcid_width     14
57#define pktid_width     4
58#define trdid_width     4
59#define wrplen_width    1
60
61typedef VciParams<cell_width,
62        plen_width,
63        address_width,
64        error_width,
65        clen_width,
66        rflag_width,
67        srcid_width,
68        pktid_width,
69        trdid_width,
70        wrplen_width> vci_param;
71
72/* mapping table for data */
73MappingTable maptabd(32, IntTab(6), IntTab(6), 0xf0000000);
74/* mapping table for coherence */
75MappingTable maptabc(32, IntTab(srcid_width), IntTab(srcid_width), 0xf0000000);
76
77
78/*
79 * segmentation
80 */
81
82#include "segmentation.h"
83
84
85/*
86 * default parameters
87 */
88
89struct param_s {
90    char *rom_path;
91    char *dsk_path;
92    bool dummy_boot;
93    bool trace_enabled;
94    size_t trace_start_cycle;
95};
96
97#define PARAM_INITIALIZER   \
98{                           \
99    .rom_path = NULL,      \
100    .dsk_path = NULL,        \
101    .dummy_boot = false,    \
102    .trace_enabled = false, \
103    .trace_start_cycle = 0  \
104}
105
106static inline void print_param(const struct param_s &param)
107{
108    std::cout << std::endl;
109    std::cout << "simulation parameters:" << std::endl;
110    std::cout << "  rom         = " << param.rom_path << std::endl;
111    std::cout << "  dummy boot  = " << param.dummy_boot << std::endl;
112    std::cout << "  dsk         = " << param.dsk_path << std::endl;
113    std::cout << "  trace       = " << param.trace_enabled << std::endl;
114    if (param.trace_enabled)
115        std::cout << "    start cyc = " << param.trace_start_cycle << std::endl;
116
117    std::cout << std::endl;
118}
119
120
121/*
122 * arguments parsing
123 */
124
125void args_parse(unsigned int argc, char *argv[], struct param_s &param)
126{
127    for (size_t n = 1; n < argc; n = n + 2)
128    {
129        if ((strcmp(argv[n], "--rom") == 0) && ((n + 1) < argc))
130        {
131            assert((param.rom_path = strdup(argv[n + 1]))
132                    && "insufficient memory");
133        }
134        else if ((strcmp(argv[n], "--dsk") == 0) && ((n + 1) < argc))
135        {
136            assert((param.dsk_path = strdup(argv[n + 1]))
137                    && "insufficient memory");
138        }
139        else if (strcmp(argv[n], "--dummy-boot") == 0)
140        {
141            param.dummy_boot = true;
142            /* we don't have an extra argument */
143            n = n - 1;
144        }
145        else if ((strcmp(argv[n], "--trace") == 0) && ((n + 1) < argc))
146        {
147            param.trace_enabled = true;
148            param.trace_start_cycle = atoi(argv[n + 1]);
149        }
150        else
151        {
152            std::cout << "Error: don't understand option " << argv[n] << std::endl;
153            std::cout << "Accepted arguments are :" << std::endl;
154            std::cout << "--rom pathname" << std::endl;
155            std::cout << "--dsk pathname" << std::endl;
156            std::cout << "[--dummy-boot]" << std::endl;
157            std::cout << "[--trace trace_start_cycle]" << std::endl;
158            exit(0);
159        }
160    }
161
162    /* check parameters */
163    assert(param.rom_path && "--rom is not optional");
164    assert(param.dsk_path && "--dsk is not optional");
165
166    print_param(param);
167}
168
169
170/*
171 * netlist
172 */
173
174int _main(int argc, char *argv[])
175{
176#ifdef _OPENMP
177    omp_set_dynamic(false);
178    omp_set_num_threads(1);
179    std::cerr << "Built with openmp version " << _OPENMP << std::endl;
180#endif
181
182    struct param_s param = PARAM_INITIALIZER;
183
184    /* parse arguments */
185    args_parse(argc, argv, param);
186
187    /*
188     * mapping table (data and coherence)
189     */
190
191    // caches ram bank
192    maptabd.add(Segment("memc_d" , MEMC_BASE , MEMC_SIZE , IntTab(0), true));
193    maptabd.add(Segment("boot_d" , BOOT_BASE , BOOT_SIZE , IntTab(1), true));
194
195    // uncached peripherals
196    maptabd.add(Segment("icu_d"   , ICU_BASE   , ICU_SIZE   , IntTab(2), false));
197    maptabd.add(Segment("mtty_d"  , MTTY_BASE  , MTTY_SIZE  , IntTab(3), false));
198    maptabd.add(Segment("timer_d" , TIMER_BASE , TIMER_SIZE , IntTab(4), false));
199    maptabd.add(Segment("bd_d"    , BD_BASE    , BD_SIZE    , IntTab(5), false));
200    maptabd.add(Segment("fb_d"    , FB_BASE    , FB_SIZE    , IntTab(6), false));
201
202    std::cout << maptabd << std::endl;
203
204    // procs
205    maptabc.add(Segment("proc_c" , 0x0000000 , 0x10 , IntTab(0) , false));
206    maptabc.add(Segment("memc_c" , 1 << (address_width - srcid_width) , 0x10 , IntTab(1) , false));
207
208    std::cout << maptabc << std::endl;
209
210    /*
211     * components
212     */
213
214    Loader loader;
215    loader.load_file(param.rom_path);
216
217#ifdef CONFIG_GDB_SERVER
218    typedef GdbServer<Mips32ElIss> proc_iss;
219    proc_iss::set_loader(loader);
220#else
221    typedef Mips32ElIss proc_iss;
222#endif
223
224    if (param.dummy_boot == true)
225    {
226        /* boot linux image directly */
227        uint64_t entry_addr = loader.get_entry_point_address();
228        std::cout << "setResetAdress: " << std::hex << entry_addr << std::endl << std::endl;
229        proc_iss::setResetAddress(entry_addr);
230    }
231
232    VciCcVCacheWrapperV4<vci_param, proc_iss > proc("ccvcache",
233                0,          // proc_id
234                maptabd,    // direct space
235                maptabc,    // coherence space
236                IntTab(0),  // srcid_d
237                IntTab(0),  // srcid_c
238                IntTab(0),  // tgtid_c
239                8, 8,       // itlb size
240                8, 8,       // dtlb size
241                4, 64, 16,  // icache size
242                4, 64, 16,  // dcache size
243                4, 4,       // wbuf size
244                0, 0,       // x, y Width
245                1,          // memory cache local id
246                1000,       // max frozen cycles
247                param.trace_start_cycle,
248                param.trace_enabled);
249
250    VciSimpleRam<vci_param> ram("ram", IntTab(0), maptabd, loader);
251
252    VciSimpleRam<vci_param> rom("rom", IntTab(1), maptabd, loader);
253
254    VciMemCacheV4<vci_param> memc("memc",
255            maptabd, maptabc, maptabd,
256            IntTab(0), IntTab(1), IntTab(0), IntTab(1), // srcid_d, srcid_c, tgtid_d, tgtid_c
257            16, 256, 16,    // cache size
258            1024, 4, 4,     // HEAP size, TRT size, UPT size
259            param.trace_start_cycle, param.trace_enabled);
260
261    VciIcu<vci_param> icu("icu", IntTab(2), maptabd,
262            3); // #input_irqs
263
264    VciMultiTty<vci_param> mtty("mtty", IntTab(3), maptabd, "vcitty0", NULL);
265
266    VciTimer<vci_param> timer("timer", IntTab(4), maptabd,
267            1); // #timers
268
269    VciBlockDeviceTsarV4<vci_param> bd("bd", maptabd, IntTab(1), IntTab(5),
270            param.dsk_path); // mapped_file[, block_size=512, latency=0]
271
272    VciFrameBuffer<vci_param> fb("fb", IntTab(6), maptabd, FB_XSIZE, FB_YSIZE,
273            FbController::RGB_16);
274
275    VciVgmn<vci_param> vgmnd("vgmnd", maptabd,
276            2, 7,       // #initiators, #targets
277            2, 8,       // min_latency, FIFO depth
278            IntTab(1)); // default target
279
280    VciVgmn<vci_param> vgmnc("vgmnc", maptabc,
281            2, 2,   // #initiators, #targets
282            2, 8);  // min_latency, FIFO depth
283
284    /*
285     * signals
286     */
287
288    /* clock and reset */
289    sc_clock signal_clk("signal_clk");
290    sc_signal<bool> signal_resetn("signal_resetn");
291
292    /* irq lines */
293    sc_signal<bool> *signal_proc_irq =
294        alloc_elems<sc_signal<bool> >("signal_proc_irq", proc_iss::n_irq);
295    sc_signal<bool> signal_mtty_irq("signal_mtty_irq");
296    sc_signal<bool> signal_timer_irq("signal_timer_irq");
297    sc_signal<bool> signal_bd_irq("signal_bd_irq");
298
299    /* vci */
300    VciSignals<vci_param> signal_vci_ini_d_proc("vci_ini_d_proc");
301    VciSignals<vci_param> signal_vci_ini_c_proc("vci_ini_c_proc");
302    VciSignals<vci_param> signal_vci_tgt_c_proc("vci_tgt_c_proc");
303
304    VciSignals<vci_param> signal_vci_ram("signal_vci_ram");
305
306    VciSignals<vci_param> signal_vci_tgt_d_rom("signal_vci_tgt_d_rom");
307
308    VciSignals<vci_param> signal_vci_ini_c_memc("signal_vci_ini_c_memc");
309    VciSignals<vci_param> signal_vci_tgt_d_memc("signal_vci_tgt_d_memc");
310    VciSignals<vci_param> signal_vci_tgt_c_memc("signal_vci_tgt_c_memc");
311
312    VciSignals<vci_param> signal_vci_tgt_d_icu("signal_vci_tgt_d_icu");
313
314    VciSignals<vci_param> signal_vci_tgt_d_mtty("signal_vci_tgt_d_mtty");
315
316    VciSignals<vci_param> signal_vci_tgt_d_timer("signal_vci_tgt_d_timer");
317
318    VciSignals<vci_param> signal_vci_ini_d_bd("signal_vci_ini_d_bd");
319    VciSignals<vci_param> signal_vci_tgt_d_bd("signal_vci_tgt_d_bd");
320
321    VciSignals<vci_param> signal_vci_tgt_d_fb("signal_vci_tgt_d_fb");
322
323    /*
324     * netlist
325     */
326
327    proc.p_clk(signal_clk);
328    proc.p_resetn(signal_resetn);
329    for (size_t i = 0; i < proc_iss::n_irq; i++)
330        proc.p_irq[i](signal_proc_irq[i]);
331    proc.p_vci_ini_d(signal_vci_ini_d_proc);
332    proc.p_vci_ini_c(signal_vci_ini_c_proc);
333    proc.p_vci_tgt_c(signal_vci_tgt_c_proc);
334
335    ram.p_clk(signal_clk);
336    ram.p_resetn(signal_resetn);
337    ram.p_vci(signal_vci_ram);
338
339    rom.p_clk(signal_clk);
340    rom.p_resetn(signal_resetn);
341    rom.p_vci(signal_vci_tgt_d_rom);
342
343    memc.p_clk(signal_clk);
344    memc.p_resetn(signal_resetn);
345    memc.p_vci_tgt(signal_vci_tgt_d_memc);
346    memc.p_vci_tgt_cleanup(signal_vci_tgt_c_memc);
347    memc.p_vci_ini(signal_vci_ini_c_memc);
348    memc.p_vci_ixr(signal_vci_ram);
349
350    icu.p_resetn(signal_resetn);
351    icu.p_clk(signal_clk);
352    icu.p_vci(signal_vci_tgt_d_icu);
353    icu.p_irq_in[0](signal_mtty_irq);
354    icu.p_irq_in[1](signal_timer_irq);
355    icu.p_irq_in[2](signal_bd_irq);
356    icu.p_irq(signal_proc_irq[0]);
357
358    mtty.p_clk(signal_clk);
359    mtty.p_resetn(signal_resetn);
360    mtty.p_vci(signal_vci_tgt_d_mtty);
361    mtty.p_irq[0](signal_mtty_irq);
362
363    timer.p_clk(signal_clk);
364    timer.p_resetn(signal_resetn);
365    timer.p_vci(signal_vci_tgt_d_timer);
366    timer.p_irq[0](signal_timer_irq);
367
368    bd.p_clk(signal_clk);
369    bd.p_resetn(signal_resetn);
370    bd.p_vci_target(signal_vci_tgt_d_bd);
371    bd.p_vci_initiator(signal_vci_ini_d_bd);
372    bd.p_irq(signal_bd_irq);
373
374    fb.p_clk(signal_clk);
375    fb.p_resetn(signal_resetn);
376    fb.p_vci(signal_vci_tgt_d_fb);
377
378    vgmnd.p_clk(signal_clk);
379    vgmnd.p_resetn(signal_resetn);
380    vgmnd.p_to_initiator[0](signal_vci_ini_d_proc);
381    vgmnd.p_to_initiator[1](signal_vci_ini_d_bd);
382    vgmnd.p_to_target[0](signal_vci_tgt_d_memc);
383    vgmnd.p_to_target[1](signal_vci_tgt_d_rom);
384    vgmnd.p_to_target[2](signal_vci_tgt_d_icu);
385    vgmnd.p_to_target[3](signal_vci_tgt_d_mtty);
386    vgmnd.p_to_target[4](signal_vci_tgt_d_timer);
387    vgmnd.p_to_target[5](signal_vci_tgt_d_bd);
388    vgmnd.p_to_target[6](signal_vci_tgt_d_fb);
389
390    vgmnc.p_clk(signal_clk);
391    vgmnc.p_resetn(signal_resetn);
392    vgmnc.p_to_initiator[0](signal_vci_ini_c_proc);
393    vgmnc.p_to_initiator[1](signal_vci_ini_c_memc);
394    vgmnc.p_to_target[0](signal_vci_tgt_c_proc);
395    vgmnc.p_to_target[1](signal_vci_tgt_c_memc);
396
397    /*
398     * simulation
399     */
400
401    sc_start(sc_time(0, SC_NS));
402    signal_resetn = false;
403
404    sc_start(sc_time(1, SC_NS));
405    signal_resetn = true;
406
407    if (param.trace_enabled)
408    {
409        if (param.trace_start_cycle > 1)
410            // simulate without output until trace_start_cycle
411            sc_start(sc_time(param.trace_start_cycle, SC_NS));
412
413        // enable debugging output
414        for (size_t n = param.trace_start_cycle ;; n++)
415        {
416            std::cout << "****************** cycle " << std::dec << n
417                << " ************************************************" << std::endl;
418            proc.print_trace();
419            memc.print_trace();
420            signal_vci_ini_d_proc.print_trace("proc_ini_d");
421            signal_vci_tgt_c_proc.print_trace("proc_tgt_c");
422            signal_vci_ini_c_proc.print_trace("proc_ini_c");
423            signal_vci_tgt_d_memc.print_trace("memc_tgt_d");
424            signal_vci_tgt_c_memc.print_trace("memc_tgt_c");
425            signal_vci_ini_c_memc.print_trace("memc_ini_c");
426            if (signal_proc_irq[0].read())
427                std::cout << "---- IRQ ----" << std::endl;
428            sc_start(sc_time(1, SC_NS));
429        }
430    } else
431        sc_start();
432
433    return EXIT_SUCCESS;
434}
435
436int sc_main (int argc, char *argv[])
437{
438    try {
439        return _main(argc, argv);
440    } catch (std::exception &e) {
441        std::cout << e.what() << std::endl;
442    } catch (...) {
443        std::cout << "Unknown exception occurred" << std::endl;
444        throw;
445    }
446    return EXIT_FAILURE;
447}
Note: See TracBrowser for help on using the repository browser.