src/mess/machine/radio86.c
| r6433 | r6434 | |
| 11 | 11 | #include "cpu/i8085/i8085.h" |
| 12 | 12 | #include "devices/cassette.h" |
| 13 | 13 | #include "machine/i8255a.h" |
| 14 | | #include "machine/8257dma.h" |
| 14 | #include "machine/i8257.h" |
| 15 | 15 | #include "video/i8275.h" |
| 16 | 16 | #include "includes/radio86.h" |
| 17 | 17 | |
| r6433 | r6434 | |
| 129 | 129 | DEVCB_HANDLER(radio86_8255_portc_w2), |
| 130 | 130 | }; |
| 131 | 131 | |
| 132 | static WRITE_LINE_DEVICE_HANDLER( hrq_w ) |
| 133 | { |
| 134 | /* HACK - this should be connected to the BUSREQ line of Z80 */ |
| 135 | cputag_set_input_line(device->machine, "maincpu", INPUT_LINE_HALT, state); |
| 136 | |
| 137 | /* HACK - this should be connected to the BUSACK line of Z80 */ |
| 138 | i8257_hlda_w(device, state); |
| 139 | } |
| 140 | |
| 132 | 141 | I8257_INTERFACE( radio86_dma ) |
| 133 | 142 | { |
| 134 | | DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_HALT), |
| 143 | DEVCB_LINE(hrq_w), |
| 135 | 144 | DEVCB_NULL, |
| 136 | 145 | DEVCB_NULL, |
| 137 | | DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte), |
| 138 | | DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte), |
| 146 | I8257_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte), |
| 147 | I8257_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte), |
| 139 | 148 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }, |
| 140 | 149 | { DEVCB_NULL, DEVCB_NULL, DEVCB_DEVICE_HANDLER("i8275", i8275_dack_w), DEVCB_NULL }, |
| 150 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL } |
| 141 | 151 | }; |
| 142 | 152 | |
| 143 | 153 | static TIMER_CALLBACK( radio86_reset ) |
src/mess/machine/partner.c
| r6433 | r6434 | |
| 11 | 11 | #include "cpu/i8085/i8085.h" |
| 12 | 12 | #include "devices/cassette.h" |
| 13 | 13 | #include "machine/i8255a.h" |
| 14 | | #include "machine/8257dma.h" |
| 14 | #include "machine/i8257.h" |
| 15 | 15 | #include "machine/wd17xx.h" |
| 16 | 16 | #include "video/i8275.h" |
| 17 | 17 | #include "includes/radio86.h" |
| r6433 | r6434 | |
| 345 | 345 | partner_bank_switch(space->machine); |
| 346 | 346 | } |
| 347 | 347 | |
| 348 | static WRITE_LINE_DEVICE_HANDLER( hrq_w ) |
| 349 | { |
| 350 | /* HACK - this should be connected to the BUSREQ line of Z80 */ |
| 351 | cputag_set_input_line(device->machine, "maincpu", INPUT_LINE_HALT, state); |
| 352 | |
| 353 | /* HACK - this should be connected to the BUSACK line of Z80 */ |
| 354 | i8257_hlda_w(device, state); |
| 355 | } |
| 356 | |
| 348 | 357 | I8257_INTERFACE( partner_dma ) |
| 349 | 358 | { |
| 350 | | DEVCB_CPU_INPUT_LINE("maincpu", INPUT_LINE_HALT), |
| 359 | DEVCB_LINE(hrq_w), |
| 351 | 360 | DEVCB_NULL, |
| 352 | 361 | DEVCB_NULL, |
| 353 | | DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte), |
| 354 | | DEVCB_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte), |
| 362 | I8257_MEMORY_HANDLER("maincpu", PROGRAM, memory_read_byte), |
| 363 | I8257_MEMORY_HANDLER("maincpu", PROGRAM, memory_write_byte), |
| 355 | 364 | { DEVCB_DEVICE_HANDLER("wd1793", wd17xx_data_r), DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }, |
| 356 | | { DEVCB_DEVICE_HANDLER("wd1793", wd17xx_data_w), DEVCB_NULL, DEVCB_DEVICE_HANDLER("i8275", i8275_dack_w), DEVCB_NULL } |
| 365 | { DEVCB_DEVICE_HANDLER("wd1793", wd17xx_data_w), DEVCB_NULL, DEVCB_DEVICE_HANDLER("i8275", i8275_dack_w), DEVCB_NULL }, |
| 366 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL } |
| 357 | 367 | }; |
| 358 | 368 | |
| 359 | 369 | |
src/mess/machine/i8257.c
| r6433 | r6434 | |
| 2 | 2 | |
| 3 | 3 | Intel 8257 Programmable DMA Controller emulation
|
| 4 | 4 | |
| 5 | | Copyright Nicola Salmoria and the MAME Team.
|
| 5 | Copyright MESS Team.
|
| 6 | 6 | Visit http://mamedev.org for licensing and usage restrictions.
|
| 7 | 7 | |
| 8 | 8 | ***************************************************************************/
|
| 9 | 9 | |
| 10 | /*
|
| 11 | |
| 12 | TODO:
|
| 13 | |
| 14 | - use cr/ar directly
|
| 15 | |
| 16 | */
|
| 17 | |
| 10 | 18 | #include "driver.h"
|
| 11 | 19 | #include "i8257.h"
|
| 12 | 20 | |
| r6433 | r6434 | |
| 61 | 69 | devcb_resolved_write_line out_hrq_func;
|
| 62 | 70 | devcb_resolved_write_line out_tc_func;
|
| 63 | 71 | devcb_resolved_write_line out_mark_func;
|
| 64 | | devcb_resolved_read8 in_memr_func;
|
| 65 | | devcb_resolved_write8 out_memw_func;
|
| 66 | | devcb_resolved_read8 in_ior_func;
|
| 67 | | devcb_resolved_write8 out_iow_func;
|
| 68 | | devcb_resolved_write_line out_dack_func[4];
|
| 72 | devcb_resolved_read8 in_memr_func[I8257_CHANNELS];
|
| 73 | devcb_resolved_write8 out_memw_func[I8257_CHANNELS];
|
| 74 | devcb_resolved_read8 in_ior_func[I8257_CHANNELS];
|
| 75 | devcb_resolved_write8 out_iow_func[I8257_CHANNELS];
|
| 76 | devcb_resolved_write_line out_dack_func[I8257_CHANNELS];
|
| 69 | 77 | |
| 70 | 78 | /* registers */
|
| 71 | 79 | UINT8 mr; /* mode register */
|
| 72 | 80 | UINT8 sr; /* status register */
|
| 73 | | UINT16 ar[4]; /* address register */
|
| 74 | | UINT16 cr[4]; /* count register */
|
| 81 | UINT16 ar[I8257_CHANNELS]; /* address register */
|
| 82 | UINT16 cr[I8257_CHANNELS]; /* count register */
|
| 75 | 83 | int fl; /* first/last flip-flop */
|
| 76 | 84 | |
| 77 | 85 | /* inputs */
|
| 78 | | int drq[4]; /* data request */
|
| 86 | int drq[I8257_CHANNELS]; /* data request */
|
| 79 | 87 | int hlda; /* hold acknowledge */
|
| 80 | 88 | int ready; /* ready */
|
| 81 | 89 | |
| r6433 | r6434 | |
| 157 | 165 | i8257_t *i8257 = get_safe_token(device);
|
| 158 | 166 | int ch;
|
| 159 | 167 | |
| 160 | | for (ch = 0; ch < 4; ch++)
|
| 168 | for (ch = 0; ch < I8257_CHANNELS; ch++)
|
| 161 | 169 | {
|
| 162 | 170 | int state = (ch != active_channel);
|
| 163 | 171 | |
| r6433 | r6434 | |
| 172 | 180 | i8257_t *i8257 = get_safe_token(device);
|
| 173 | 181 | int ch;
|
| 174 | 182 | |
| 175 | | for (ch = 0; ch < 4; ch++)
|
| 183 | for (ch = 0; ch < I8257_CHANNELS; ch++)
|
| 176 | 184 | {
|
| 177 | 185 | if (i8257->drq[ch] && BIT(i8257->mr, ch))
|
| 178 | 186 | {
|
| r6433 | r6434 | |
| 188 | 196 | i8257_t *i8257 = get_safe_token(device);
|
| 189 | 197 | int i;
|
| 190 | 198 | |
| 191 | | for (i = 0; i < 4; i++)
|
| 199 | for (i = 0; i < I8257_CHANNELS; i++)
|
| 192 | 200 | {
|
| 193 | | int ch = (i + i8257->priority) % 4;
|
| 201 | int ch = (i + i8257->priority) % I8257_CHANNELS;
|
| 194 | 202 | |
| 195 | 203 | if (i8257->drq[ch] && BIT(i8257->mr, ch))
|
| 196 | 204 | {
|
| r6433 | r6434 | |
| 213 | 221 | break;
|
| 214 | 222 | |
| 215 | 223 | case MODE_WRITE:
|
| 216 | | i8257->data = devcb_call_read8(&i8257->in_memr_func, i8257->address);
|
| 224 | i8257->data = devcb_call_read8(&i8257->in_memr_func[i8257->channel], i8257->address);
|
| 217 | 225 | if (LOG) logerror("I8257 '%s' DMA Memory Read %04x: %02x\n", device->tag, i8257->address, i8257->data);
|
| 218 | 226 | break;
|
| 219 | 227 | |
| 220 | 228 | case MODE_READ:
|
| 221 | | i8257->data = devcb_call_read8(&i8257->in_ior_func, i8257->address);
|
| 229 | i8257->data = devcb_call_read8(&i8257->in_ior_func[i8257->channel], i8257->address);
|
| 222 | 230 | if (LOG) logerror("I8257 '%s' DMA I/O Read %04x: %02x\n", device->tag, i8257->address, i8257->data);
|
| 223 | 231 | break;
|
| 224 | 232 | |
| r6433 | r6434 | |
| 237 | 245 | break;
|
| 238 | 246 | |
| 239 | 247 | case MODE_WRITE:
|
| 240 | | devcb_call_write8(&i8257->out_iow_func, i8257->address, i8257->data);
|
| 248 | devcb_call_write8(&i8257->out_iow_func[i8257->channel], i8257->address, i8257->data);
|
| 241 | 249 | if (LOG) logerror("I8257 '%s' DMA I/O Write %04x: %02x\n", device->tag, i8257->address, i8257->data);
|
| 242 | 250 | break;
|
| 243 | 251 | |
| 244 | 252 | case MODE_READ:
|
| 245 | | devcb_call_write8(&i8257->out_memw_func, i8257->address, i8257->data);
|
| 253 | devcb_call_write8(&i8257->out_memw_func[i8257->channel], i8257->address, i8257->data);
|
| 246 | 254 | if (LOG) logerror("I8257 '%s' DMA Memory Write %04x: %02x\n", device->tag, i8257->address, i8257->data);
|
| 247 | 255 | break;
|
| 248 | 256 | |
| r6433 | r6434 | |
| 310 | 318 | |
| 311 | 319 | case STATE_S3:
|
| 312 | 320 | /* activate write command */
|
| 313 | | dma_write(device);
|
| 321 | if (!(i8257->mr & I8257_MODE_EW))
|
| 322 | {
|
| 323 | dma_write(device);
|
| 324 | }
|
| 314 | 325 | |
| 315 | 326 | i8257->address++;
|
| 316 | 327 | i8257->count--;
|
| r6433 | r6434 | |
| 365 | 376 | i8257->ar[2] = i8257->ar[3];
|
| 366 | 377 | i8257->cr[2] = i8257->cr[3];
|
| 367 | 378 | |
| 379 | if (LOG)
|
| 380 | {
|
| 381 | logerror("I8257 '%s' DMA Channel 2 Address Register: %04x\n", device->tag, i8257->ar[2]);
|
| 382 | logerror("I8257 '%s' DMA Channel 2 Count Register: %04x\n", device->tag, i8257->cr[2] & 0x3fff);
|
| 383 | logerror("I8257 '%s' DMA Channel 2 Mode: %u\n", device->tag, i8257->cr[2] >> 14);
|
| 384 | }
|
| 385 | |
| 368 | 386 | i8257->state = STATE_S4;
|
| 369 | 387 | break;
|
| 370 | 388 | |
| r6433 | r6434 | |
| 377 | 395 | if ((i8257->mr & I8257_MODE_TCS) && |
| 378 | 396 | !((i8257->channel == 2) && (i8257->mr & I8257_MODE_AL)))
|
| 379 | 397 | {
|
| 380 | | i8257->mr &= (1 << i8257->channel);
|
| 398 | i8257->mr &= ~(1 << i8257->channel);
|
| 399 | if (LOG) logerror("I8257 '%s' DMA Channel %u: disabled\n", device->tag, i8257->channel);
|
| 381 | 400 | }
|
| 382 | 401 | |
| 383 | 402 | if (i8257->mr & I8257_MODE_RP)
|
| 384 | 403 | {
|
| 385 | | i8257->priority = (i8257->channel + 1) % 4;
|
| 404 | i8257->priority = (i8257->channel + 1) % I8257_CHANNELS;
|
| 386 | 405 | }
|
| 387 | 406 | |
| 388 | 407 | /* resolve DRQ priorities */
|
| r6433 | r6434 | |
| 481 | 500 | if (i8257->fl)
|
| 482 | 501 | {
|
| 483 | 502 | i8257->ar[ch] = (data << 8) | (i8257->ar[ch] & 0xff);
|
| 484 | | if (LOG) logerror("I8257 '%s' Address Register %u: %04x\n", device->tag, ch, i8257->ar[ch]);
|
| 503 | if (LOG) logerror("I8257 '%s' DMA Channel %u Address Register: %04x\n", device->tag, ch, i8257->ar[ch]);
|
| 485 | 504 | }
|
| 486 | 505 | else
|
| 487 | 506 | {
|
| r6433 | r6434 | |
| 505 | 524 | if (i8257->fl)
|
| 506 | 525 | {
|
| 507 | 526 | i8257->cr[ch] = (data << 8) | (i8257->cr[ch] & 0xff);
|
| 508 | | if (LOG) logerror("I8257 '%s' Count Register %u: %04x\n", device->tag, ch, i8257->cr[ch] & 0x3fff);
|
| 509 | | if (LOG) logerror("I8257 '%s' Mode: %u\n", device->tag, i8257->cr[ch] >> 14);
|
| 527 | if (LOG) logerror("I8257 '%s' DMA Channel %u Count Register: %04x\n", device->tag, ch, i8257->cr[ch] & 0x3fff);
|
| 528 | if (LOG) logerror("I8257 '%s' DMA Channel %u Mode: %u\n", device->tag, ch, i8257->cr[ch] >> 14);
|
| 510 | 529 | }
|
| 511 | 530 | else
|
| 512 | 531 | {
|
| r6433 | r6434 | |
| 525 | 544 | i8257->mr = data;
|
| 526 | 545 | i8257->fl = 0;
|
| 527 | 546 | |
| 547 | if ((i8257->state == STATE_SI) && sample_drq(device))
|
| 548 | {
|
| 549 | timer_enable(i8257->dma_timer, 1);
|
| 550 | }
|
| 551 | |
| 528 | 552 | if (LOG)
|
| 529 | 553 | {
|
| 530 | 554 | logerror("I8257 '%s' DMA Channel 0: %s\n", device->tag, BIT(i8257->mr, 0) ? "enabled" : "disabled");
|
| r6433 | r6434 | |
| 566 | 590 | |
| 567 | 591 | if (LOG) logerror("I8257 '%s' Data Request %u: %u\n", device->tag, ch, state);
|
| 568 | 592 | |
| 569 | | if (state)
|
| 593 | if (state && (i8257->state == STATE_SI))
|
| 570 | 594 | {
|
| 571 | 595 | timer_enable(i8257->dma_timer, 1);
|
| 572 | 596 | }
|
| r6433 | r6434 | |
| 585 | 609 | {
|
| 586 | 610 | i8257_t *i8257 = get_safe_token(device);
|
| 587 | 611 | i8257_interface *intf = (i8257_interface *)device->static_config;
|
| 612 | int ch;
|
| 588 | 613 | |
| 589 | 614 | /* resolve callbacks */
|
| 590 | 615 | devcb_resolve_write_line(&i8257->out_hrq_func, &intf->out_hrq_func, device);
|
| 591 | 616 | devcb_resolve_write_line(&i8257->out_tc_func, &intf->out_tc_func, device);
|
| 592 | 617 | devcb_resolve_write_line(&i8257->out_mark_func, &intf->out_mark_func, device);
|
| 593 | | devcb_resolve_read8(&i8257->in_memr_func, &intf->in_memr_func, device);
|
| 594 | | devcb_resolve_write8(&i8257->out_memw_func, &intf->out_memw_func, device);
|
| 595 | | devcb_resolve_read8(&i8257->in_ior_func, &intf->in_ior_func, device);
|
| 596 | | devcb_resolve_write8(&i8257->out_iow_func, &intf->out_iow_func, device);
|
| 597 | | devcb_resolve_write_line(&i8257->out_dack_func[0], &intf->out_dack_func[0], device);
|
| 598 | | devcb_resolve_write_line(&i8257->out_dack_func[1], &intf->out_dack_func[1], device);
|
| 599 | | devcb_resolve_write_line(&i8257->out_dack_func[2], &intf->out_dack_func[2], device);
|
| 600 | | devcb_resolve_write_line(&i8257->out_dack_func[3], &intf->out_dack_func[3], device);
|
| 618 |
|
| 619 | for (ch = 0; ch < I8257_CHANNELS; ch++)
|
| 620 | {
|
| 621 | devcb_resolve_read8(&i8257->in_memr_func[ch], &intf->in_memr_func[ch], device);
|
| 622 | devcb_resolve_write8(&i8257->out_memw_func[ch], &intf->out_memw_func[ch], device);
|
| 623 | devcb_resolve_read8(&i8257->in_ior_func[ch], &intf->in_ior_func[ch], device);
|
| 624 | devcb_resolve_write8(&i8257->out_iow_func[ch], &intf->out_iow_func[ch], device);
|
| 625 | devcb_resolve_write_line(&i8257->out_dack_func[ch], &intf->out_dack_func[ch], device);
|
| 626 | }
|
| 601 | 627 | |
| 602 | 628 | /* create the DMA timer */
|
| 603 | 629 | i8257->dma_timer = timer_alloc(device->machine, dma_tick, (void *)device);
|
| r6433 | r6434 | |
| 636 | 662 | i8257->sr = 0;
|
| 637 | 663 | i8257->state = STATE_SI;
|
| 638 | 664 | i8257->priority = 0;
|
| 665 | i8257->ready = 1;
|
| 639 | 666 | |
| 640 | 667 | set_hrq(device, 0);
|
| 641 | 668 | set_mark(device, 0);
|
src/mess/machine/i8257.h
| r6433 | r6434 | |
| 2 | 2 | |
| 3 | 3 | Intel 8257 Programmable DMA Controller emulation
|
| 4 | 4 | |
| 5 | | Copyright Nicola Salmoria and the MAME Team.
|
| 5 | Copyright MESS Team.
|
| 6 | 6 | Visit http://mamedev.org for licensing and usage restrictions.
|
| 7 | 7 | |
| 8 | 8 | ****************************************************************************
|
| r6433 | r6434 | |
| 48 | 48 | #define I8257_INTERFACE(_name) \
|
| 49 | 49 | const i8257_interface (_name) =
|
| 50 | 50 | |
| 51 | #define I8257_MEMORY_HANDLER(_tag, _space, _func) \
|
| 52 | { DEVCB_MEMORY_HANDLER(_tag, _space, _func), \ |
| 53 | DEVCB_MEMORY_HANDLER(_tag, _space, _func), \ |
| 54 | DEVCB_MEMORY_HANDLER(_tag, _space, _func), \ |
| 55 | DEVCB_MEMORY_HANDLER(_tag, _space, _func) } |
| 56 | |
| 57 | #define I8257_CHANNELS 4 |
| 58 | |
| 51 | 59 | /***************************************************************************
|
| 52 | 60 | TYPE DEFINITIONS
|
| 53 | 61 | ***************************************************************************/
|
| r6433 | r6434 | |
| 60 | 68 | devcb_write_line out_mark_func;
|
| 61 | 69 | |
| 62 | 70 | /* memory */
|
| 63 | | devcb_read8 in_memr_func;
|
| 64 | | devcb_write8 out_memw_func;
|
| 71 | devcb_read8 in_memr_func[I8257_CHANNELS];
|
| 72 | devcb_write8 out_memw_func[I8257_CHANNELS];
|
| 65 | 73 | |
| 66 | 74 | /* I/O */
|
| 67 | | devcb_read8 in_ior_func;
|
| 68 | | devcb_write8 out_iow_func;
|
| 75 | devcb_read8 in_ior_func[I8257_CHANNELS];
|
| 76 | devcb_write8 out_iow_func[I8257_CHANNELS];
|
| 69 | 77 | |
| 70 | 78 | /* DMA acknowledge */
|
| 71 | | devcb_write_line out_dack_func[4];
|
| 79 | devcb_write_line out_dack_func[I8257_CHANNELS];
|
| 72 | 80 | };
|
| 73 | 81 | |
| 74 | 82 | /***************************************************************************
|
src/mess/drivers/pc8001.c
| r6433 | r6434 | |
| 473 | 473 | i8257_hlda_w(device, state); |
| 474 | 474 | } |
| 475 | 475 | |
| 476 | | static WRITE8_DEVICE_HANDLER( mem_w ) |
| 477 | | { |
| 478 | | pc8001_state *driver_state = device->machine->driver_data; |
| 479 | | |
| 480 | | if (!driver_state->dack2) |
| 481 | | { |
| 482 | | upd3301_dack_w(driver_state->upd3301, 0, data); |
| 483 | | } |
| 484 | | } |
| 485 | | |
| 486 | | static WRITE_LINE_DEVICE_HANDLER( dack2_w ) |
| 487 | | { |
| 488 | | pc8001_state *driver_state = device->machine->driver_data; |
| 489 | | |
| 490 | | driver_state->dack2 = state; |
| 491 | | } |
| 492 | | |
| 493 | 476 | static I8257_INTERFACE( pc8001_8257_intf ) |
| 494 | 477 | { |
| 495 | 478 | DEVCB_LINE(hrq_w), |
| 496 | 479 | DEVCB_NULL, |
| 497 | 480 | DEVCB_NULL, |
| 498 | | DEVCB_NULL, |
| 499 | | DEVCB_HANDLER(mem_w), |
| 500 | | DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_read_byte), |
| 501 | | DEVCB_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_write_byte), |
| 502 | | { DEVCB_NULL, DEVCB_NULL, DEVCB_LINE(dack2_w), DEVCB_NULL } |
| 481 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL }, |
| 482 | { DEVCB_NULL, DEVCB_NULL, DEVCB_DEVICE_HANDLER(UPD3301_TAG, upd3301_dack_w), DEVCB_NULL }, |
| 483 | I8257_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_read_byte), |
| 484 | I8257_MEMORY_HANDLER(Z80_TAG, PROGRAM, memory_write_byte), |
| 485 | { DEVCB_NULL, DEVCB_NULL, DEVCB_NULL, DEVCB_NULL } |
| 503 | 486 | }; |
| 504 | 487 | |
| 505 | 488 | /* uPD1990A Interface */ |