summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/z8000/z8000.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/cpu/z8000/z8000.c')
-rw-r--r--src/emu/cpu/z8000/z8000.c828
1 files changed, 414 insertions, 414 deletions
diff --git a/src/emu/cpu/z8000/z8000.c b/src/emu/cpu/z8000/z8000.c
index 725b6b03f81..51814ab745a 100644
--- a/src/emu/cpu/z8000/z8000.c
+++ b/src/emu/cpu/z8000/z8000.c
@@ -54,34 +54,34 @@
#define VERBOSE 0
-#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
+#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
union z8000_reg_file
{
- UINT8 B[16]; /* RL0,RH0,RL1,RH1...RL7,RH7 */
- UINT16 W[16]; /* R0,R1,R2...R15 */
- UINT32 L[8]; /* RR0,RR2,RR4..RR14 */
- UINT64 Q[4]; /* RQ0,RQ4,..RQ12 */
+ UINT8 B[16]; /* RL0,RH0,RL1,RH1...RL7,RH7 */
+ UINT16 W[16]; /* R0,R1,R2...R15 */
+ UINT32 L[8]; /* RR0,RR2,RR4..RR14 */
+ UINT64 Q[4]; /* RQ0,RQ4,..RQ12 */
};
struct z8000_state
{
- UINT32 op[4]; /* opcodes/data of current instruction */
- UINT32 ppc; /* previous program counter */
- UINT32 pc; /* program counter */
- UINT16 psapseg; /* program status pointer, segment (Z8001 only) */
- UINT16 psapoff; /* program status pointer, offset */
- UINT16 fcw; /* flags and control word */
- UINT16 refresh; /* refresh timer/counter */
- UINT16 nspseg; /* system stack pointer, segment (Z8001 only) */
- UINT16 nspoff; /* system stack pointer, offset */
- UINT16 irq_req; /* CPU is halted, interrupt or trap request */
- UINT16 irq_srv; /* serviced interrupt request */
- UINT16 irq_vec; /* interrupt vector */
- unsigned int op_valid; /* bit field indicating if given op[] field is already initialized */
- z8000_reg_file regs;/* registers */
- int nmi_state; /* NMI line state */
- int irq_state[2]; /* IRQ line states (NVI, VI) */
+ UINT32 op[4]; /* opcodes/data of current instruction */
+ UINT32 ppc; /* previous program counter */
+ UINT32 pc; /* program counter */
+ UINT16 psapseg; /* program status pointer, segment (Z8001 only) */
+ UINT16 psapoff; /* program status pointer, offset */
+ UINT16 fcw; /* flags and control word */
+ UINT16 refresh; /* refresh timer/counter */
+ UINT16 nspseg; /* system stack pointer, segment (Z8001 only) */
+ UINT16 nspoff; /* system stack pointer, offset */
+ UINT16 irq_req; /* CPU is halted, interrupt or trap request */
+ UINT16 irq_srv; /* serviced interrupt request */
+ UINT16 irq_vec; /* interrupt vector */
+ unsigned int op_valid; /* bit field indicating if given op[] field is already initialized */
+ z8000_reg_file regs;/* registers */
+ int nmi_state; /* NMI line state */
+ int irq_state[2]; /* IRQ line states (NVI, VI) */
device_irq_acknowledge_callback irq_callback;
legacy_cpu_device *device;
address_space *program;
@@ -129,83 +129,83 @@ INLINE UINT32 addr_sub(z8000_state *cpustate, UINT32 addr, UINT32 subtrahend)
INLINE UINT16 RDOP(z8000_state *cpustate)
{
UINT16 res = cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- return res;
+ cpustate->pc += 2;
+ return res;
}
INLINE UINT32 get_operand (z8000_state *cpustate, int opnum)
{
- int i;
- assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
+ int i;
+ assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
- for (i = 0; i < opnum; i++)
- assert (cpustate->op_valid & (1 << i));
+ for (i = 0; i < opnum; i++)
+ assert (cpustate->op_valid & (1 << i));
- if (! (cpustate->op_valid & (1 << opnum)))
- {
- cpustate->op[opnum] = cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- cpustate->op_valid |= (1 << opnum);
- }
- return cpustate->op[opnum];
+ if (! (cpustate->op_valid & (1 << opnum)))
+ {
+ cpustate->op[opnum] = cpustate->program->read_word(cpustate->pc);
+ cpustate->pc += 2;
+ cpustate->op_valid |= (1 << opnum);
+ }
+ return cpustate->op[opnum];
}
INLINE UINT32 get_addr_operand (z8000_state *cpustate, int opnum)
{
- int i;
- assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
-
- for (i = 0; i < opnum; i++)
- assert (cpustate->op_valid & (1 << i));
-
- if (! (cpustate->op_valid & (1 << opnum)))
- {
- UINT32 seg = cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- if (segmented_mode(cpustate))
- {
- if (seg & 0x8000)
- {
- cpustate->op[opnum] = ((seg & 0x7f00) << 8) | cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- }
- else
- cpustate->op[opnum] = ((seg & 0x7f00) << 8) | (seg & 0xff);
- }
- else
- cpustate->op[opnum] = seg;
- cpustate->op_valid |= (1 << opnum);
- }
- return cpustate->op[opnum];
+ int i;
+ assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
+
+ for (i = 0; i < opnum; i++)
+ assert (cpustate->op_valid & (1 << i));
+
+ if (! (cpustate->op_valid & (1 << opnum)))
+ {
+ UINT32 seg = cpustate->program->read_word(cpustate->pc);
+ cpustate->pc += 2;
+ if (segmented_mode(cpustate))
+ {
+ if (seg & 0x8000)
+ {
+ cpustate->op[opnum] = ((seg & 0x7f00) << 8) | cpustate->program->read_word(cpustate->pc);
+ cpustate->pc += 2;
+ }
+ else
+ cpustate->op[opnum] = ((seg & 0x7f00) << 8) | (seg & 0xff);
+ }
+ else
+ cpustate->op[opnum] = seg;
+ cpustate->op_valid |= (1 << opnum);
+ }
+ return cpustate->op[opnum];
}
INLINE UINT32 get_raw_addr_operand (z8000_state *cpustate, int opnum)
{
- int i;
- assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
-
- for (i = 0; i < opnum; i++)
- assert (cpustate->op_valid & (1 << i));
-
- if (! (cpustate->op_valid & (1 << opnum)))
- {
- UINT32 seg = cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- if (segmented_mode(cpustate))
- {
- if (seg & 0x8000)
- {
- cpustate->op[opnum] = (seg << 16) | cpustate->program->read_word(cpustate->pc);
- cpustate->pc += 2;
- }
- else
- cpustate->op[opnum] = (seg << 16) | (seg & 0xff);
- }
- else
- cpustate->op[opnum] = seg;
- cpustate->op_valid |= (1 << opnum);
- }
- return cpustate->op[opnum];
+ int i;
+ assert (cpustate->device->type() == Z8001 || cpustate->device->type() == Z8002);
+
+ for (i = 0; i < opnum; i++)
+ assert (cpustate->op_valid & (1 << i));
+
+ if (! (cpustate->op_valid & (1 << opnum)))
+ {
+ UINT32 seg = cpustate->program->read_word(cpustate->pc);
+ cpustate->pc += 2;
+ if (segmented_mode(cpustate))
+ {
+ if (seg & 0x8000)
+ {
+ cpustate->op[opnum] = (seg << 16) | cpustate->program->read_word(cpustate->pc);
+ cpustate->pc += 2;
+ }
+ else
+ cpustate->op[opnum] = (seg << 16) | (seg & 0xff);
+ }
+ else
+ cpustate->op[opnum] = seg;
+ cpustate->op_valid |= (1 << opnum);
+ }
+ return cpustate->op[opnum];
}
INLINE UINT32 adjust_addr_for_nonseg_mode(z8000_state *cpustate, UINT32 addr)
@@ -230,11 +230,11 @@ INLINE UINT16 RDMEM_W(z8000_state *cpustate, address_spacenum spacenum, UINT32 a
{
addr = adjust_addr_for_nonseg_mode(cpustate, addr);
addr &= ~1;
- /* hack for m20 driver: BIOS accesses 0x7f0000 and expects a segmentation violation */
- if (addr >= 0x7f0000) {
- cpustate->irq_req = Z8000_SEGTRAP;
- return 0xffff;
- }
+ /* hack for m20 driver: BIOS accesses 0x7f0000 and expects a segmentation violation */
+ if (addr >= 0x7f0000) {
+ cpustate->irq_req = Z8000_SEGTRAP;
+ return 0xffff;
+ }
if (spacenum == AS_PROGRAM)
return cpustate->program->read_word(addr);
else
@@ -310,15 +310,15 @@ INLINE UINT16 RDPORT_W(z8000_state *cpustate, int mode, UINT16 addr)
{
if(mode == 0)
{
- if (cpustate->device->type() == Z8001)
- {
- return cpustate->io->read_word((UINT16)addr);
- }
- else
- {
- return cpustate->io->read_byte((UINT16)(addr)) +
- (cpustate->io->read_byte((UINT16)(addr+1)) << 8);
- }
+ if (cpustate->device->type() == Z8001)
+ {
+ return cpustate->io->read_word((UINT16)addr);
+ }
+ else
+ {
+ return cpustate->io->read_byte((UINT16)(addr)) +
+ (cpustate->io->read_byte((UINT16)(addr+1)) << 8);
+ }
}
else
{
@@ -331,32 +331,32 @@ INLINE void WRPORT_B(z8000_state *cpustate, int mode, UINT16 addr, UINT8 value)
{
if(mode == 0)
{
- cpustate->io->write_byte(addr,value);
+ cpustate->io->write_byte(addr,value);
}
else
{
/* how to handle MMU writes? */
- }
+ }
}
INLINE void WRPORT_W(z8000_state *cpustate, int mode, UINT16 addr, UINT16 value)
{
if(mode == 0)
{
- if (cpustate->device->type() == Z8001)
- {
- cpustate->io->write_word((UINT16)addr, value);
- }
- else
- {
- cpustate->io->write_byte((UINT16)(addr),value & 0xff);
- cpustate->io->write_byte((UINT16)(addr+1),(value >> 8) & 0xff);
- }
+ if (cpustate->device->type() == Z8001)
+ {
+ cpustate->io->write_word((UINT16)addr, value);
+ }
+ else
+ {
+ cpustate->io->write_byte((UINT16)(addr),value & 0xff);
+ cpustate->io->write_byte((UINT16)(addr+1),(value >> 8) & 0xff);
+ }
}
else
{
/* how to handle MMU writes? */
- }
+ }
}
INLINE void cycles(z8000_state *cpustate, int cycles)
@@ -369,55 +369,55 @@ INLINE void cycles(z8000_state *cpustate, int cycles)
INLINE void set_irq(z8000_state *cpustate, int type)
{
- switch ((type >> 8) & 255)
- {
- case Z8000_EPU >> 8:
- if (cpustate->irq_srv >= Z8000_EPU)
- return;
- cpustate->irq_req = type;
- break;
- case Z8000_TRAP >> 8:
- if (cpustate->irq_srv >= Z8000_TRAP)
- return; /* double TRAP.. very bad :( */
- cpustate->irq_req = type;
- break;
- case Z8000_NMI >> 8:
- if (cpustate->irq_srv >= Z8000_NMI)
- return; /* no NMIs inside trap */
- cpustate->irq_req = type;
- break;
- case Z8000_SEGTRAP >> 8:
- if (cpustate->irq_srv >= Z8000_SEGTRAP)
- return; /* no SEGTRAPs inside NMI/TRAP */
- cpustate->irq_req = type;
- break;
- case Z8000_NVI >> 8:
- if (cpustate->irq_srv >= Z8000_NVI)
- return; /* no NVIs inside SEGTRAP/NMI/TRAP */
- cpustate->irq_req = type;
- break;
- case Z8000_VI >> 8:
- if (cpustate->irq_srv >= Z8000_VI)
- return; /* no VIs inside NVI/SEGTRAP/NMI/TRAP */
- cpustate->irq_req = type;
- break;
- case Z8000_SYSCALL >> 8:
- LOG(("Z8K '%s' SYSCALL $%02x\n", cpustate->device->tag(), type & 0xff));
- cpustate->irq_req = type;
- break;
- default:
- logerror("Z8000 invalid Cause_Interrupt %04x\n", type);
- return;
- }
- /* set interrupt request flag, reset HALT flag */
- cpustate->irq_req = type & ~Z8000_HALT;
+ switch ((type >> 8) & 255)
+ {
+ case Z8000_EPU >> 8:
+ if (cpustate->irq_srv >= Z8000_EPU)
+ return;
+ cpustate->irq_req = type;
+ break;
+ case Z8000_TRAP >> 8:
+ if (cpustate->irq_srv >= Z8000_TRAP)
+ return; /* double TRAP.. very bad :( */
+ cpustate->irq_req = type;
+ break;
+ case Z8000_NMI >> 8:
+ if (cpustate->irq_srv >= Z8000_NMI)
+ return; /* no NMIs inside trap */
+ cpustate->irq_req = type;
+ break;
+ case Z8000_SEGTRAP >> 8:
+ if (cpustate->irq_srv >= Z8000_SEGTRAP)
+ return; /* no SEGTRAPs inside NMI/TRAP */
+ cpustate->irq_req = type;
+ break;
+ case Z8000_NVI >> 8:
+ if (cpustate->irq_srv >= Z8000_NVI)
+ return; /* no NVIs inside SEGTRAP/NMI/TRAP */
+ cpustate->irq_req = type;
+ break;
+ case Z8000_VI >> 8:
+ if (cpustate->irq_srv >= Z8000_VI)
+ return; /* no VIs inside NVI/SEGTRAP/NMI/TRAP */
+ cpustate->irq_req = type;
+ break;
+ case Z8000_SYSCALL >> 8:
+ LOG(("Z8K '%s' SYSCALL $%02x\n", cpustate->device->tag(), type & 0xff));
+ cpustate->irq_req = type;
+ break;
+ default:
+ logerror("Z8000 invalid Cause_Interrupt %04x\n", type);
+ return;
+ }
+ /* set interrupt request flag, reset HALT flag */
+ cpustate->irq_req = type & ~Z8000_HALT;
}
#define PUSH_PC() do { \
if (cpustate->device->type() == Z8001) \
- PUSHL(cpustate, SP, make_segmented_addr(cpustate->pc)); /* save current cpustate->pc */ \
- else \
- PUSHW(cpustate, SP, cpustate->pc); /* save current cpustate->pc */ \
+ PUSHL(cpustate, SP, make_segmented_addr(cpustate->pc)); /* save current cpustate->pc */ \
+ else \
+ PUSHW(cpustate, SP, cpustate->pc); /* save current cpustate->pc */ \
} while (0)
#define GET_PC(VEC) (cpustate->device->type() == Z8001 ? segmented_addr(RDMEM_L(cpustate, AS_PROGRAM, VEC + 4)) : RDMEM_W(cpustate, AS_PROGRAM, VEC + 2))
@@ -426,116 +426,116 @@ if (cpustate->device->type() == Z8001) \
INLINE void Interrupt(z8000_state *cpustate)
{
- UINT16 fcw = cpustate->fcw;
-
- if (cpustate->irq_req & Z8000_NVI)
- {
- int type = (*cpustate->irq_callback)(cpustate->device, 0);
- set_irq(cpustate, type | Z8000_NVI);
- }
-
- if (cpustate->irq_req & Z8000_VI)
- {
- int type = (*cpustate->irq_callback)(cpustate->device, 1);
- set_irq(cpustate, type | Z8000_VI);
- }
-
- /* trap ? */
- if (cpustate->irq_req & Z8000_EPU)
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->irq_req &= ~Z8000_EPU;
- CHANGE_FCW(cpustate, GET_FCW(EPU));
- cpustate->pc = GET_PC(EPU);
- LOG(("Z8K '%s' ext instr trap $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if (cpustate->irq_req & Z8000_TRAP)
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->irq_req &= ~Z8000_TRAP;
- CHANGE_FCW(cpustate, GET_FCW(TRAP));
- cpustate->pc = GET_PC(TRAP);
- LOG(("Z8K '%s' priv instr trap $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if (cpustate->irq_req & Z8000_SYSCALL)
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->irq_req &= ~Z8000_SYSCALL;
- CHANGE_FCW(cpustate, GET_FCW(SYSCALL));
- cpustate->pc = GET_PC(SYSCALL);
- LOG(("Z8K '%s' syscall $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if (cpustate->irq_req & Z8000_SEGTRAP)
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->irq_req &= ~Z8000_SEGTRAP;
- CHANGE_FCW(cpustate, GET_FCW(SEGTRAP));
- cpustate->pc = GET_PC(SEGTRAP);
- LOG(("Z8K '%s' segtrap $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if (cpustate->irq_req & Z8000_NMI)
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->pc = RDMEM_W(cpustate, AS_PROGRAM, NMI);
- cpustate->irq_req &= ~Z8000_NMI;
- CHANGE_FCW(cpustate, GET_FCW(NMI));
- cpustate->pc = GET_PC(NMI);
- LOG(("Z8K '%s' NMI $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if ((cpustate->irq_req & Z8000_NVI) && (cpustate->fcw & F_NVIE))
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
- cpustate->pc = GET_PC(NVI);
- cpustate->irq_req &= ~Z8000_NVI;
- CHANGE_FCW(cpustate, GET_FCW(NVI));
- LOG(("Z8K '%s' NVI $%04x\n", cpustate->device->tag(), cpustate->pc));
- }
- else
- if ((cpustate->irq_req & Z8000_VI) && (cpustate->fcw & F_VIE))
- {
- CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
- PUSH_PC();
- PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
- PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
- cpustate->irq_srv = cpustate->irq_req;
+ UINT16 fcw = cpustate->fcw;
+
+ if (cpustate->irq_req & Z8000_NVI)
+ {
+ int type = (*cpustate->irq_callback)(cpustate->device, 0);
+ set_irq(cpustate, type | Z8000_NVI);
+ }
+
+ if (cpustate->irq_req & Z8000_VI)
+ {
+ int type = (*cpustate->irq_callback)(cpustate->device, 1);
+ set_irq(cpustate, type | Z8000_VI);
+ }
+
+ /* trap ? */
+ if (cpustate->irq_req & Z8000_EPU)
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->irq_req &= ~Z8000_EPU;
+ CHANGE_FCW(cpustate, GET_FCW(EPU));
+ cpustate->pc = GET_PC(EPU);
+ LOG(("Z8K '%s' ext instr trap $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if (cpustate->irq_req & Z8000_TRAP)
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->irq_req &= ~Z8000_TRAP;
+ CHANGE_FCW(cpustate, GET_FCW(TRAP));
+ cpustate->pc = GET_PC(TRAP);
+ LOG(("Z8K '%s' priv instr trap $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if (cpustate->irq_req & Z8000_SYSCALL)
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->irq_req &= ~Z8000_SYSCALL;
+ CHANGE_FCW(cpustate, GET_FCW(SYSCALL));
+ cpustate->pc = GET_PC(SYSCALL);
+ LOG(("Z8K '%s' syscall $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if (cpustate->irq_req & Z8000_SEGTRAP)
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->irq_req &= ~Z8000_SEGTRAP;
+ CHANGE_FCW(cpustate, GET_FCW(SEGTRAP));
+ cpustate->pc = GET_PC(SEGTRAP);
+ LOG(("Z8K '%s' segtrap $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if (cpustate->irq_req & Z8000_NMI)
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->pc = RDMEM_W(cpustate, AS_PROGRAM, NMI);
+ cpustate->irq_req &= ~Z8000_NMI;
+ CHANGE_FCW(cpustate, GET_FCW(NMI));
+ cpustate->pc = GET_PC(NMI);
+ LOG(("Z8K '%s' NMI $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if ((cpustate->irq_req & Z8000_NVI) && (cpustate->fcw & F_NVIE))
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
+ cpustate->pc = GET_PC(NVI);
+ cpustate->irq_req &= ~Z8000_NVI;
+ CHANGE_FCW(cpustate, GET_FCW(NVI));
+ LOG(("Z8K '%s' NVI $%04x\n", cpustate->device->tag(), cpustate->pc));
+ }
+ else
+ if ((cpustate->irq_req & Z8000_VI) && (cpustate->fcw & F_VIE))
+ {
+ CHANGE_FCW(cpustate, fcw | F_S_N | F_SEG_Z8001);/* switch to segmented (on Z8001) system mode */
+ PUSH_PC();
+ PUSHW(cpustate, SP, fcw); /* save current cpustate->fcw */
+ PUSHW(cpustate, SP, cpustate->irq_req); /* save interrupt/trap type tag */
+ cpustate->irq_srv = cpustate->irq_req;
if (cpustate->device->type() == Z8001)
cpustate->pc = segmented_addr(RDMEM_L(cpustate, AS_PROGRAM, VEC00 + 4 * (cpustate->irq_req & 0xff)));
else
cpustate->pc = RDMEM_W(cpustate, AS_PROGRAM, VEC00 + 2 * (cpustate->irq_req & 0xff));
- cpustate->irq_req &= ~Z8000_VI;
- CHANGE_FCW(cpustate, GET_FCW(VI));
- //printf ("z8k VI (vec 0x%x)\n", cpustate->irq_req & 0xff);
- LOG(("Z8K '%s' VI [$%04x/$%04x] fcw $%04x, pc $%04x\n", cpustate->device->tag(), cpustate->irq_vec, VEC00 + (cpustate->device->type() == Z8001 ? 4 : 2) * (cpustate->irq_req & 0xff), cpustate->fcw, cpustate->pc));
- }
+ cpustate->irq_req &= ~Z8000_VI;
+ CHANGE_FCW(cpustate, GET_FCW(VI));
+ //printf ("z8k VI (vec 0x%x)\n", cpustate->irq_req & 0xff);
+ LOG(("Z8K '%s' VI [$%04x/$%04x] fcw $%04x, pc $%04x\n", cpustate->device->tag(), cpustate->irq_vec, VEC00 + (cpustate->device->type() == Z8001 ? 4 : 2) * (cpustate->irq_req & 0xff), cpustate->fcw, cpustate->pc));
+ }
}
static CPU_INIT( z8001 )
@@ -548,7 +548,7 @@ static CPU_INIT( z8001 )
cpustate->device = device;
cpustate->program = &device->space(AS_PROGRAM);
/* If the system decodes STn lines to distinguish between data and program memory fetches,
- install the data space. If it doesn't, install the program memory into data memory space. */
+ install the data space. If it doesn't, install the program memory into data memory space. */
if (device->has_space(AS_DATA))
cpustate->data = &device->space(AS_DATA);
else
@@ -571,7 +571,7 @@ static CPU_INIT( z8002 )
cpustate->device = device;
cpustate->program = &device->space(AS_PROGRAM);
/* If the system decodes STn lines to distinguish between data and program memory fetches,
- install the data space. If it doesn't, install the program memory into data memory space. */
+ install the data space. If it doesn't, install the program memory into data memory space. */
if (device->has_space(AS_DATA))
cpustate->data = &device->space(AS_DATA);
else
@@ -616,31 +616,31 @@ static CPU_EXECUTE( z8000 )
{
z8000_state *cpustate = get_safe_token(device);
- do
- {
- /* any interrupt request pending? */
- if (cpustate->irq_req)
+ do
+ {
+ /* any interrupt request pending? */
+ if (cpustate->irq_req)
Interrupt(cpustate);
debugger_instruction_hook(device, cpustate->pc);
if (cpustate->irq_req & Z8000_HALT)
- {
- cpustate->icount = 0;
- }
- else
- {
- Z8000_exec *exec;
+ {
+ cpustate->icount = 0;
+ }
+ else
+ {
+ Z8000_exec *exec;
- cpustate->op[0] = RDOP(cpustate);
- cpustate->op_valid = 1;
- exec = &z8000_exec[cpustate->op[0]];
+ cpustate->op[0] = RDOP(cpustate);
+ cpustate->op_valid = 1;
+ exec = &z8000_exec[cpustate->op[0]];
- cpustate->icount -= exec->cycles;
- (*exec->opcode)(cpustate);
- cpustate->op_valid = 0;
- }
- } while (cpustate->icount > 0);
+ cpustate->icount -= exec->cycles;
+ (*exec->opcode)(cpustate);
+ cpustate->op_valid = 0;
+ }
+ } while (cpustate->icount > 0);
}
@@ -651,11 +651,11 @@ static void set_irq_line(z8000_state *cpustate, int irqline, int state)
if (cpustate->nmi_state == state)
return;
- cpustate->nmi_state = state;
+ cpustate->nmi_state = state;
- if (state != CLEAR_LINE)
+ if (state != CLEAR_LINE)
{
- if (cpustate->irq_srv >= Z8000_NMI) /* no NMIs inside trap */
+ if (cpustate->irq_srv >= Z8000_NMI) /* no NMIs inside trap */
return;
cpustate->irq_req = Z8000_NMI;
cpustate->irq_vec = NMI;
@@ -675,7 +675,7 @@ static void set_irq_line(z8000_state *cpustate, int irqline, int state)
{
if (cpustate->fcw & F_NVIE)
cpustate->irq_req |= Z8000_NVI;
- }
+ }
}
else
{
@@ -706,36 +706,36 @@ static CPU_SET_INFO( z8002 )
switch (state)
{
/* --- the following bits of info are set as 64-bit signed integers --- */
- case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: set_irq_line(cpustate, INPUT_LINE_NMI, info->i); break;
- case CPUINFO_INT_INPUT_STATE + 0: set_irq_line(cpustate, 0, info->i); break;
- case CPUINFO_INT_INPUT_STATE + 1: set_irq_line(cpustate, 1, info->i); break;
+ case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: set_irq_line(cpustate, INPUT_LINE_NMI, info->i); break;
+ case CPUINFO_INT_INPUT_STATE + 0: set_irq_line(cpustate, 0, info->i); break;
+ case CPUINFO_INT_INPUT_STATE + 1: set_irq_line(cpustate, 1, info->i); break;
- case CPUINFO_INT_PC: cpustate->pc = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_PC: cpustate->pc = info->i; break;
+ case CPUINFO_INT_PC: cpustate->pc = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_PC: cpustate->pc = info->i; break;
case CPUINFO_INT_SP:
- case CPUINFO_INT_REGISTER + Z8000_NSP: cpustate->nspoff = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_FCW: cpustate->fcw = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_PSAP: cpustate->psapoff = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_REFRESH: cpustate->refresh = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_REQ: cpustate->irq_req = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_SRV: cpustate->irq_srv = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_VEC: cpustate->irq_vec = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R0: cpustate->RW( 0) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R1: cpustate->RW( 1) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R2: cpustate->RW( 2) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R3: cpustate->RW( 3) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R4: cpustate->RW( 4) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R5: cpustate->RW( 5) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R6: cpustate->RW( 6) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R7: cpustate->RW( 7) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R8: cpustate->RW( 8) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R9: cpustate->RW( 9) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R10: cpustate->RW(10) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R11: cpustate->RW(11) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R12: cpustate->RW(12) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R13: cpustate->RW(13) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R14: cpustate->RW(14) = info->i; break;
- case CPUINFO_INT_REGISTER + Z8000_R15: cpustate->RW(15) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_NSP: cpustate->nspoff = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_FCW: cpustate->fcw = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_PSAP: cpustate->psapoff = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_REFRESH: cpustate->refresh = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_REQ: cpustate->irq_req = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_SRV: cpustate->irq_srv = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_VEC: cpustate->irq_vec = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R0: cpustate->RW( 0) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R1: cpustate->RW( 1) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R2: cpustate->RW( 2) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R3: cpustate->RW( 3) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R4: cpustate->RW( 4) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R5: cpustate->RW( 5) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R6: cpustate->RW( 6) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R7: cpustate->RW( 7) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R8: cpustate->RW( 8) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R9: cpustate->RW( 9) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R10: cpustate->RW(10) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R11: cpustate->RW(11) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R12: cpustate->RW(12) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R13: cpustate->RW(13) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R14: cpustate->RW(14) = info->i; break;
+ case CPUINFO_INT_REGISTER + Z8000_R15: cpustate->RW(15) = info->i; break;
}
}
@@ -752,76 +752,76 @@ CPU_GET_INFO( z8002 )
switch (state)
{
/* --- the following bits of info are returned as 64-bit signed integers --- */
- case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(z8000_state); break;
- case CPUINFO_INT_INPUT_LINES: info->i = 2; break;
- case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0xff; break;
- case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_BIG; break;
- case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break;
- case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break;
- case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 2; break;
- case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 6; break;
- case CPUINFO_INT_MIN_CYCLES: info->i = 2; break;
- case CPUINFO_INT_MAX_CYCLES: info->i = 744; break;
-
- case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break;
- case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break;
- case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break;
- case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 8; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break;
-
- case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: info->i = cpustate->nmi_state; break;
- case CPUINFO_INT_INPUT_STATE + 0: info->i = cpustate->irq_state[0]; break; /* NVI */
- case CPUINFO_INT_INPUT_STATE + 1: info->i = cpustate->irq_state[1]; break; /* VI */
-
- case CPUINFO_INT_PREVIOUSPC: info->i = cpustate->ppc; break;
+ case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(z8000_state); break;
+ case CPUINFO_INT_INPUT_LINES: info->i = 2; break;
+ case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0xff; break;
+ case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_BIG; break;
+ case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break;
+ case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break;
+ case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 2; break;
+ case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 6; break;
+ case CPUINFO_INT_MIN_CYCLES: info->i = 2; break;
+ case CPUINFO_INT_MAX_CYCLES: info->i = 744; break;
+
+ case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break;
+ case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break;
+ case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break;
+ case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 8; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break;
+
+ case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: info->i = cpustate->nmi_state; break;
+ case CPUINFO_INT_INPUT_STATE + 0: info->i = cpustate->irq_state[0]; break; /* NVI */
+ case CPUINFO_INT_INPUT_STATE + 1: info->i = cpustate->irq_state[1]; break; /* VI */
+
+ case CPUINFO_INT_PREVIOUSPC: info->i = cpustate->ppc; break;
case CPUINFO_INT_PC:
- case CPUINFO_INT_REGISTER + Z8000_PC: info->i = cpustate->pc; break;
+ case CPUINFO_INT_REGISTER + Z8000_PC: info->i = cpustate->pc; break;
case CPUINFO_INT_SP:
- case CPUINFO_INT_REGISTER + Z8000_NSP: info->i = cpustate->nspoff; break;
- case CPUINFO_INT_REGISTER + Z8000_FCW: info->i = cpustate->fcw; break;
- case CPUINFO_INT_REGISTER + Z8000_PSAP: info->i = cpustate->psapoff; break;
- case CPUINFO_INT_REGISTER + Z8000_REFRESH: info->i = cpustate->refresh; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_REQ: info->i = cpustate->irq_req; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_SRV: info->i = cpustate->irq_srv; break;
- case CPUINFO_INT_REGISTER + Z8000_IRQ_VEC: info->i = cpustate->irq_vec; break;
- case CPUINFO_INT_REGISTER + Z8000_R0: info->i = cpustate->RW( 0); break;
- case CPUINFO_INT_REGISTER + Z8000_R1: info->i = cpustate->RW( 1); break;
- case CPUINFO_INT_REGISTER + Z8000_R2: info->i = cpustate->RW( 2); break;
- case CPUINFO_INT_REGISTER + Z8000_R3: info->i = cpustate->RW( 3); break;
- case CPUINFO_INT_REGISTER + Z8000_R4: info->i = cpustate->RW( 4); break;
- case CPUINFO_INT_REGISTER + Z8000_R5: info->i = cpustate->RW( 5); break;
- case CPUINFO_INT_REGISTER + Z8000_R6: info->i = cpustate->RW( 6); break;
- case CPUINFO_INT_REGISTER + Z8000_R7: info->i = cpustate->RW( 7); break;
- case CPUINFO_INT_REGISTER + Z8000_R8: info->i = cpustate->RW( 8); break;
- case CPUINFO_INT_REGISTER + Z8000_R9: info->i = cpustate->RW( 9); break;
- case CPUINFO_INT_REGISTER + Z8000_R10: info->i = cpustate->RW(10); break;
- case CPUINFO_INT_REGISTER + Z8000_R11: info->i = cpustate->RW(11); break;
- case CPUINFO_INT_REGISTER + Z8000_R12: info->i = cpustate->RW(12); break;
- case CPUINFO_INT_REGISTER + Z8000_R13: info->i = cpustate->RW(13); break;
- case CPUINFO_INT_REGISTER + Z8000_R14: info->i = cpustate->RW(14); break;
- case CPUINFO_INT_REGISTER + Z8000_R15: info->i = cpustate->RW(15); break;
+ case CPUINFO_INT_REGISTER + Z8000_NSP: info->i = cpustate->nspoff; break;
+ case CPUINFO_INT_REGISTER + Z8000_FCW: info->i = cpustate->fcw; break;
+ case CPUINFO_INT_REGISTER + Z8000_PSAP: info->i = cpustate->psapoff; break;
+ case CPUINFO_INT_REGISTER + Z8000_REFRESH: info->i = cpustate->refresh; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_REQ: info->i = cpustate->irq_req; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_SRV: info->i = cpustate->irq_srv; break;
+ case CPUINFO_INT_REGISTER + Z8000_IRQ_VEC: info->i = cpustate->irq_vec; break;
+ case CPUINFO_INT_REGISTER + Z8000_R0: info->i = cpustate->RW( 0); break;
+ case CPUINFO_INT_REGISTER + Z8000_R1: info->i = cpustate->RW( 1); break;
+ case CPUINFO_INT_REGISTER + Z8000_R2: info->i = cpustate->RW( 2); break;
+ case CPUINFO_INT_REGISTER + Z8000_R3: info->i = cpustate->RW( 3); break;
+ case CPUINFO_INT_REGISTER + Z8000_R4: info->i = cpustate->RW( 4); break;
+ case CPUINFO_INT_REGISTER + Z8000_R5: info->i = cpustate->RW( 5); break;
+ case CPUINFO_INT_REGISTER + Z8000_R6: info->i = cpustate->RW( 6); break;
+ case CPUINFO_INT_REGISTER + Z8000_R7: info->i = cpustate->RW( 7); break;
+ case CPUINFO_INT_REGISTER + Z8000_R8: info->i = cpustate->RW( 8); break;
+ case CPUINFO_INT_REGISTER + Z8000_R9: info->i = cpustate->RW( 9); break;
+ case CPUINFO_INT_REGISTER + Z8000_R10: info->i = cpustate->RW(10); break;
+ case CPUINFO_INT_REGISTER + Z8000_R11: info->i = cpustate->RW(11); break;
+ case CPUINFO_INT_REGISTER + Z8000_R12: info->i = cpustate->RW(12); break;
+ case CPUINFO_INT_REGISTER + Z8000_R13: info->i = cpustate->RW(13); break;
+ case CPUINFO_INT_REGISTER + Z8000_R14: info->i = cpustate->RW(14); break;
+ case CPUINFO_INT_REGISTER + Z8000_R15: info->i = cpustate->RW(15); break;
/* --- the following bits of info are returned as pointers to data or functions --- */
- case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(z8002); break;
- case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(z8002); break;
- case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(z8002); break;
- case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(z8000); break;
- case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(z8000); break;
- case CPUINFO_FCT_BURN: info->burn = NULL; break;
- case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(z8000);break;
- case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break;
+ case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(z8002); break;
+ case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(z8002); break;
+ case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(z8002); break;
+ case CPUINFO_FCT_EXIT: info->exit = CPU_EXIT_NAME(z8000); break;
+ case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(z8000); break;
+ case CPUINFO_FCT_BURN: info->burn = NULL; break;
+ case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(z8000);break;
+ case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break;
/* --- the following bits of info are returned as NULL-terminated strings --- */
- case CPUINFO_STR_NAME: strcpy(info->s, "Z8002"); break;
- case CPUINFO_STR_FAMILY: strcpy(info->s, "Zilog Z8000"); break;
- case CPUINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
- case CPUINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
- case CPUINFO_STR_CREDITS: strcpy(info->s, "Copyright Juergen Buchmueller, all rights reserved."); break;
+ case CPUINFO_STR_NAME: strcpy(info->s, "Z8002"); break;
+ case CPUINFO_STR_FAMILY: strcpy(info->s, "Zilog Z8000"); break;
+ case CPUINFO_STR_VERSION: strcpy(info->s, "1.1"); break;
+ case CPUINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
+ case CPUINFO_STR_CREDITS: strcpy(info->s, "Copyright Juergen Buchmueller, all rights reserved."); break;
case CPUINFO_STR_FLAGS:
sprintf(info->s, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
@@ -841,32 +841,32 @@ CPU_GET_INFO( z8002 )
cpustate->fcw & 0x0004 ? 'H':'.',
cpustate->fcw & 0x0002 ? '?':'.',
cpustate->fcw & 0x0001 ? '?':'.');
- break;
-
- case CPUINFO_STR_REGISTER + Z8000_PC: sprintf(info->s, "pc :%08X", cpustate->pc); break;
- case CPUINFO_STR_REGISTER + Z8000_NSP: sprintf(info->s, "SP :%04X", cpustate->nspoff); break;
- case CPUINFO_STR_REGISTER + Z8000_FCW: sprintf(info->s, "fcw:%04X", cpustate->fcw); break;
- case CPUINFO_STR_REGISTER + Z8000_PSAP: sprintf(info->s, "psapoff:%04X", cpustate->psapoff); break;
- case CPUINFO_STR_REGISTER + Z8000_REFRESH: sprintf(info->s, "REFR:%04X", cpustate->refresh); break;
- case CPUINFO_STR_REGISTER + Z8000_IRQ_REQ: sprintf(info->s, "IRQR:%04X", cpustate->irq_req); break;
- case CPUINFO_STR_REGISTER + Z8000_IRQ_SRV: sprintf(info->s, "IRQS:%04X", cpustate->irq_srv); break;
- case CPUINFO_STR_REGISTER + Z8000_IRQ_VEC: sprintf(info->s, "IRQV:%04X", cpustate->irq_vec); break;
- case CPUINFO_STR_REGISTER + Z8000_R0: sprintf(info->s, "R0 :%04X", cpustate->RW(0)); break;
- case CPUINFO_STR_REGISTER + Z8000_R1: sprintf(info->s, "R1 :%04X", cpustate->RW(1)); break;
- case CPUINFO_STR_REGISTER + Z8000_R2: sprintf(info->s, "R2 :%04X", cpustate->RW(2)); break;
- case CPUINFO_STR_REGISTER + Z8000_R3: sprintf(info->s, "R3 :%04X", cpustate->RW(3)); break;
- case CPUINFO_STR_REGISTER + Z8000_R4: sprintf(info->s, "R4 :%04X", cpustate->RW(4)); break;
- case CPUINFO_STR_REGISTER + Z8000_R5: sprintf(info->s, "R5 :%04X", cpustate->RW(5)); break;
- case CPUINFO_STR_REGISTER + Z8000_R6: sprintf(info->s, "R6 :%04X", cpustate->RW(6)); break;
- case CPUINFO_STR_REGISTER + Z8000_R7: sprintf(info->s, "R7 :%04X", cpustate->RW(7)); break;
- case CPUINFO_STR_REGISTER + Z8000_R8: sprintf(info->s, "R8 :%04X", cpustate->RW(8)); break;
- case CPUINFO_STR_REGISTER + Z8000_R9: sprintf(info->s, "R9 :%04X", cpustate->RW(9)); break;
- case CPUINFO_STR_REGISTER + Z8000_R10: sprintf(info->s, "R10:%04X", cpustate->RW(10)); break;
- case CPUINFO_STR_REGISTER + Z8000_R11: sprintf(info->s, "R11:%04X", cpustate->RW(11)); break;
- case CPUINFO_STR_REGISTER + Z8000_R12: sprintf(info->s, "R12:%04X", cpustate->RW(12)); break;
- case CPUINFO_STR_REGISTER + Z8000_R13: sprintf(info->s, "R13:%04X", cpustate->RW(13)); break;
- case CPUINFO_STR_REGISTER + Z8000_R14: sprintf(info->s, "R14:%04X", cpustate->RW(14)); break;
- case CPUINFO_STR_REGISTER + Z8000_R15: sprintf(info->s, "R15:%04X", cpustate->RW(15)); break;
+ break;
+
+ case CPUINFO_STR_REGISTER + Z8000_PC: sprintf(info->s, "pc :%08X", cpustate->pc); break;
+ case CPUINFO_STR_REGISTER + Z8000_NSP: sprintf(info->s, "SP :%04X", cpustate->nspoff); break;
+ case CPUINFO_STR_REGISTER + Z8000_FCW: sprintf(info->s, "fcw:%04X", cpustate->fcw); break;
+ case CPUINFO_STR_REGISTER + Z8000_PSAP: sprintf(info->s, "psapoff:%04X", cpustate->psapoff); break;
+ case CPUINFO_STR_REGISTER + Z8000_REFRESH: sprintf(info->s, "REFR:%04X", cpustate->refresh); break;
+ case CPUINFO_STR_REGISTER + Z8000_IRQ_REQ: sprintf(info->s, "IRQR:%04X", cpustate->irq_req); break;
+ case CPUINFO_STR_REGISTER + Z8000_IRQ_SRV: sprintf(info->s, "IRQS:%04X", cpustate->irq_srv); break;
+ case CPUINFO_STR_REGISTER + Z8000_IRQ_VEC: sprintf(info->s, "IRQV:%04X", cpustate->irq_vec); break;
+ case CPUINFO_STR_REGISTER + Z8000_R0: sprintf(info->s, "R0 :%04X", cpustate->RW(0)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R1: sprintf(info->s, "R1 :%04X", cpustate->RW(1)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R2: sprintf(info->s, "R2 :%04X", cpustate->RW(2)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R3: sprintf(info->s, "R3 :%04X", cpustate->RW(3)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R4: sprintf(info->s, "R4 :%04X", cpustate->RW(4)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R5: sprintf(info->s, "R5 :%04X", cpustate->RW(5)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R6: sprintf(info->s, "R6 :%04X", cpustate->RW(6)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R7: sprintf(info->s, "R7 :%04X", cpustate->RW(7)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R8: sprintf(info->s, "R8 :%04X", cpustate->RW(8)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R9: sprintf(info->s, "R9 :%04X", cpustate->RW(9)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R10: sprintf(info->s, "R10:%04X", cpustate->RW(10)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R11: sprintf(info->s, "R11:%04X", cpustate->RW(11)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R12: sprintf(info->s, "R12:%04X", cpustate->RW(12)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R13: sprintf(info->s, "R13:%04X", cpustate->RW(13)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R14: sprintf(info->s, "R14:%04X", cpustate->RW(14)); break;
+ case CPUINFO_STR_REGISTER + Z8000_R15: sprintf(info->s, "R15:%04X", cpustate->RW(15)); break;
}
}
@@ -878,24 +878,24 @@ CPU_GET_INFO( z8001 )
{
switch (state)
{
- case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 20; break;
- case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 20; break;
- case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 16; break;
- case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break;
+ case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 20; break;
+ case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 20; break;
+ case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 16; break;
+ case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break;
/* --- the following bits of info are returned as pointers to data or functions --- */
- case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(z8001); break;
- case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(z8001); break;
+ case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(z8001); break;
+ case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(z8001); break;
/* --- the following bits of info are returned as NULL-terminated strings --- */
- case CPUINFO_STR_NAME: strcpy(info->s, "Zilog Z8001"); break;
+ case CPUINFO_STR_NAME: strcpy(info->s, "Zilog Z8001"); break;
- case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 2; break;
- case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 8; break;
+ case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 2; break;
+ case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 8; break;
- default: CPU_GET_INFO_CALL(z8002); break;
+ default: CPU_GET_INFO_CALL(z8002); break;
}
}