src/emu/cpu/m6502/m4510.c
| r11232 | r11233 | |
| 153 | 153 | |
| 154 | 154 | UINT8 ddr; |
| 155 | 155 | UINT8 port; |
| 156 | | m6510_port_read_func port_read; |
| 157 | | m6510_port_write_func port_write; |
| 156 | |
| 157 | devcb_resolved_read8 in_port_func; |
| 158 | devcb_resolved_write8 out_port_func; |
| 158 | 159 | }; |
| 159 | 160 | |
| 160 | 161 | INLINE m4510_Regs *get_safe_token(device_t *device) |
| r11232 | r11233 | |
| 202 | 203 | cpustate->interrupt_inhibit = 0; |
| 203 | 204 | cpustate->rdmem_id = default_rdmem_id; |
| 204 | 205 | cpustate->wrmem_id = default_wrmem_id; |
| 205 | | cpustate->port_read = NULL; |
| 206 | | cpustate->port_write = NULL; |
| 207 | 206 | cpustate->irq_callback = irqcallback; |
| 208 | 207 | cpustate->device = device; |
| 209 | 208 | cpustate->space = device->space(AS_PROGRAM); |
| r11232 | r11233 | |
| 217 | 216 | if ( intf->write_indexed_func ) |
| 218 | 217 | cpustate->wrmem_id = intf->write_indexed_func; |
| 219 | 218 | |
| 220 | | if ( intf->port_read_func ) |
| 221 | | cpustate->port_read = intf->port_read_func; |
| 222 | | |
| 223 | | if ( intf->port_write_func ) |
| 224 | | cpustate->port_write = intf->port_write_func; |
| 219 | devcb_resolve_read8(&cpustate->in_port_func, &intf->in_port_func, device); |
| 220 | devcb_resolve_write8(&cpustate->out_port_func, &intf->out_port_func, device); |
| 225 | 221 | } |
| 226 | 222 | } |
| 227 | 223 | |
| r11232 | r11233 | |
| 366 | 362 | result = cpustate->ddr; |
| 367 | 363 | break; |
| 368 | 364 | case 0x0001: /* Data Port */ |
| 369 | | if (cpustate->port_read) |
| 370 | | result = cpustate->port_read(cpustate->device, 0); |
| 365 | result = devcb_call_read8(&cpustate->in_port_func, 0); |
| 371 | 366 | result = (cpustate->ddr & cpustate->port) | (~cpustate->ddr & result); |
| 372 | 367 | break; |
| 373 | 368 | } |
| r11232 | r11233 | |
| 388 | 383 | break; |
| 389 | 384 | } |
| 390 | 385 | |
| 391 | | if (cpustate->port_write) |
| 392 | | cpustate->port_write(cpustate->device, 0, m4510_get_port(downcast<legacy_cpu_device *>(&space->device()))); |
| 386 | devcb_call_write8(&cpustate->out_port_func, 0, m4510_get_port(downcast<legacy_cpu_device *>(&space->device()))); |
| 393 | 387 | } |
| 394 | 388 | |
| 395 | 389 | static ADDRESS_MAP_START(m4510_mem, AS_PROGRAM, 8) |
src/emu/cpu/m6502/m6502.c
| r11232 | r11233 | |
| 81 | 81 | |
| 82 | 82 | UINT8 ddr; |
| 83 | 83 | UINT8 port; |
| 84 | | m6510_port_read_func port_read; |
| 85 | | m6510_port_write_func port_write; |
| 84 | |
| 85 | devcb_resolved_read8 in_port_func; |
| 86 | devcb_resolved_write8 out_port_func; |
| 86 | 87 | }; |
| 87 | 88 | |
| 88 | 89 | INLINE m6502_Regs *get_safe_token(device_t *device) |
| r11232 | r11233 | |
| 142 | 143 | cpustate->insn = insn; |
| 143 | 144 | cpustate->rdmem_id = default_rdmem_id; |
| 144 | 145 | cpustate->wrmem_id = default_wdmem_id; |
| 145 | | cpustate->port_read = NULL; |
| 146 | | cpustate->port_write = NULL; |
| 147 | 146 | |
| 148 | 147 | if ( intf ) |
| 149 | 148 | { |
| r11232 | r11233 | |
| 153 | 152 | if ( intf->write_indexed_func ) |
| 154 | 153 | cpustate->wrmem_id = intf->write_indexed_func; |
| 155 | 154 | |
| 156 | | if ( intf->port_read_func ) |
| 157 | | cpustate->port_read = intf->port_read_func; |
| 158 | | |
| 159 | | if ( intf->port_write_func ) |
| 160 | | cpustate->port_write = intf->port_write_func; |
| 155 | devcb_resolve_read8(&cpustate->in_port_func, &intf->in_port_func, device); |
| 156 | devcb_resolve_write8(&cpustate->out_port_func, &intf->out_port_func, device); |
| 161 | 157 | } |
| 162 | 158 | |
| 163 | 159 | device->save_item(NAME(cpustate->pc.w.l)); |
| r11232 | r11233 | |
| 374 | 370 | result = cpustate->ddr; |
| 375 | 371 | break; |
| 376 | 372 | case 0x0001: /* Data Port */ |
| 377 | | if (cpustate->port_read) |
| 378 | | result = cpustate->port_read( cpustate->device, cpustate->ddr ); |
| 373 | result = devcb_call_read8(&cpustate->in_port_func, cpustate->ddr); |
| 379 | 374 | result = (cpustate->ddr & cpustate->port) | (~cpustate->ddr & result); |
| 380 | 375 | break; |
| 381 | 376 | } |
| r11232 | r11233 | |
| 396 | 391 | break; |
| 397 | 392 | } |
| 398 | 393 | |
| 399 | | if (cpustate->port_write) |
| 400 | | cpustate->port_write( cpustate->device, cpustate->ddr, cpustate->port & cpustate->ddr ); |
| 394 | devcb_call_write8(&cpustate->out_port_func, cpustate->ddr, cpustate->port & cpustate->ddr); |
| 401 | 395 | } |
| 402 | 396 | |
| 403 | 397 | static ADDRESS_MAP_START(m6510_mem, AS_PROGRAM, 8) |
src/emu/cpu/m6502/m6502.h
| r11232 | r11233 | |
| 51 | 51 | positiv edge sets overflow flag */ |
| 52 | 52 | #define M6502_SET_OVERFLOW 1 |
| 53 | 53 | |
| 54 | | typedef UINT8 (*m6510_port_read_func)(device_t *device, UINT8 direction); |
| 55 | | typedef void (*m6510_port_write_func)(device_t *device, UINT8 direction, UINT8 data); |
| 56 | 54 | |
| 57 | | |
| 58 | 55 | /* Optional interface to set callbacks */ |
| 59 | 56 | typedef struct _m6502_interface m6502_interface; |
| 60 | 57 | struct _m6502_interface |
| 61 | 58 | { |
| 62 | 59 | read8_space_func read_indexed_func; |
| 63 | 60 | write8_space_func write_indexed_func; |
| 64 | | m6510_port_read_func port_read_func; |
| 65 | | m6510_port_write_func port_write_func; |
| 61 | devcb_read8 in_port_func; |
| 62 | devcb_write8 out_port_func; |
| 66 | 63 | }; |
| 67 | 64 | |
| 68 | 65 | DECLARE_LEGACY_CPU_DEVICE(M6502, m6502); |
src/mess/machine/c128.c
| r11232 | r11233 | |
| 1076 | 1076 | */ |
| 1077 | 1077 | |
| 1078 | 1078 | |
| 1079 | | void c128_m6510_port_write( device_t *device, UINT8 direction, UINT8 data ) |
| 1079 | WRITE8_DEVICE_HANDLER(c128_m6510_port_write) |
| 1080 | 1080 | { |
| 1081 | 1081 | c128_state *state = device->machine().driver_data<c128_state>(); |
| 1082 | |
| 1083 | UINT8 direction = offset; // HACK ALERT! |
| 1084 | |
| 1082 | 1085 | /* if line is marked as input then keep current value */ |
| 1083 | 1086 | data = (state->m_c64_port_data & ~direction) | (data & direction); |
| 1084 | 1087 | |
| r11232 | r11233 | |
| 1123 | 1126 | |
| 1124 | 1127 | } |
| 1125 | 1128 | |
| 1126 | | UINT8 c128_m6510_port_read( device_t *device, UINT8 direction ) |
| 1129 | READ8_DEVICE_HANDLER(c128_m6510_port_read) |
| 1127 | 1130 | { |
| 1128 | 1131 | c128_state *state = device->machine().driver_data<c128_state>(); |
| 1129 | 1132 | UINT8 data = state->m_c64_port_data; |
src/mess/machine/c16.c
| r11232 | r11233 | |
| 68 | 68 | p7 serial data in, serial bus 5 |
| 69 | 69 | */ |
| 70 | 70 | |
| 71 | | void c16_m7501_port_write( device_t *device, UINT8 direction, UINT8 data ) |
| 71 | WRITE8_DEVICE_HANDLER(c16_m7501_port_write) |
| 72 | 72 | { |
| 73 | 73 | c16_state *state = device->machine().driver_data<c16_state>(); |
| 74 | 74 | |
| r11232 | r11233 | |
| 82 | 82 | cassette_change_state(state->m_cassette, BIT(data, 7) ? CASSETTE_MOTOR_DISABLED : CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); |
| 83 | 83 | } |
| 84 | 84 | |
| 85 | | UINT8 c16_m7501_port_read( device_t *device, UINT8 direction ) |
| 85 | READ8_DEVICE_HANDLER(c16_m7501_port_read) |
| 86 | 86 | { |
| 87 | 87 | c16_state *state = device->machine().driver_data<c16_state>(); |
| 88 | 88 | UINT8 data = 0xff; |
src/mess/machine/c1551.c
| r11232 | r11233 | |
| 250 | 250 | c1551_port_r - M6510T port read |
| 251 | 251 | -------------------------------------------------*/ |
| 252 | 252 | |
| 253 | | static UINT8 c1551_port_r( device_t *device, UINT8 direction ) |
| 253 | static READ8_DEVICE_HANDLER( c1551_port_r ) |
| 254 | 254 | { |
| 255 | 255 | /* |
| 256 | 256 | |
| r11232 | r11233 | |
| 283 | 283 | c1551_port_w - M6510T port write |
| 284 | 284 | -------------------------------------------------*/ |
| 285 | 285 | |
| 286 | | static void c1551_port_w( device_t *device, UINT8 direction, UINT8 data ) |
| 286 | static WRITE8_DEVICE_HANDLER( c1551_port_w ) |
| 287 | 287 | { |
| 288 | 288 | /* |
| 289 | 289 | |
| r11232 | r11233 | |
| 326 | 326 | { |
| 327 | 327 | NULL, /* read_indexed_func */ |
| 328 | 328 | NULL, /* write_indexed_func */ |
| 329 | | c1551_port_r, /* port_read_func */ |
| 330 | | c1551_port_w /* port_write_func */ |
| 329 | DEVCB_HANDLER(c1551_port_r), /* port_read_func */ |
| 330 | DEVCB_HANDLER(c1551_port_w) /* port_write_func */ |
| 331 | 331 | }; |
| 332 | 332 | |
| 333 | 333 | /*------------------------------------------------- |
src/mess/machine/c64.c
| r11232 | r11233 | |
| 546 | 546 | p6,7 not available on M6510 |
| 547 | 547 | */ |
| 548 | 548 | |
| 549 | | void c64_m6510_port_write( device_t *device, UINT8 direction, UINT8 data ) |
| 549 | WRITE8_DEVICE_HANDLER(c64_m6510_port_write) |
| 550 | 550 | { |
| 551 | 551 | c64_state *state = device->machine().driver_data<c64_state>(); |
| 552 | |
| 553 | UINT8 direction = offset; // HACK ALERT! |
| 552 | 554 | |
| 553 | 555 | /* if line is marked as input then keep current value */ |
| 554 | 556 | data = (state->m_port_data & ~direction) | (data & direction); |
| r11232 | r11233 | |
| 595 | 597 | |
| 596 | 598 | } |
| 597 | 599 | |
| 598 | | UINT8 c64_m6510_port_read( device_t *device, UINT8 direction ) |
| 600 | READ8_DEVICE_HANDLER(c64_m6510_port_read) |
| 599 | 601 | { |
| 600 | 602 | c64_state *state = device->machine().driver_data<c64_state>(); |
| 601 | 603 | UINT8 data = state->m_port_data; |
src/mess/includes/c128.h
| r11232 | r11233 | |
| 88 | 88 | int c128_dma_read_color(running_machine &machine, int offset); |
| 89 | 89 | void c128_vic_interrupt(running_machine &machine, int level); |
| 90 | 90 | |
| 91 | | UINT8 c128_m6510_port_read(device_t *device, UINT8 direction); |
| 92 | | void c128_m6510_port_write(device_t *device, UINT8 direction, UINT8 data); |
| 91 | extern READ8_DEVICE_HANDLER(c128_m6510_port_read); |
| 92 | extern WRITE8_DEVICE_HANDLER(c128_m6510_port_write); |
| 93 | 93 | |
| 94 | 94 | extern const mos6526_interface c128_ntsc_cia0, c128_pal_cia0; |
| 95 | 95 | extern const mos6526_interface c128_ntsc_cia1, c128_pal_cia1; |
src/mess/includes/c16.h
| r11232 | r11233 | |
| 43 | 43 | |
| 44 | 44 | /*----------- defined in machine/c16.c -----------*/ |
| 45 | 45 | |
| 46 | | UINT8 c16_m7501_port_read(device_t *device, UINT8 direction); |
| 47 | | void c16_m7501_port_write(device_t *device, UINT8 direction, UINT8 data); |
| 46 | extern READ8_DEVICE_HANDLER(c16_m7501_port_read); |
| 47 | extern WRITE8_DEVICE_HANDLER(c16_m7501_port_write); |
| 48 | 48 | |
| 49 | 49 | extern WRITE8_HANDLER(c16_6551_port_w); |
| 50 | 50 | extern READ8_HANDLER(c16_6551_port_r); |
src/mess/drivers/c128.c
| r11232 | r11233 | |
| 654 | 654 | { |
| 655 | 655 | NULL, /* read_indexed_func */ |
| 656 | 656 | NULL, /* write_indexed_func */ |
| 657 | | c128_m6510_port_read, /* port_read_func */ |
| 658 | | c128_m6510_port_write, /* port_write_func */ |
| 657 | DEVCB_HANDLER(c128_m6510_port_read), /* port_read_func */ |
| 658 | DEVCB_HANDLER(c128_m6510_port_write) /* port_write_func */ |
| 659 | 659 | }; |
| 660 | 660 | |
| 661 | 661 | static CBM_IEC_DAISY( c128_iec_bus ) |
src/mess/drivers/c16.c
| r11232 | r11233 | |
| 413 | 413 | { |
| 414 | 414 | NULL, /* read_indexed_func */ |
| 415 | 415 | NULL, /* write_indexed_func */ |
| 416 | | c16_m7501_port_read, /* port_read_func */ |
| 417 | | c16_m7501_port_write /* port_write_func */ |
| 416 | DEVCB_HANDLER(c16_m7501_port_read), /* port_read_func */ |
| 417 | DEVCB_HANDLER(c16_m7501_port_write) /* port_write_func */ |
| 418 | 418 | }; |
| 419 | 419 | |
| 420 | 420 | static CBM_IEC_DAISY( c16_iec_no_drives ) |