src/emu/cpu/cdp1802/cdp1802.c
| r5261 | r5262 | |
| 48 | 48 | |
| 49 | 49 | /* cpu state */ |
| 50 | 50 | cdp1802_cpu_state state; /* processor state */ |
| 51 | cdp1802_state_code state_code; /* state code */ |
| 51 | 52 | cdp1802_control_mode mode; /* control mode */ |
| 52 | 53 | cdp1802_control_mode prevmode; /* previous control mode */ |
| 53 | 54 | |
| r5261 | r5262 | |
| 101 | 102 | CDP1802_STATE_ENTRY(Re, "%04X", r[14], 0xffff, 0) |
| 102 | 103 | CDP1802_STATE_ENTRY(Rf, "%04X", r[15], 0xffff, 0) |
| 103 | 104 | |
| 105 | CDP1802_STATE_ENTRY(SC, "%1u", state_code, 0x3, CPUSTATE_NOSHOW) |
| 104 | 106 | CDP1802_STATE_ENTRY(DF, "%1u", df, 0x1, CPUSTATE_NOSHOW) |
| 105 | 107 | CDP1802_STATE_ENTRY(IE, "%1u", ie, 0x1, CPUSTATE_NOSHOW) |
| 106 | 108 | CDP1802_STATE_ENTRY(Q, "%1u", q, 0x1, CPUSTATE_NOSHOW) |
| r5261 | r5262 | |
| 243 | 245 | if (cpustate->intf->sc_w) |
| 244 | 246 | { |
| 245 | 247 | cdp1802_state_code state_code = CDP1802_STATE_CODE_S0_FETCH; |
| 248 | int sc0, sc1; |
| 246 | 249 | |
| 247 | 250 | switch (cpustate->state) |
| 248 | 251 | { |
| r5261 | r5262 | |
| 266 | 269 | break; |
| 267 | 270 | } |
| 268 | 271 | |
| 269 | | cpustate->intf->sc_w(device, state_code); |
| 272 | sc0 = BIT(state_code, 0); |
| 273 | sc1 = BIT(state_code, 1); |
| 274 | |
| 275 | cpustate->intf->sc_w(device, state_code, sc0, sc1); |
| 270 | 276 | } |
| 271 | 277 | } |
| 272 | 278 | |
| r5261 | r5262 | |
| 274 | 280 | { |
| 275 | 281 | cdp1802_state *cpustate = get_safe_token(device); |
| 276 | 282 | |
| 277 | | cdp1802_output_state_code(device); |
| 278 | | |
| 279 | 283 | switch (cpustate->state) |
| 280 | 284 | { |
| 281 | 285 | case CDP1802_STATE_1_RESET: |
| r5261 | r5262 | |
| 885 | 889 | switch (cpustate->mode) |
| 886 | 890 | { |
| 887 | 891 | case CDP1802_MODE_LOAD: |
| 888 | | I = 0; |
| 889 | | N = 0; |
| 890 | | cpustate->state = CDP1802_STATE_1_EXECUTE; |
| 891 | | cdp1802_run(device); |
| 892 | if (cpustate->prevmode == CDP1802_MODE_RESET) |
| 893 | { |
| 894 | cpustate->prevmode = CDP1802_MODE_LOAD; |
| 895 | |
| 896 | /* execute initialization cycle */ |
| 897 | cpustate->state = CDP1802_STATE_1_INIT; |
| 898 | cdp1802_run(device); |
| 899 | |
| 900 | /* next state is IDLE */ |
| 901 | cpustate->state = CDP1802_STATE_1_EXECUTE; |
| 902 | } |
| 903 | else |
| 904 | { |
| 905 | /* idle */ |
| 906 | I = 0; |
| 907 | N = 0; |
| 908 | cdp1802_run(device); |
| 909 | } |
| 892 | 910 | break; |
| 893 | 911 | |
| 894 | 912 | case CDP1802_MODE_RESET: |
| r5261 | r5262 | |
| 905 | 923 | { |
| 906 | 924 | case CDP1802_MODE_LOAD: |
| 907 | 925 | // RUN mode cannot be initiated from LOAD mode |
| 926 | logerror("CDP1802 '%s' Tried to initiate RUN mode from LOAD mode\n", device->tag); |
| 908 | 927 | cpustate->mode = CDP1802_MODE_LOAD; |
| 909 | 928 | break; |
| 910 | 929 | |
| r5261 | r5262 | |
| 926 | 945 | } |
| 927 | 946 | break; |
| 928 | 947 | } |
| 948 | |
| 949 | cdp1802_output_state_code(device); |
| 929 | 950 | } |
| 930 | 951 | while (cpustate->icount > 0); |
| 931 | 952 | |
src/mess/drivers/elf.c
| r5261 | r5262 | |
| 1 | 1 | /*************************************************************************** |
| 2 | 2 | |
| 3 | | Netronics Elf-II |
| 3 | Netronics Elf II |
| 4 | 4 | |
| 5 | 5 | ****************************************************************************/ |
| 6 | 6 | |
| r5261 | r5262 | |
| 8 | 8 | |
| 9 | 9 | TODO: |
| 10 | 10 | |
| 11 | | - keyboard |
| 12 | | - Q led |
| 13 | | - DMAIN |
| 14 | | - memory protect |
| 15 | | - 7 segment displays |
| 11 | - proper layout |
| 16 | 12 | |
| 17 | 13 | */ |
| 18 | 14 | |
| r5261 | r5262 | |
| 20 | 16 | #include "includes/elf.h" |
| 21 | 17 | #include "cpu/cdp1802/cdp1802.h" |
| 22 | 18 | #include "devices/cassette.h" |
| 19 | #include "devices/snapquik.h" |
| 23 | 20 | #include "machine/mm74c922.h" |
| 24 | 21 | #include "video/cdp1861.h" |
| 25 | 22 | #include "video/dm9368.h" |
| 26 | 23 | #include "machine/rescap.h" |
| 27 | 24 | #include "elf2.lh" |
| 28 | 25 | |
| 26 | #define RUN(_machine) BIT(input_port_read((_machine), "SPECIAL"), 0) |
| 27 | #define LOAD(_machine) BIT(input_port_read((_machine), "SPECIAL"), 1) |
| 28 | #define MEMORY_PROTECT(_machine) BIT(input_port_read((_machine), "SPECIAL"), 2) |
| 29 | #define INPUT(_machine) BIT(input_port_read((_machine), "SPECIAL"), 3) |
| 30 | |
| 31 | static QUICKLOAD_LOAD( elf ); |
| 32 | |
| 29 | 33 | /* Read/Write Handlers */ |
| 30 | 34 | |
| 31 | | static WRITE8_HANDLER( digit_w ) |
| 35 | static READ8_DEVICE_HANDLER( dispon_r ) |
| 32 | 36 | { |
| 33 | | // elf_state *state = space->machine->driver_data; |
| 37 | cdp1861_dispon_w(device, 1); |
| 38 | cdp1861_dispon_w(device, 0); |
| 34 | 39 | |
| 35 | | output_set_digit_value(0, 0xff); |
| 36 | | output_set_digit_value(1, 0xff); |
| 40 | return 0xff; |
| 37 | 41 | } |
| 38 | 42 | |
| 43 | static READ8_HANDLER( data_r ) |
| 44 | { |
| 45 | elf2_state *state = space->machine->driver_data; |
| 46 | |
| 47 | return state->data; |
| 48 | } |
| 49 | |
| 50 | static WRITE8_HANDLER( data_w ) |
| 51 | { |
| 52 | elf2_state *state = space->machine->driver_data; |
| 53 | |
| 54 | dm9368_w(state->dm9368_l, 0, data & 0x0f); |
| 55 | dm9368_w(state->dm9368_h, 0, data >> 4); |
| 56 | } |
| 57 | |
| 58 | static WRITE8_HANDLER( memory_w ) |
| 59 | { |
| 60 | elf2_state *state = space->machine->driver_data; |
| 61 | |
| 62 | if (LOAD(space->machine)) |
| 63 | { |
| 64 | if (MEMORY_PROTECT(space->machine)) |
| 65 | { |
| 66 | /* latch data from memory */ |
| 67 | data = mess_ram[offset]; |
| 68 | } |
| 69 | else |
| 70 | { |
| 71 | /* write latched data to memory */ |
| 72 | mess_ram[offset] = data; |
| 73 | } |
| 74 | |
| 75 | /* write data to 7 segment displays */ |
| 76 | dm9368_w(state->dm9368_l, 0, data & 0x0f); |
| 77 | dm9368_w(state->dm9368_h, 0, data >> 4); |
| 78 | } |
| 79 | } |
| 80 | |
| 39 | 81 | /* Memory Maps */ |
| 40 | 82 | |
| 41 | 83 | static ADDRESS_MAP_START( elf2_mem, ADDRESS_SPACE_PROGRAM, 8 ) |
| 84 | ADDRESS_MAP_UNMAP_HIGH |
| 42 | 85 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 43 | | AM_RANGE(0x0000, 0x00ff) AM_RAM |
| 86 | AM_RANGE(0x0000, 0x00ff) AM_RAMBANK(1) |
| 44 | 87 | ADDRESS_MAP_END |
| 45 | 88 | |
| 46 | 89 | static ADDRESS_MAP_START( elf2_io, ADDRESS_SPACE_IO, 8 ) |
| 47 | | // AM_RANGE(0x01, 0x01) AM_DEVREADWRITE(CDP1861_TAG, vip_cdp1861_dispon_r, vip_cdp1861_dispoff_w) |
| 48 | | AM_RANGE(0x04, 0x04) AM_WRITE(digit_w) |
| 90 | ADDRESS_MAP_UNMAP_HIGH |
| 91 | AM_RANGE(0x01, 0x01) AM_DEVREAD(CDP1861_TAG, dispon_r) |
| 92 | AM_RANGE(0x04, 0x04) AM_READWRITE(data_r, data_w) |
| 49 | 93 | ADDRESS_MAP_END |
| 50 | 94 | |
| 51 | 95 | /* Input Ports */ |
| r5261 | r5262 | |
| 54 | 98 | { |
| 55 | 99 | if (newval) |
| 56 | 100 | { |
| 101 | /* assert DMAIN */ |
| 57 | 102 | cputag_set_input_line(field->port->machine, CDP1802_TAG, CDP1802_INPUT_LINE_DMAIN, ASSERT_LINE); |
| 58 | 103 | } |
| 59 | 104 | } |
| r5261 | r5262 | |
| 91 | 136 | PORT_BIT( 0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("RUN") PORT_CODE(KEYCODE_R) PORT_TOGGLE |
| 92 | 137 | PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("LOAD") PORT_CODE(KEYCODE_L) PORT_TOGGLE |
| 93 | 138 | PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("M/P") PORT_CODE(KEYCODE_M) PORT_TOGGLE |
| 94 | | PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("INPUT") PORT_CODE(KEYCODE_R) PORT_CHANGED(input_w, 0) |
| 139 | PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_NAME("INPUT") PORT_CODE(KEYCODE_ENTER) PORT_CHANGED(input_w, 0) |
| 95 | 140 | INPUT_PORTS_END |
| 96 | 141 | |
| 97 | 142 | /* CDP1802 Configuration */ |
| 98 | 143 | |
| 99 | 144 | static CDP1802_MODE_READ( elf2_mode_r ) |
| 100 | 145 | { |
| 101 | | // elf_state *state = device->machine->driver_data; |
| 102 | | |
| 103 | | UINT8 special = input_port_read(device->machine, "SPECIAL"); |
| 104 | | int run = BIT(special, 0); |
| 105 | | int load = !BIT(special, 1); |
| 106 | 146 | cdp1802_control_mode mode = CDP1802_MODE_RESET; |
| 107 | 147 | |
| 108 | | switch ((run << 1) | load) |
| 148 | switch ((RUN(device->machine) << 1) | !LOAD(device->machine)) |
| 109 | 149 | { |
| 110 | | case 0: mode = CDP1802_MODE_LOAD; break; |
| 111 | | case 1: mode = CDP1802_MODE_RESET; break; |
| 112 | | case 2: mode = CDP1802_MODE_PAUSE; break; |
| 113 | | case 3: mode = CDP1802_MODE_RUN; break; |
| 150 | case 0: mode = CDP1802_MODE_LOAD; popmessage("LOAD"); break; |
| 151 | case 1: mode = CDP1802_MODE_RESET; popmessage("RESET"); break; |
| 152 | case 2: mode = CDP1802_MODE_PAUSE; popmessage("PAUSE"); break; |
| 153 | case 3: mode = CDP1802_MODE_RUN; popmessage("RUN"); break; |
| 114 | 154 | } |
| 115 | 155 | |
| 116 | 156 | return mode; |
| r5261 | r5262 | |
| 122 | 162 | EF1 CDP1861 |
| 123 | 163 | EF2 |
| 124 | 164 | EF3 |
| 125 | | EF4 |
| 165 | EF4 input switch |
| 126 | 166 | */ |
| 127 | 167 | |
| 128 | | elf_state *state = device->machine->driver_data; |
| 168 | elf2_state *state = device->machine->driver_data; |
| 129 | 169 | |
| 130 | 170 | UINT8 flags = 0x0f; |
| 131 | 171 | |
| 132 | 172 | /* CDP1861 */ |
| 133 | 173 | if (state->cdp1861_efx) flags -= EF1; |
| 134 | 174 | |
| 175 | /* input switch */ |
| 176 | if (!INPUT(device->machine)) flags -= EF4; |
| 177 | |
| 135 | 178 | return flags; |
| 136 | 179 | } |
| 137 | 180 | |
| 138 | 181 | static CDP1802_SC_WRITE( elf2_sc_w ) |
| 139 | 182 | { |
| 140 | | // elf_state *driver_state = device->machine->driver_data; |
| 141 | | |
| 142 | | if (state == CDP1802_STATE_CODE_S2_DMA) |
| 183 | if (sc1) |
| 143 | 184 | { |
| 144 | | // DMA acknowledge clears the DMAOUT request |
| 185 | /* clear DMAIN */ |
| 145 | 186 | cputag_set_input_line(device->machine, CDP1802_TAG, CDP1802_INPUT_LINE_DMAIN, CLEAR_LINE); |
| 146 | 187 | } |
| 147 | 188 | } |
| r5261 | r5262 | |
| 153 | 194 | |
| 154 | 195 | static READ8_DEVICE_HANDLER( elf2_dma_r ) |
| 155 | 196 | { |
| 156 | | // elf_state *state = device->machine->driver_data; |
| 197 | elf2_state *state = device->machine->driver_data; |
| 157 | 198 | |
| 158 | | return 0; |
| 199 | return state->data; |
| 159 | 200 | } |
| 160 | 201 | |
| 161 | 202 | static WRITE8_DEVICE_HANDLER( elf2_dma_w ) |
| 162 | 203 | { |
| 163 | | elf_state *state = device->machine->driver_data; |
| 204 | elf2_state *state = device->machine->driver_data; |
| 164 | 205 | |
| 165 | 206 | cdp1861_dma_w(state->cdp1861, data); |
| 166 | 207 | } |
| r5261 | r5262 | |
| 179 | 220 | |
| 180 | 221 | static WRITE_LINE_DEVICE_HANDLER( mm74c923_da_w ) |
| 181 | 222 | { |
| 223 | elf2_state *driver_state = device->machine->driver_data; |
| 224 | |
| 225 | if (state) |
| 226 | { |
| 227 | /* shift keyboard data to latch */ |
| 228 | driver_state->data <<= 4; |
| 229 | driver_state->data |= mm74c922_r(device, 0) & 0x0f; |
| 230 | |
| 231 | if (LOAD(device->machine)) |
| 232 | { |
| 233 | /* write data to 7 segment displays */ |
| 234 | dm9368_w(driver_state->dm9368_l, 0, driver_state->data & 0x0f); |
| 235 | dm9368_w(driver_state->dm9368_h, 0, driver_state->data >> 4); |
| 236 | } |
| 237 | } |
| 182 | 238 | } |
| 183 | 239 | |
| 184 | 240 | static MM74C922_INTERFACE( keyboard_intf ) |
| r5261 | r5262 | |
| 197 | 253 | |
| 198 | 254 | static VIDEO_UPDATE( elf2 ) |
| 199 | 255 | { |
| 200 | | elf_state *state = screen->machine->driver_data; |
| 256 | elf2_state *state = screen->machine->driver_data; |
| 201 | 257 | |
| 202 | 258 | cdp1861_update(state->cdp1861, bitmap, cliprect); |
| 203 | 259 | |
| r5261 | r5262 | |
| 206 | 262 | |
| 207 | 263 | static WRITE_LINE_DEVICE_HANDLER( elf2_efx_w ) |
| 208 | 264 | { |
| 209 | | elf_state *driver_state = device->machine->driver_data; |
| 265 | elf2_state *driver_state = device->machine->driver_data; |
| 210 | 266 | |
| 211 | 267 | driver_state->cdp1861_efx = state; |
| 212 | 268 | } |
| r5261 | r5262 | |
| 224 | 280 | |
| 225 | 281 | static MACHINE_START( elf2 ) |
| 226 | 282 | { |
| 227 | | elf_state *state = machine->driver_data; |
| 283 | elf2_state *state = machine->driver_data; |
| 284 | const address_space *program = cputag_get_address_space(machine, CDP1802_TAG, ADDRESS_SPACE_PROGRAM); |
| 228 | 285 | |
| 229 | 286 | /* find devices */ |
| 230 | 287 | state->cdp1861 = devtag_get_device(machine, CDP1861_TAG); |
| r5261 | r5262 | |
| 233 | 290 | state->dm9368_h = devtag_get_device(machine, DM9368_H_TAG); |
| 234 | 291 | state->cassette = devtag_get_device(machine, CASSETTE_TAG); |
| 235 | 292 | |
| 293 | /* initialize LED displays */ |
| 294 | dm9368_rbi_w(state->dm9368_l, 1); |
| 295 | dm9368_rbi_w(state->dm9368_h, 1); |
| 296 | |
| 297 | /* setup memory banking */ |
| 298 | memory_install_readwrite8_handler(program, 0x0000, 0x00ff, 0, 0, SMH_BANK(1), memory_w); |
| 299 | memory_configure_bank(machine, 1, 0, 1, mess_ram, 0); |
| 300 | memory_set_bank(machine, 1, 0); |
| 301 | |
| 236 | 302 | /* register for state saving */ |
| 237 | | // state_save_register_global(machine, state->); |
| 303 | state_save_register_global(machine, state->cdp1861_efx); |
| 304 | state_save_register_global(machine, state->data); |
| 238 | 305 | } |
| 239 | 306 | |
| 240 | 307 | /* Machine Driver */ |
| r5261 | r5262 | |
| 247 | 314 | }; |
| 248 | 315 | |
| 249 | 316 | static MACHINE_DRIVER_START( elf2 ) |
| 250 | | MDRV_DRIVER_DATA(elf_state) |
| 317 | MDRV_DRIVER_DATA(elf2_state) |
| 251 | 318 | |
| 252 | 319 | /* basic machine hardware */ |
| 253 | 320 | MDRV_CPU_ADD(CDP1802_TAG, CDP1802, XTAL_3_579545MHz/2) |
| r5261 | r5262 | |
| 274 | 341 | |
| 275 | 342 | /* devices */ |
| 276 | 343 | MDRV_CASSETTE_ADD(CASSETTE_TAG, elf_cassette_config) |
| 344 | MDRV_QUICKLOAD_ADD("quickload", elf, "bin", 0) |
| 277 | 345 | MACHINE_DRIVER_END |
| 278 | 346 | |
| 279 | 347 | /* ROMs */ |
| r5261 | r5262 | |
| 284 | 352 | |
| 285 | 353 | /* System Configuration */ |
| 286 | 354 | |
| 355 | static QUICKLOAD_LOAD( elf ) |
| 356 | { |
| 357 | int size = image_length(image); |
| 358 | |
| 359 | if (size > mess_ram_size) |
| 360 | { |
| 361 | return INIT_FAIL; |
| 362 | } |
| 363 | |
| 364 | image_fread(image, mess_ram, size); |
| 365 | |
| 366 | return INIT_PASS; |
| 367 | } |
| 368 | |
| 287 | 369 | static SYSTEM_CONFIG_START( elf2 ) |
| 288 | | CONFIG_RAM_DEFAULT( 1 * 1024 ) |
| 370 | CONFIG_RAM_DEFAULT( 256 ) |
| 289 | 371 | SYSTEM_CONFIG_END |
| 290 | 372 | |
| 291 | 373 | /* System Drivers */ |
| 292 | 374 | |
| 293 | 375 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT CONFIG COMPANY FULLNAME FLAGS */ |
| 294 | | COMP( 1978, elf2, 0, 0, elf2, elf2, 0, elf2, "Netronics", "Elf-II", GAME_NOT_WORKING ) |
| 376 | COMP( 1978, elf2, 0, 0, elf2, elf2, 0, elf2, "Netronics", "Elf II", GAME_NOT_WORKING ) |