/[gxemul]/trunk/src/machines/machine_test.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/machines/machine_test.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 22 by dpavlin, Mon Oct 8 16:19:37 2007 UTC revision 38 by dpavlin, Mon Oct 8 16:21:53 2007 UTC
# Line 1  Line 1 
1  /*  /*
2   *  Copyright (C) 2005-2006  Anders Gavare.  All rights reserved.   *  Copyright (C) 2005-2007  Anders Gavare.  All rights reserved.
3   *   *
4   *  Redistribution and use in source and binary forms, with or without   *  Redistribution and use in source and binary forms, with or without
5   *  modification, are permitted provided that the following conditions are met:   *  modification, are permitted provided that the following conditions are met:
# Line 25  Line 25 
25   *  SUCH DAMAGE.   *  SUCH DAMAGE.
26   *     *  
27   *   *
28   *  $Id: machine_test.c,v 1.1 2006/01/01 20:41:25 debug Exp $   *  $Id: machine_test.c,v 1.31 2007/04/10 17:26:20 debug Exp $
29   *   *
30   *  Various "test" machines (bare machines with just a CPU, or a bare machine   *  Various "test" machines (bare machines with just a CPU, or a bare machine
31   *  plus some experimental devices).   *  plus some experimental devices).
# Line 36  Line 36 
36    
37  #include "cpu.h"  #include "cpu.h"
38  #include "device.h"  #include "device.h"
 #include "devices.h"  
39  #include "machine.h"  #include "machine.h"
40  #include "memory.h"  #include "memory.h"
41  #include "misc.h"  #include "misc.h"
42  #include "mp.h"  
43    #include "testmachine/dev_cons.h"
44    #include "testmachine/dev_disk.h"
45    #include "testmachine/dev_ether.h"
46    #include "testmachine/dev_fb.h"
47    #include "testmachine/dev_mp.h"
48    #include "testmachine/dev_rtc.h"
49    
50    
51  static void default_test(struct machine *machine, struct cpu *cpu)  static void default_test(struct machine *machine, struct cpu *cpu)
52  {  {
53          char tmpstr[1000];          char tmpstr[1000];
54          snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=0",  
55              (long long)DEV_CONS_ADDRESS);          snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%"PRIx64" irq=none",
56                (uint64_t) DEV_CONS_ADDRESS);
57          machine->main_console_handle = (size_t)device_add(machine, tmpstr);          machine->main_console_handle = (size_t)device_add(machine, tmpstr);
58    
59          snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",          snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%"PRIx64,
60              (long long)DEV_MP_ADDRESS);              (uint64_t) DEV_MP_ADDRESS);
61            device_add(machine, tmpstr);
62    
63            snprintf(tmpstr, sizeof(tmpstr), "fbctrl addr=0x%"PRIx64,
64                (uint64_t) DEV_FBCTRL_ADDRESS);
65          device_add(machine, tmpstr);          device_add(machine, tmpstr);
66    
67          dev_fb_init(machine, machine->memory, DEV_FB_ADDRESS, VFB_GENERIC,          snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64,
68              640,480, 640,480, 24, "testalpha generic");              (uint64_t) DEV_DISK_ADDRESS);
69            device_add(machine, tmpstr);
70    
71          snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",          snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=none",
72              (long long)DEV_DISK_ADDRESS);              (uint64_t) DEV_ETHER_ADDRESS);
73          device_add(machine, tmpstr);          device_add(machine, tmpstr);
74    
75          snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=0",          snprintf(tmpstr, sizeof(tmpstr), "rtc addr=0x%"PRIx64" irq=none",
76              (long long)DEV_ETHER_ADDRESS);              (uint64_t) DEV_RTC_ADDRESS);
77          device_add(machine, tmpstr);          device_add(machine, tmpstr);
78  }  }
79    
# Line 87  MACHINE_SETUP(testalpha) Line 98  MACHINE_SETUP(testalpha)
98    
99  MACHINE_DEFAULT_CPU(barealpha)  MACHINE_DEFAULT_CPU(barealpha)
100  {  {
101          machine->cpu_name = strdup("Alpha");          machine->cpu_name = strdup("21264");
102  }  }
103    
104    
105  MACHINE_DEFAULT_CPU(testalpha)  MACHINE_DEFAULT_CPU(testalpha)
106  {  {
107          machine->cpu_name = strdup("Alpha");          machine->cpu_name = strdup("21264");
108  }  }
109    
110    
111  MACHINE_REGISTER(barealpha)  MACHINE_REGISTER(barealpha)
112  {  {
113          MR_DEFAULT(barealpha, "Generic \"bare\" Alpha machine",          MR_DEFAULT(barealpha, "Generic \"bare\" Alpha machine",
114              ARCH_ALPHA, MACHINE_BAREALPHA, 1, 0);              ARCH_ALPHA, MACHINE_BAREALPHA);
115          me->aliases[0] = "barealpha";  
116          machine_entry_add(me, ARCH_ALPHA);          machine_entry_add_alias(me, "barealpha");
117  }  }
118    
119    
120  MACHINE_REGISTER(testalpha)  MACHINE_REGISTER(testalpha)
121  {  {
122          MR_DEFAULT(testalpha, "Test-machine for Alpha",          MR_DEFAULT(testalpha, "Test-machine for Alpha",
123              ARCH_ALPHA, MACHINE_TESTALPHA, 1, 0);              ARCH_ALPHA, MACHINE_TESTALPHA);
124          me->aliases[0] = "testalpha";  
125          machine_entry_add(me, ARCH_ALPHA);          machine_entry_add_alias(me, "testalpha");
126  }  }
127    
128    
# Line 159  MACHINE_DEFAULT_CPU(testarm) Line 170  MACHINE_DEFAULT_CPU(testarm)
170  MACHINE_REGISTER(barearm)  MACHINE_REGISTER(barearm)
171  {  {
172          MR_DEFAULT(barearm, "Generic \"bare\" ARM machine",          MR_DEFAULT(barearm, "Generic \"bare\" ARM machine",
173              ARCH_ARM, MACHINE_BAREARM, 1, 0);              ARCH_ARM, MACHINE_BAREARM);
         me->aliases[0] = "barearm";  
         machine_entry_add(me, ARCH_ARM);  
 }  
   
   
 MACHINE_REGISTER(testarm)  
 {  
         MR_DEFAULT(testarm, "Test-machine for ARM",  
             ARCH_ARM, MACHINE_TESTARM, 1, 0);  
         me->aliases[0] = "testarm";  
         machine_entry_add(me, ARCH_ARM);  
 }  
   
   
   
 MACHINE_SETUP(bareavr)  
 {  
         machine->machine_name = "Generic \"bare\" AVR machine";  
         machine->stable = 1;  
 }  
   
   
 MACHINE_DEFAULT_CPU(bareavr)  
 {  
         machine->cpu_name = strdup("AVR");  
 }  
   
   
 MACHINE_REGISTER(bareavr)  
 {  
         MR_DEFAULT(bareavr, "Generic \"bare\" AVR machine",  
             ARCH_AVR, MACHINE_BAREAVR, 1, 0);  
         me->aliases[0] = "bareavr";  
         machine_entry_add(me, ARCH_AVR);  
 }  
   
   
 MACHINE_SETUP(barehppa)  
 {  
         machine->machine_name = "Generic \"bare\" HPPA machine";  
         machine->stable = 1;  
 }  
   
   
 MACHINE_SETUP(testhppa)  
 {  
         machine->machine_name = "HPPA test machine";  
         machine->stable = 1;  
   
         /*  TODO: interrupt for HPPA?  */  
   
         default_test(machine, cpu);  
 }  
   
   
 MACHINE_DEFAULT_CPU(barehppa)  
 {  
         machine->cpu_name = strdup("HPPA");  
 }  
   
   
 MACHINE_DEFAULT_CPU(testhppa)  
 {  
         machine->cpu_name = strdup("HPPA");  
 }  
   
   
 MACHINE_REGISTER(barehppa)  
 {  
         MR_DEFAULT(barehppa, "Generic \"bare\" HPPA machine",  
             ARCH_HPPA, MACHINE_BAREHPPA, 1, 0);  
         me->aliases[0] = "barehppa";  
         machine_entry_add(me, ARCH_HPPA);  
 }  
   
   
 MACHINE_REGISTER(testhppa)  
 {  
         MR_DEFAULT(testhppa, "Test-machine for HPPA",  
             ARCH_HPPA, MACHINE_TESTHPPA, 1, 0);  
         me->aliases[0] = "testhppa";  
         machine_entry_add(me, ARCH_HPPA);  
 }  
   
   
 MACHINE_SETUP(barei960)  
 {  
         machine->machine_name = "Generic \"bare\" i960 machine";  
         machine->stable = 1;  
 }  
174    
175            machine_entry_add_alias(me, "barearm");
 MACHINE_SETUP(testi960)  
 {  
         machine->machine_name = "i960 test machine";  
         machine->stable = 1;  
   
         /*  TODO: interrupt for i960?  */  
   
         default_test(machine, cpu);  
 }  
   
   
 MACHINE_DEFAULT_CPU(barei960)  
 {  
         machine->cpu_name = strdup("i960");  
 }  
   
   
 MACHINE_DEFAULT_CPU(testi960)  
 {  
         machine->cpu_name = strdup("i960");  
176  }  }
177    
178    
179  MACHINE_REGISTER(barei960)  MACHINE_REGISTER(testarm)
 {  
         MR_DEFAULT(barei960, "Generic \"bare\" i960 machine",  
             ARCH_I960, MACHINE_BAREI960, 1, 0);  
         me->aliases[0] = "barei960";  
         machine_entry_add(me, ARCH_I960);  
 }  
   
   
 MACHINE_REGISTER(testi960)  
 {  
         MR_DEFAULT(testi960, "Test-machine for i960",  
             ARCH_I960, MACHINE_TESTI960, 1, 0);  
         me->aliases[0] = "testi960";  
         machine_entry_add(me, ARCH_I960);  
 }  
   
   
 MACHINE_SETUP(bareia64)  
 {  
         machine->machine_name = "Generic \"bare\" IA64 machine";  
         machine->stable = 1;  
 }  
   
   
 MACHINE_SETUP(testia64)  
 {  
         machine->machine_name = "IA64 test machine";  
         machine->stable = 1;  
   
         /*  TODO: interrupt for IA64?  */  
   
         default_test(machine, cpu);  
 }  
   
   
 MACHINE_DEFAULT_CPU(bareia64)  
 {  
         machine->cpu_name = strdup("IA64");  
 }  
   
   
 MACHINE_DEFAULT_CPU(testia64)  
180  {  {
181          machine->cpu_name = strdup("IA64");          MR_DEFAULT(testarm, "Test-machine for ARM", ARCH_ARM, MACHINE_TESTARM);
 }  
182    
183            machine_entry_add_alias(me, "testarm");
 MACHINE_REGISTER(bareia64)  
 {  
         MR_DEFAULT(bareia64, "Generic \"bare\" IA64 machine",  
             ARCH_IA64, MACHINE_BAREIA64, 1, 0);  
         me->aliases[0] = "bareia64";  
         machine_entry_add(me, ARCH_IA64);  
184  }  }
185    
186    
 MACHINE_REGISTER(testia64)  
 {  
         MR_DEFAULT(testia64, "Test-machine for IA64",  
             ARCH_IA64, MACHINE_TESTIA64, 1, 0);  
         me->aliases[0] = "testia64";  
         machine_entry_add(me, ARCH_IA64);  
 }  
   
187    
188  MACHINE_SETUP(barem68k)  MACHINE_SETUP(barem68k)
189  {  {
# Line 374  MACHINE_DEFAULT_CPU(testm68k) Line 218  MACHINE_DEFAULT_CPU(testm68k)
218  MACHINE_REGISTER(barem68k)  MACHINE_REGISTER(barem68k)
219  {  {
220          MR_DEFAULT(barem68k, "Generic \"bare\" M68K machine",          MR_DEFAULT(barem68k, "Generic \"bare\" M68K machine",
221              ARCH_M68K, MACHINE_BAREM68K, 1, 0);              ARCH_M68K, MACHINE_BAREM68K);
222          me->aliases[0] = "barem68k";  
223          machine_entry_add(me, ARCH_M68K);          machine_entry_add_alias(me, "barem68k");
224  }  }
225    
226    
227  MACHINE_REGISTER(testm68k)  MACHINE_REGISTER(testm68k)
228  {  {
229          MR_DEFAULT(testm68k, "Test-machine for M68K",          MR_DEFAULT(testm68k, "Test-machine for M68K",
230              ARCH_M68K, MACHINE_TESTM68K, 1, 0);              ARCH_M68K, MACHINE_TESTM68K);
231          me->aliases[0] = "testm68k";  
232          machine_entry_add(me, ARCH_M68K);          machine_entry_add_alias(me, "testm68k");
233  }  }
234    
235    
# Line 400  MACHINE_SETUP(baremips) Line 244  MACHINE_SETUP(baremips)
244  MACHINE_SETUP(testmips)  MACHINE_SETUP(testmips)
245  {  {
246          /*          /*
247           *  A MIPS test machine (which happens to work with the           *  A MIPS test machine. Originally, this was created as a way for
248           *  code in my master's thesis).  :-)           *  me to test my master's thesis code; since then it has both
249             *  evolved to support new things, and suffered bit rot so that it
250             *  no longer can run my thesis code. Well, well...
251           *           *
252           *  IRQ map:           *  IRQ map:
253           *      7       CPU counter           *      7       CPU counter
254           *      6       SMP IPIs           *      6       SMP IPIs
255           *      5       not used yet           *      5       not used yet
256           *      4       not used yet           *      4       rtc
257           *      3       ethernet             *      3       ethernet  
258           *      2       serial console           *      2       serial console
259           */           */
260    
261          char tmpstr[1000];          char tmpstr[300];
262    
263          machine->machine_name = "MIPS test machine";          machine->machine_name = "MIPS test machine";
264          machine->stable = 1;          machine->stable = 1;
265          cpu->byte_order = EMUL_BIG_ENDIAN;          cpu->byte_order = EMUL_BIG_ENDIAN;
266    
267          snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%llx irq=2",          snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%"PRIx64" irq=%s."
268              (long long)DEV_CONS_ADDRESS);              "cpu[%i].2", (uint64_t) DEV_CONS_ADDRESS, machine->path,
269                machine->bootstrap_cpu);
270          machine->main_console_handle = (size_t)device_add(machine, tmpstr);          machine->main_console_handle = (size_t)device_add(machine, tmpstr);
271    
272          snprintf(tmpstr, sizeof(tmpstr), "mp addr=0x%llx",          snprintf(tmpstr, sizeof(tmpstr), "mp irq=6 addr=0x%"PRIx64,
273              (long long)DEV_MP_ADDRESS);              (uint64_t) DEV_MP_ADDRESS);
274            device_add(machine, tmpstr);
275    
276            snprintf(tmpstr, sizeof(tmpstr), "fbctrl addr=0x%"PRIx64,
277                (uint64_t) DEV_FBCTRL_ADDRESS);
278          device_add(machine, tmpstr);          device_add(machine, tmpstr);
279    
280          dev_fb_init(machine, machine->memory, DEV_FB_ADDRESS, VFB_GENERIC,          snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64,
281              640,480, 640,480, 24, "testmips generic");              (uint64_t) DEV_DISK_ADDRESS);
282            device_add(machine, tmpstr);
283    
284          snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%llx",          snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=%s."
285              (long long)DEV_DISK_ADDRESS);              "cpu[%i].3", (uint64_t) DEV_ETHER_ADDRESS, machine->path,
286                machine->bootstrap_cpu);
287          device_add(machine, tmpstr);          device_add(machine, tmpstr);
288    
289          snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%llx irq=3",          snprintf(tmpstr, sizeof(tmpstr), "rtc addr=0x%"PRIx64" irq=%s."
290              (long long)DEV_ETHER_ADDRESS);              "cpu[%i].4", (uint64_t) DEV_RTC_ADDRESS, machine->path,
291                machine->bootstrap_cpu);
292          device_add(machine, tmpstr);          device_add(machine, tmpstr);
293  }  }
294    
295    
296  MACHINE_DEFAULT_CPU(baremips)  MACHINE_DEFAULT_CPU(baremips)
297  {  {
298          machine->cpu_name = strdup("R4000");          machine->cpu_name = strdup("5KE");
299  }  }
300    
301    
302  MACHINE_DEFAULT_CPU(testmips)  MACHINE_DEFAULT_CPU(testmips)
303  {  {
304          machine->cpu_name = strdup("R4000");          machine->cpu_name = strdup("5KE");
305  }  }
306    
307    
308  MACHINE_REGISTER(baremips)  MACHINE_REGISTER(baremips)
309  {  {
310          MR_DEFAULT(baremips, "Generic \"bare\" MIPS machine",          MR_DEFAULT(baremips, "Generic \"bare\" MIPS machine",
311              ARCH_MIPS, MACHINE_BAREMIPS, 1, 0);              ARCH_MIPS, MACHINE_BAREMIPS);
312          me->aliases[0] = "baremips";  
313          machine_entry_add(me, ARCH_MIPS);          machine_entry_add_alias(me, "baremips");
314  }  }
315    
316    
317  MACHINE_REGISTER(testmips)  MACHINE_REGISTER(testmips)
318  {  {
319          MR_DEFAULT(testmips, "Test-machine for MIPS",          MR_DEFAULT(testmips, "Test-machine for MIPS",
320              ARCH_MIPS, MACHINE_TESTMIPS, 1, 0);              ARCH_MIPS, MACHINE_TESTMIPS);
321          me->aliases[0] = "testmips";  
322          machine_entry_add(me, ARCH_MIPS);          machine_entry_add_alias(me, "testmips");
323  }  }
324    
325    
# Line 502  MACHINE_DEFAULT_CPU(testppc) Line 356  MACHINE_DEFAULT_CPU(testppc)
356  MACHINE_REGISTER(bareppc)  MACHINE_REGISTER(bareppc)
357  {  {
358          MR_DEFAULT(bareppc, "Generic \"bare\" PPC machine",          MR_DEFAULT(bareppc, "Generic \"bare\" PPC machine",
359              ARCH_PPC, MACHINE_BAREPPC, 1, 0);              ARCH_PPC, MACHINE_BAREPPC);
360          me->aliases[0] = "bareppc";  
361          machine_entry_add(me, ARCH_PPC);          machine_entry_add_alias(me, "bareppc");
362  }  }
363    
364    
365  MACHINE_REGISTER(testppc)  MACHINE_REGISTER(testppc)
366  {  {
367          MR_DEFAULT(testppc, "Test-machine for PPC",          MR_DEFAULT(testppc, "Test-machine for PPC", ARCH_PPC, MACHINE_TESTPPC);
368              ARCH_PPC, MACHINE_TESTPPC, 1, 0);  
369          me->aliases[0] = "testppc";          machine_entry_add_alias(me, "testppc");
         machine_entry_add(me, ARCH_PPC);  
370  }  }
371    
372    
# Line 537  MACHINE_SETUP(testsh) Line 390  MACHINE_SETUP(testsh)
390    
391  MACHINE_DEFAULT_CPU(baresh)  MACHINE_DEFAULT_CPU(baresh)
392  {  {
393          machine->cpu_name = strdup("SH");          machine->cpu_name = strdup("SH7750");
394  }  }
395    
396    
397  MACHINE_DEFAULT_CPU(testsh)  MACHINE_DEFAULT_CPU(testsh)
398  {  {
399          machine->cpu_name = strdup("SH");          machine->cpu_name = strdup("SH7750");
400  }  }
401    
402    
403  MACHINE_REGISTER(baresh)  MACHINE_REGISTER(baresh)
404  {  {
405          MR_DEFAULT(baresh, "Generic \"bare\" SH machine",          MR_DEFAULT(baresh, "Generic \"bare\" SH machine",
406              ARCH_SH, MACHINE_BARESH, 1, 0);              ARCH_SH, MACHINE_BARESH);
407          me->aliases[0] = "baresh";  
408          machine_entry_add(me, ARCH_SH);          machine_entry_add_alias(me, "baresh");
409  }  }
410    
411    
412  MACHINE_REGISTER(testsh)  MACHINE_REGISTER(testsh)
413  {  {
414          MR_DEFAULT(testsh, "Test-machine for SH",          MR_DEFAULT(testsh, "Test-machine for SH", ARCH_SH, MACHINE_TESTSH);
415              ARCH_SH, MACHINE_TESTSH, 1, 0);  
416          me->aliases[0] = "testsh";          machine_entry_add_alias(me, "testsh");
         machine_entry_add(me, ARCH_SH);  
417  }  }
418    
419    
# Line 585  MACHINE_SETUP(testsparc) Line 437  MACHINE_SETUP(testsparc)
437    
438  MACHINE_DEFAULT_CPU(baresparc)  MACHINE_DEFAULT_CPU(baresparc)
439  {  {
440          machine->cpu_name = strdup("SPARCv9");          machine->cpu_name = strdup("UltraSPARC");
441  }  }
442    
443    
444  MACHINE_DEFAULT_CPU(testsparc)  MACHINE_DEFAULT_CPU(testsparc)
445  {  {
446          machine->cpu_name = strdup("SPARCv9");          machine->cpu_name = strdup("UltraSPARC");
447  }  }
448    
449    
450  MACHINE_REGISTER(baresparc)  MACHINE_REGISTER(baresparc)
451  {  {
452          MR_DEFAULT(baresparc, "Generic \"bare\" SPARC machine",          MR_DEFAULT(baresparc, "Generic \"bare\" SPARC machine",
453              ARCH_SPARC, MACHINE_BARESPARC, 1, 0);              ARCH_SPARC, MACHINE_BARESPARC);
454          me->aliases[0] = "baresparc";  
455          machine_entry_add(me, ARCH_SPARC);          machine_entry_add_alias(me, "baresparc");
456  }  }
457    
458    
459  MACHINE_REGISTER(testsparc)  MACHINE_REGISTER(testsparc)
460  {  {
461          MR_DEFAULT(testsparc, "Test-machine for SPARC",          MR_DEFAULT(testsparc, "Test-machine for SPARC",
462              ARCH_SPARC, MACHINE_TESTSPARC, 1, 0);              ARCH_SPARC, MACHINE_TESTSPARC);
463          me->aliases[0] = "testsparc";  
464          machine_entry_add(me, ARCH_SPARC);          machine_entry_add_alias(me, "testsparc");
465  }  }
466    
467    
Legend:
Removed from v.22  
changed lines
  Added in v.38
  ViewVC Help
Powered by ViewVC 1.1.26