src/emu/cpu/z8/z8.c
| r5545 | r5546 | |
| 14 | 14 | - expose register file to disassembler |
| 15 | 15 | - arithmetic opcodes |
| 16 | 16 | - interrupts |
| 17 | | - I/O ports |
| 18 | 17 | - counter/timer |
| 19 | 18 | - serial |
| 20 | 19 | - instruction pipeline |
| r5545 | r5546 | |
| 56 | 55 | #define Z8_P01M_P0L_MODE_MASK 0x03 |
| 57 | 56 | #define Z8_P01M_P0L_MODE_OUTPUT 0x00 |
| 58 | 57 | #define Z8_P01M_P0L_MODE_INPUT 0x01 |
| 59 | | #define Z8_P01M_P0L_MODE_A8_A11 0x02 |
| 58 | #define Z8_P01M_P0L_MODE_A8_A11 0x02 /* not supported */ |
| 60 | 59 | #define Z8_P01M_INTERNAL_STACK 0x04 |
| 61 | 60 | #define Z8_P01M_P1_MODE_MASK 0x18 |
| 62 | 61 | #define Z8_P01M_P1_MODE_OUTPUT 0x00 |
| 63 | 62 | #define Z8_P01M_P1_MODE_INPUT 0x08 |
| 64 | | #define Z8_P01M_P1_MODE_AD0_AD7 0x10 |
| 65 | | #define Z8_P01M_P1_MODE_HI_Z 0x18 |
| 66 | | #define Z8_P01M_EXTENDED_TIMING 0x20 |
| 67 | | #define Z8_P01M_P1H_MODE_MASK 0xc0 |
| 68 | | #define Z8_P01M_P1H_MODE_OUTPUT 0x00 |
| 69 | | #define Z8_P01M_P1H_MODE_INPUT 0x40 |
| 70 | | #define Z8_P01M_P1H_MODE_A12_A15 0x80 |
| 63 | #define Z8_P01M_P1_MODE_AD0_AD7 0x10 /* not supported */ |
| 64 | #define Z8_P01M_P1_MODE_HI_Z 0x18 /* not supported */ |
| 65 | #define Z8_P01M_EXTENDED_TIMING 0x20 /* not supported */ |
| 66 | #define Z8_P01M_P0H_MODE_MASK 0xc0 |
| 67 | #define Z8_P01M_P0H_MODE_OUTPUT 0x00 |
| 68 | #define Z8_P01M_P0H_MODE_INPUT 0x40 |
| 69 | #define Z8_P01M_P0H_MODE_A12_A15 0x80 /* not supported */ |
| 71 | 70 | |
| 72 | | #define Z8_IMR_ENABLE 0x80 |
| 71 | #define Z8_P3M_P2_ACTIVE_PULLUPS 0x01 /* not supported */ |
| 72 | #define Z8_P3M_P0_STROBED 0x04 |
| 73 | #define Z8_P3M_P1_MODE_MASK 0x18 |
| 74 | //#define Z8_P3M_ 0x00 |
| 75 | //#define Z8_P3M_ 0x08 |
| 76 | //#define Z8_P3M_ 0x10 |
| 77 | #define Z8_P3M_P1_STROBED 0x18 |
| 78 | #define Z8_P3M_P2_STROBED 0x20 |
| 79 | #define Z8_P3M_P3_SERIAL 0x40 /* not supported */ |
| 80 | #define Z8_P3M_PARITY 0x80 /* not supported */ |
| 81 | |
| 82 | #define Z8_IMR_ENABLE 0x80 /* not supported */ |
| 73 | 83 | #define Z8_IMR_RAM_PROTECT 0x40 /* not supported */ |
| 74 | | #define Z8_IMR_ENABLE_IRQ5 0x20 |
| 75 | | #define Z8_IMR_ENABLE_IRQ4 0x10 |
| 76 | | #define Z8_IMR_ENABLE_IRQ3 0x08 |
| 77 | | #define Z8_IMR_ENABLE_IRQ2 0x04 |
| 78 | | #define Z8_IMR_ENABLE_IRQ1 0x02 |
| 79 | | #define Z8_IMR_ENABLE_IRQ0 0x01 |
| 84 | #define Z8_IMR_ENABLE_IRQ5 0x20 /* not supported */ |
| 85 | #define Z8_IMR_ENABLE_IRQ4 0x10 /* not supported */ |
| 86 | #define Z8_IMR_ENABLE_IRQ3 0x08 /* not supported */ |
| 87 | #define Z8_IMR_ENABLE_IRQ2 0x04 /* not supported */ |
| 88 | #define Z8_IMR_ENABLE_IRQ1 0x02 /* not supported */ |
| 89 | #define Z8_IMR_ENABLE_IRQ0 0x01 /* not supported */ |
| 80 | 90 | |
| 81 | 91 | #define Z8_FLAGS_F1 0x01 |
| 82 | 92 | #define Z8_FLAGS_F2 0x02 |
| r5545 | r5546 | |
| 110 | 120 | UINT16 fake_sp; /* fake stack pointer */ |
| 111 | 121 | UINT8 fake_rp; /* fake register pointer */ |
| 112 | 122 | UINT8 fake_r[16]; /* fake working registers */ |
| 123 | UINT8 input[4]; /* port input latches */ |
| 124 | UINT8 output[4]; /* port output latches */ |
| 113 | 125 | |
| 114 | 126 | /* interrupts */ |
| 115 | 127 | int irq[4]; /* external interrupt flip-flops */ |
| r5545 | r5546 | |
| 188 | 200 | INLINE UINT8 register_read(z8_state *cpustate, UINT8 offset) |
| 189 | 201 | { |
| 190 | 202 | UINT8 data = 0xff; |
| 203 | UINT8 mask = 0; |
| 191 | 204 | |
| 192 | 205 | switch (offset) |
| 193 | 206 | { |
| 194 | 207 | case Z8_REGISTER_P0: |
| 208 | /* TODO: if defined as address outputs, return 1 in each address bit location */ |
| 209 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P0L_MODE_MASK) == Z8_P01M_P0L_MODE_INPUT) mask |= 0x0f; |
| 210 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P0H_MODE_MASK) == Z8_P01M_P0H_MODE_INPUT) mask |= 0xf0; |
| 211 | |
| 212 | if (!(cpustate->r[Z8_REGISTER_P3M] & Z8_P3M_P0_STROBED)) |
| 213 | { |
| 214 | if (mask) cpustate->input[offset] = memory_read_byte_8be(cpustate->io, offset); |
| 215 | } |
| 216 | |
| 217 | data = (cpustate->input[offset] & mask) | (cpustate->output[offset] & ~mask); |
| 218 | break; |
| 219 | |
| 195 | 220 | case Z8_REGISTER_P1: |
| 221 | /* TODO: if defined as address outputs, return 1 in each address bit location */ |
| 222 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P1_MODE_MASK) == Z8_P01M_P1_MODE_INPUT) mask = 0xff; |
| 223 | |
| 224 | if ((cpustate->r[Z8_REGISTER_P3M] & Z8_P3M_P1_MODE_MASK) != Z8_P3M_P1_STROBED) |
| 225 | { |
| 226 | if (mask) cpustate->input[offset] = memory_read_byte_8be(cpustate->io, offset); |
| 227 | } |
| 228 | |
| 229 | data = (cpustate->input[offset] & mask) | (cpustate->output[offset] & ~mask); |
| 230 | break; |
| 231 | |
| 196 | 232 | case Z8_REGISTER_P2: |
| 233 | mask = cpustate->r[Z8_REGISTER_P2M]; |
| 234 | |
| 235 | if (!(cpustate->r[Z8_REGISTER_P3M] & Z8_P3M_P2_STROBED)) |
| 236 | { |
| 237 | if (mask) cpustate->input[offset] = memory_read_byte_8be(cpustate->io, offset); |
| 238 | } |
| 239 | |
| 240 | data = (cpustate->input[offset] & mask) | (cpustate->output[offset] & ~mask); |
| 241 | break; |
| 242 | |
| 197 | 243 | case Z8_REGISTER_P3: |
| 198 | | data = memory_read_byte_8be(cpustate->io, offset); |
| 199 | | /* if defined as address outputs, return 1 in each address bit location */ |
| 244 | // TODO: special port 3 modes |
| 245 | if (!(cpustate->r[Z8_REGISTER_P3M] & 0x7c)) |
| 246 | { |
| 247 | mask = 0x0f; |
| 248 | } |
| 249 | |
| 250 | if (mask) cpustate->input[offset] = memory_read_byte_8be(cpustate->io, offset); |
| 251 | |
| 252 | data = (cpustate->input[offset] & mask) | (cpustate->output[offset] & ~mask); |
| 200 | 253 | break; |
| 201 | 254 | |
| 202 | 255 | case Z8_REGISTER_PRE1: |
| r5545 | r5546 | |
| 223 | 276 | |
| 224 | 277 | INLINE void register_write(z8_state *cpustate, UINT8 offset, UINT8 data) |
| 225 | 278 | { |
| 279 | UINT8 mask = 0; |
| 280 | |
| 226 | 281 | switch (offset) |
| 227 | 282 | { |
| 228 | 283 | case Z8_REGISTER_P0: |
| 284 | cpustate->output[offset] = data; |
| 285 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P0L_MODE_MASK) == Z8_P01M_P0L_MODE_OUTPUT) mask |= 0x0f; |
| 286 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P0H_MODE_MASK) == Z8_P01M_P0H_MODE_OUTPUT) mask |= 0xf0; |
| 287 | if (mask) memory_write_byte_8be(cpustate->io, offset, data & mask); |
| 288 | break; |
| 289 | |
| 229 | 290 | case Z8_REGISTER_P1: |
| 291 | cpustate->output[offset] = data; |
| 292 | if ((cpustate->r[Z8_REGISTER_P01M] & Z8_P01M_P1_MODE_MASK) == Z8_P01M_P1_MODE_OUTPUT) mask = 0xff; |
| 293 | if (mask) memory_write_byte_8be(cpustate->io, offset, data & mask); |
| 294 | break; |
| 295 | |
| 230 | 296 | case Z8_REGISTER_P2: |
| 297 | cpustate->output[offset] = data; |
| 298 | mask = cpustate->r[Z8_REGISTER_P2M] ^ 0xff; |
| 299 | if (mask) memory_write_byte_8be(cpustate->io, offset, data & mask); |
| 300 | break; |
| 301 | |
| 231 | 302 | case Z8_REGISTER_P3: |
| 232 | | memory_write_byte_8be(cpustate->io, offset, data); |
| 303 | cpustate->output[offset] = data; |
| 304 | |
| 305 | // TODO: special port 3 modes |
| 306 | if (!(cpustate->r[Z8_REGISTER_P3M] & 0x7c)) |
| 307 | { |
| 308 | mask = 0xf0; |
| 309 | } |
| 310 | |
| 311 | if (mask) memory_write_byte_8be(cpustate->io, offset, data & mask); |
| 233 | 312 | break; |
| 234 | 313 | |
| 235 | 314 | case Z8_REGISTER_SIO: |
src/emu/cpu/z8/z8ops.c
| r5545 | r5546 | |
| 155 | 155 | static void load_to_memory(z8_state *cpustate, const address_space *space) |
| 156 | 156 | { |
| 157 | 157 | UINT8 operands = fetch(cpustate); |
| 158 | | UINT8 dst = get_working_register(cpustate, operands >> 4); |
| 159 | | UINT8 src = get_working_register(cpustate, operands & 0x0f); |
| 158 | UINT8 src = get_working_register(cpustate, operands >> 4); |
| 159 | UINT8 dst = get_working_register(cpustate, operands & 0x0f); |
| 160 | 160 | |
| 161 | 161 | UINT16 address = register_pair_read(cpustate, dst); |
| 162 | 162 | UINT8 data = register_read(cpustate, src); |
| r5545 | r5546 | |
| 183 | 183 | static void load_to_memory_autoinc(z8_state *cpustate, const address_space *space) |
| 184 | 184 | { |
| 185 | 185 | UINT8 operands = fetch(cpustate); |
| 186 | | UINT8 dst = get_working_register(cpustate, operands >> 4); |
| 187 | | UINT8 src = get_working_register(cpustate, operands & 0x0f); |
| 186 | UINT8 src = get_working_register(cpustate, operands >> 4); |
| 187 | UINT8 dst = get_working_register(cpustate, operands & 0x0f); |
| 188 | 188 | UINT8 real_src = get_intermediate_register(cpustate, src); |
| 189 | 189 | |
| 190 | 190 | UINT16 address = register_pair_read(cpustate, dst); |