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: |
25 |
* SUCH DAMAGE. |
* SUCH DAMAGE. |
26 |
* |
* |
27 |
* |
* |
28 |
* $Id: machine_test.c,v 1.13 2006/06/12 10:21:12 debug Exp $ |
* $Id: machine_test.c,v 1.30 2007/02/10 14:38:39 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). |
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" |
45 |
#include "testmachine/dev_ether.h" |
#include "testmachine/dev_ether.h" |
46 |
#include "testmachine/dev_fb.h" |
#include "testmachine/dev_fb.h" |
47 |
#include "testmachine/dev_mp.h" |
#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 |
|
|
55 |
snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%"PRIx64" irq=0", |
snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%"PRIx64" irq=none", |
56 |
(uint64_t) DEV_CONS_ADDRESS); |
(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 |
|
|
60 |
(uint64_t) DEV_MP_ADDRESS); |
(uint64_t) DEV_MP_ADDRESS); |
61 |
device_add(machine, tmpstr); |
device_add(machine, tmpstr); |
62 |
|
|
63 |
dev_fb_init(machine, machine->memory, DEV_FB_ADDRESS, VFB_GENERIC, |
snprintf(tmpstr, sizeof(tmpstr), "fbctrl addr=0x%"PRIx64, |
64 |
640,480, 640,480, 24, "generic"); |
(uint64_t) DEV_FBCTRL_ADDRESS); |
65 |
|
device_add(machine, tmpstr); |
66 |
|
|
67 |
snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64, |
snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64, |
68 |
(uint64_t) DEV_DISK_ADDRESS); |
(uint64_t) DEV_DISK_ADDRESS); |
69 |
device_add(machine, tmpstr); |
device_add(machine, tmpstr); |
70 |
|
|
71 |
snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=0", |
snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=none", |
72 |
(uint64_t) DEV_ETHER_ADDRESS); |
(uint64_t) DEV_ETHER_ADDRESS); |
73 |
device_add(machine, tmpstr); |
device_add(machine, tmpstr); |
74 |
|
|
75 |
|
snprintf(tmpstr, sizeof(tmpstr), "rtc addr=0x%"PRIx64" irq=none", |
76 |
|
(uint64_t) DEV_RTC_ADDRESS); |
77 |
|
device_add(machine, tmpstr); |
78 |
} |
} |
79 |
|
|
80 |
|
|
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 |
|
|
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(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); |
|
|
} |
|
174 |
|
|
175 |
|
machine_entry_add_alias(me, "barearm"); |
|
MACHINE_SETUP(barei960) |
|
|
{ |
|
|
machine->machine_name = "Generic \"bare\" i960 machine"; |
|
|
machine->stable = 1; |
|
176 |
} |
} |
177 |
|
|
178 |
|
|
179 |
MACHINE_SETUP(testi960) |
MACHINE_REGISTER(testarm) |
|
{ |
|
|
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"); |
|
|
} |
|
|
|
|
|
|
|
|
MACHINE_REGISTER(barei960) |
|
|
{ |
|
|
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) |
|
180 |
{ |
{ |
181 |
machine->cpu_name = strdup("IA64"); |
MR_DEFAULT(testarm, "Test-machine for ARM", ARCH_ARM, MACHINE_TESTARM); |
|
} |
|
|
|
|
182 |
|
|
183 |
MACHINE_DEFAULT_CPU(testia64) |
machine_entry_add_alias(me, "testarm"); |
|
{ |
|
|
machine->cpu_name = strdup("IA64"); |
|
184 |
} |
} |
185 |
|
|
186 |
|
|
|
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); |
|
|
} |
|
|
|
|
|
|
|
|
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 |
{ |
{ |
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 |
|
|
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%"PRIx64" irq=2", |
snprintf(tmpstr, sizeof(tmpstr), "cons addr=0x%"PRIx64" irq=%s." |
268 |
(uint64_t) 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%"PRIx64, |
snprintf(tmpstr, sizeof(tmpstr), "mp irq=6 addr=0x%"PRIx64, |
273 |
(uint64_t) DEV_MP_ADDRESS); |
(uint64_t) DEV_MP_ADDRESS); |
274 |
device_add(machine, tmpstr); |
device_add(machine, tmpstr); |
275 |
|
|
276 |
dev_fb_init(machine, machine->memory, DEV_FB_ADDRESS, VFB_GENERIC, |
snprintf(tmpstr, sizeof(tmpstr), "fbctrl addr=0x%"PRIx64, |
277 |
640,480, 640,480, 24, "testmips generic"); |
(uint64_t) DEV_FBCTRL_ADDRESS); |
278 |
|
device_add(machine, tmpstr); |
279 |
|
|
280 |
snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64, |
snprintf(tmpstr, sizeof(tmpstr), "disk addr=0x%"PRIx64, |
281 |
(uint64_t) DEV_DISK_ADDRESS); |
(uint64_t) DEV_DISK_ADDRESS); |
282 |
device_add(machine, tmpstr); |
device_add(machine, tmpstr); |
283 |
|
|
284 |
snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=3", |
snprintf(tmpstr, sizeof(tmpstr), "ether addr=0x%"PRIx64" irq=%s." |
285 |
(uint64_t) DEV_ETHER_ADDRESS); |
"cpu[%i].3", (uint64_t) DEV_ETHER_ADDRESS, machine->path, |
286 |
|
machine->bootstrap_cpu); |
287 |
|
device_add(machine, tmpstr); |
288 |
|
|
289 |
|
snprintf(tmpstr, sizeof(tmpstr), "rtc addr=0x%"PRIx64" irq=%s." |
290 |
|
"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("5Kc"); |
machine->cpu_name = strdup("5KE"); |
299 |
} |
} |
300 |
|
|
301 |
|
|
302 |
MACHINE_DEFAULT_CPU(testmips) |
MACHINE_DEFAULT_CPU(testmips) |
303 |
{ |
{ |
304 |
machine->cpu_name = strdup("5Kc"); |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
468 |
|
MACHINE_SETUP(baretransputer) |
469 |
|
{ |
470 |
|
machine->machine_name = "Generic \"bare\" Transputer machine"; |
471 |
|
machine->stable = 1; |
472 |
|
} |
473 |
|
|
474 |
|
|
475 |
|
MACHINE_DEFAULT_CPU(baretransputer) |
476 |
|
{ |
477 |
|
machine->cpu_name = strdup("T800"); |
478 |
|
} |
479 |
|
|
480 |
|
|
481 |
|
MACHINE_REGISTER(baretransputer) |
482 |
|
{ |
483 |
|
MR_DEFAULT(baretransputer, "Generic \"bare\" Transputer machine", |
484 |
|
ARCH_TRANSPUTER, MACHINE_BARETRANSPUTER); |
485 |
|
|
486 |
|
machine_entry_add_alias(me, "baretransputer"); |
487 |
} |
} |
488 |
|
|