src/emu/cpu/cdp1802/cdp1802.c
| r5252 | r5253 | |
| 29 | 29 | const address_space *program; |
| 30 | 30 | const address_space *io; |
| 31 | 31 | |
| 32 | devcb_resolved_write_line out_q_func; |
| 33 | devcb_resolved_read8 in_dma_func; |
| 34 | devcb_resolved_write8 out_dma_func; |
| 35 | |
| 32 | 36 | /* registers */ |
| 33 | 37 | UINT8 d; /* data register (accumulator) */ |
| 34 | 38 | int df; /* data flag (ALU carry) */ |
| r5252 | r5253 | |
| 549 | 553 | case 0xa: |
| 550 | 554 | Q = 0; |
| 551 | 555 | |
| 552 | | if (cpustate->intf->q_w) |
| 553 | | { |
| 554 | | cpustate->intf->q_w(device, Q); |
| 555 | | } |
| 556 | devcb_call_write_line(&cpustate->out_q_func, Q); |
| 556 | 557 | break; |
| 557 | 558 | |
| 558 | 559 | case 0xb: |
| 559 | 560 | Q = 1; |
| 560 | 561 | |
| 561 | | if (cpustate->intf->q_w) |
| 562 | | { |
| 563 | | cpustate->intf->q_w(device, Q); |
| 564 | | } |
| 562 | devcb_call_write_line(&cpustate->out_q_func, Q); |
| 565 | 563 | break; |
| 566 | 564 | |
| 567 | 565 | case 0xc: |
| r5252 | r5253 | |
| 791 | 789 | |
| 792 | 790 | case CDP1802_STATE_2_DMA_IN: |
| 793 | 791 | |
| 794 | | if (cpustate->intf->dma_r) |
| 795 | | { |
| 796 | | RAM_W(R[0], cpustate->intf->dma_r(device, R[0])); |
| 797 | | } |
| 792 | RAM_W(R[0], devcb_call_read8(&cpustate->in_dma_func, R[0])); |
| 798 | 793 | |
| 799 | 794 | R[0] = R[0] + 1; |
| 800 | 795 | |
| r5252 | r5253 | |
| 824 | 819 | |
| 825 | 820 | case CDP1802_STATE_2_DMA_OUT: |
| 826 | 821 | |
| 827 | | if (cpustate->intf->dma_w) |
| 828 | | { |
| 829 | | cpustate->intf->dma_w(device, R[0], RAM_R(R[0])); |
| 830 | | } |
| 822 | devcb_call_write8(&cpustate->out_dma_func, R[0], RAM_R(R[0])); |
| 831 | 823 | |
| 832 | 824 | R[0] = R[0] + 1; |
| 833 | 825 | |
| r5252 | r5253 | |
| 954 | 946 | |
| 955 | 947 | cpustate->intf = (cdp1802_interface *) device->static_config; |
| 956 | 948 | |
| 957 | | /* set up the state table */ |
| 949 | /* resolve callbacks */ |
| 950 | devcb_resolve_write_line(&cpustate->out_q_func, &cpustate->intf->out_q_func, device); |
| 951 | devcb_resolve_read8(&cpustate->in_dma_func, &cpustate->intf->in_dma_func, device); |
| 952 | devcb_resolve_write8(&cpustate->out_dma_func, &cpustate->intf->out_dma_func, device); |
| 958 | 953 | |
| 954 | /* set up the state table */ |
| 959 | 955 | cpustate->state_table = state_table_template; |
| 960 | 956 | cpustate->state_table.baseptr = cpustate; |
| 961 | 957 | cpustate->state_table.subtypemask = 1; |
| 962 | 958 | |
| 963 | 959 | /* find address spaces */ |
| 964 | | |
| 965 | 960 | cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM); |
| 966 | 961 | cpustate->io = memory_find_address_space(device, ADDRESS_SPACE_IO); |
| 967 | 962 | |
| 968 | 963 | /* set initial values */ |
| 969 | | |
| 970 | 964 | cpustate->p = mame_rand(device->machine) & 0x0f; |
| 971 | 965 | cpustate->x = mame_rand(device->machine) & 0x0f; |
| 972 | 966 | cpustate->d = mame_rand(device->machine); |
| r5252 | r5253 | |
| 987 | 981 | cpustate->dmaout = CLEAR_LINE; |
| 988 | 982 | |
| 989 | 983 | /* register for state saving */ |
| 990 | | |
| 991 | 984 | state_save_register_device_item(device, 0, cpustate->p); |
| 992 | 985 | state_save_register_device_item(device, 0, cpustate->x); |
| 993 | 986 | state_save_register_device_item(device, 0, cpustate->d); |
src/emu/cpu/cdp1802/cdp1802.h
| r5252 | r5253 | |
| 18 | 18 | */ |
| 19 | 19 | |
| 20 | 20 | #include "cpuintrf.h" |
| 21 | #include "devcb.h" |
| 21 | 22 | |
| 22 | 23 | enum |
| 23 | 24 | { |
| r5252 | r5253 | |
| 70 | 71 | typedef void (*cdp1802_sc_write_func)(const device_config *device, cdp1802_state_code state); |
| 71 | 72 | #define CDP1802_SC_WRITE(name) void name(const device_config *device, cdp1802_state_code state) |
| 72 | 73 | |
| 73 | | typedef void (*cdp1802_q_write_func)(const device_config *device, int level); |
| 74 | | #define CDP1802_Q_WRITE(name) void name(const device_config *device, int level) |
| 75 | | |
| 76 | | typedef UINT8 (*cdp1802_dma_read_func)(const device_config *device, UINT16 ma); |
| 77 | | #define CDP1802_DMA_READ(name) UINT8 name(const device_config *device, UINT16 ma) |
| 78 | | |
| 79 | | typedef void (*cdp1802_dma_write_func)(const device_config *device, UINT16 ma, UINT8 data); |
| 80 | | #define CDP1802_DMA_WRITE(name) void name(const device_config *device, UINT16 ma, UINT8 data) |
| 81 | | |
| 82 | 74 | /* interface */ |
| 83 | 75 | typedef struct _cdp1802_interface cdp1802_interface; |
| 84 | 76 | struct _cdp1802_interface |
| r5252 | r5253 | |
| 93 | 85 | cdp1802_sc_write_func sc_w; |
| 94 | 86 | |
| 95 | 87 | /* if specified, this gets called for every change of the Q pin (pin 4) */ |
| 96 | | cdp1802_q_write_func q_w; |
| 88 | devcb_write_line out_q_func; |
| 97 | 89 | |
| 98 | 90 | /* if specified, this gets called for every DMA read */ |
| 99 | | cdp1802_dma_read_func dma_r; |
| 91 | devcb_read8 in_dma_func; |
| 100 | 92 | |
| 101 | 93 | /* if specified, this gets called for every DMA write */ |
| 102 | | cdp1802_dma_write_func dma_w; |
| 94 | devcb_write8 out_dma_func; |
| 103 | 95 | }; |
| 104 | 96 | #define CDP1802_INTERFACE(name) const cdp1802_interface (name) = |
| 105 | 97 | |
src/mess/drivers/vip.c
| r5252 | r5253 | |
| 505 | 505 | return flags; |
| 506 | 506 | } |
| 507 | 507 | |
| 508 | | static CDP1802_Q_WRITE( vip_q_w ) |
| 508 | static WRITE_LINE_DEVICE_HANDLER( vip_q_w ) |
| 509 | 509 | { |
| 510 | 510 | const device_config *discrete = devtag_get_device(device->machine, "discrete"); |
| 511 | | vip_state *state = device->machine->driver_data; |
| 511 | vip_state *driver_state = device->machine->driver_data; |
| 512 | 512 | |
| 513 | 513 | /* sound output */ |
| 514 | | discrete_sound_w(discrete, NODE_01, level); |
| 514 | discrete_sound_w(discrete, NODE_01, state); |
| 515 | 515 | |
| 516 | 516 | if (input_port_read(device->machine, "SOUND") == VIP_SOUND_CDP1863) |
| 517 | 517 | { |
| 518 | 518 | /* CDP1863 output enable */ |
| 519 | | cdp1863_oe_w(state->cdp1863, level); |
| 519 | cdp1863_oe_w(driver_state->cdp1863, state); |
| 520 | 520 | } |
| 521 | 521 | |
| 522 | 522 | /* Q led */ |
| 523 | | set_led_status(VIP_LED_Q, level); |
| 523 | set_led_status(VIP_LED_Q, state); |
| 524 | 524 | |
| 525 | 525 | /* tape output */ |
| 526 | | cassette_output(state->cassette, level ? 1.0 : -1.0); |
| 526 | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 527 | 527 | } |
| 528 | 528 | |
| 529 | | static CDP1802_DMA_WRITE( vip_dma_w ) |
| 529 | static WRITE8_DEVICE_HANDLER( vip_dma_w ) |
| 530 | 530 | { |
| 531 | 531 | vip_state *state = device->machine->driver_data; |
| 532 | 532 | |
| r5252 | r5253 | |
| 538 | 538 | |
| 539 | 539 | case VIP_VIDEO_CDP1862: |
| 540 | 540 | { |
| 541 | | UINT8 color = state->colorram[ma & 0xff]; |
| 541 | UINT8 color = state->colorram[offset & 0xff]; |
| 542 | 542 | |
| 543 | 543 | int rdata = BIT(color, 0); |
| 544 | 544 | int gdata = BIT(color, 2); |
| r5252 | r5253 | |
| 555 | 555 | vip_mode_r, |
| 556 | 556 | vip_ef_r, |
| 557 | 557 | NULL, |
| 558 | | vip_q_w, |
| 559 | | NULL, |
| 560 | | vip_dma_w |
| 558 | DEVCB_LINE(vip_q_w), |
| 559 | DEVCB_NULL, |
| 560 | DEVCB_HANDLER(vip_dma_w) |
| 561 | 561 | }; |
| 562 | 562 | |
| 563 | 563 | /* Machine Initialization */ |
src/mess/drivers/studio2.c
| r5252 | r5253 | |
| 372 | 372 | return ef; |
| 373 | 373 | } |
| 374 | 374 | |
| 375 | | static CDP1802_Q_WRITE( studio2_q_w ) |
| 375 | static WRITE_LINE_DEVICE_HANDLER( studio2_q_w ) |
| 376 | 376 | { |
| 377 | 377 | const device_config *speaker = devtag_get_device(device->machine, "beep"); |
| 378 | | beep_set_state(speaker, level); |
| 378 | beep_set_state(speaker, state); |
| 379 | 379 | } |
| 380 | 380 | |
| 381 | | static CDP1802_DMA_WRITE( studio2_dma_w ) |
| 381 | static WRITE8_DEVICE_HANDLER( studio2_dma_w ) |
| 382 | 382 | { |
| 383 | 383 | studio2_state *state = device->machine->driver_data; |
| 384 | 384 | |
| r5252 | r5253 | |
| 390 | 390 | studio2_mode_r, |
| 391 | 391 | studio2_ef_r, |
| 392 | 392 | NULL, |
| 393 | | studio2_q_w, |
| 394 | | NULL, |
| 395 | | studio2_dma_w |
| 393 | DEVCB_LINE(studio2_q_w), |
| 394 | DEVCB_NULL, |
| 395 | DEVCB_HANDLER(studio2_dma_w) |
| 396 | 396 | }; |
| 397 | 397 | |
| 398 | 398 | static CDP1802_EF_READ( mpt02_ef_r ) |
| r5252 | r5253 | |
| 409 | 409 | return ef; |
| 410 | 410 | } |
| 411 | 411 | |
| 412 | | static CDP1802_DMA_WRITE( mpt02_dma_w ) |
| 412 | static WRITE8_DEVICE_HANDLER( mpt02_dma_w ) |
| 413 | 413 | { |
| 414 | 414 | studio2_state *state = device->machine->driver_data; |
| 415 | 415 | |
| 416 | | UINT8 color = state->color_ram[ma / 4]; // 0x04 = R, 0x02 = B, 0x01 = G |
| 416 | UINT8 color = state->color_ram[offset / 4]; // 0x04 = R, 0x02 = B, 0x01 = G |
| 417 | 417 | |
| 418 | 418 | int rdata = BIT(color, 2); |
| 419 | 419 | int gdata = BIT(color, 0); |
| r5252 | r5253 | |
| 427 | 427 | studio2_mode_r, |
| 428 | 428 | mpt02_ef_r, |
| 429 | 429 | NULL, |
| 430 | | studio2_q_w, |
| 431 | | NULL, |
| 432 | | mpt02_dma_w |
| 430 | DEVCB_LINE(studio2_q_w), |
| 431 | DEVCB_NULL, |
| 432 | DEVCB_HANDLER(mpt02_dma_w) |
| 433 | 433 | }; |
| 434 | 434 | |
| 435 | 435 | /* Machine Initialization */ |
src/mess/drivers/tmc1800.c
| r5252 | r5253 | |
| 485 | 485 | return flags; |
| 486 | 486 | } |
| 487 | 487 | |
| 488 | | static CDP1802_Q_WRITE( tmc1800_q_w ) |
| 488 | static WRITE_LINE_DEVICE_HANDLER( tmc1800_q_w ) |
| 489 | 489 | { |
| 490 | | tmc1800_state *state = device->machine->driver_data; |
| 490 | tmc1800_state *driver_state = device->machine->driver_data; |
| 491 | 491 | |
| 492 | 492 | /* tape output */ |
| 493 | | cassette_output(state->cassette, level ? 1.0 : -1.0); |
| 493 | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 494 | 494 | } |
| 495 | 495 | |
| 496 | | static CDP1802_DMA_WRITE( tmc1800_dma_w ) |
| 496 | static WRITE8_DEVICE_HANDLER( tmc1800_dma_w ) |
| 497 | 497 | { |
| 498 | 498 | tmc1800_state *state = device->machine->driver_data; |
| 499 | 499 | |
| r5252 | r5253 | |
| 505 | 505 | tmc1800_mode_r, |
| 506 | 506 | tmc1800_ef_r, |
| 507 | 507 | NULL, |
| 508 | | tmc1800_q_w, |
| 509 | | NULL, |
| 510 | | tmc1800_dma_w |
| 508 | DEVCB_LINE(tmc1800_q_w), |
| 509 | DEVCB_NULL, |
| 510 | DEVCB_HANDLER(tmc1800_dma_w) |
| 511 | 511 | }; |
| 512 | 512 | |
| 513 | 513 | static CDP1802_INTERFACE( osc1000b_config ) |
| r5252 | r5253 | |
| 515 | 515 | tmc1800_mode_r, |
| 516 | 516 | tmc1800_ef_r, |
| 517 | 517 | NULL, |
| 518 | | tmc1800_q_w, |
| 519 | | NULL, |
| 520 | | NULL |
| 518 | DEVCB_LINE(tmc1800_q_w), |
| 519 | DEVCB_NULL, |
| 520 | DEVCB_NULL |
| 521 | 521 | }; |
| 522 | 522 | |
| 523 | 523 | // Telmac 2000 |
| r5252 | r5253 | |
| 572 | 572 | return flags; |
| 573 | 573 | } |
| 574 | 574 | |
| 575 | | static CDP1802_Q_WRITE( tmc2000_q_w ) |
| 575 | static WRITE_LINE_DEVICE_HANDLER( tmc2000_q_w ) |
| 576 | 576 | { |
| 577 | | tmc2000_state *state = device->machine->driver_data; |
| 577 | tmc2000_state *driver_state = device->machine->driver_data; |
| 578 | 578 | |
| 579 | 579 | /* CDP1864 audio output enable */ |
| 580 | | cdp1864_aoe_w(state->cdp1864, level); |
| 580 | cdp1864_aoe_w(driver_state->cdp1864, state); |
| 581 | 581 | |
| 582 | 582 | /* set Q led status */ |
| 583 | | set_led_status(1, level); |
| 583 | set_led_status(1, state); |
| 584 | 584 | |
| 585 | 585 | /* tape output */ |
| 586 | | cassette_output(state->cassette, level ? 1.0 : -1.0); |
| 586 | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 587 | 587 | } |
| 588 | 588 | |
| 589 | | static CDP1802_DMA_WRITE( tmc2000_dma_w ) |
| 589 | static WRITE8_DEVICE_HANDLER( tmc2000_dma_w ) |
| 590 | 590 | { |
| 591 | 591 | tmc2000_state *state = device->machine->driver_data; |
| 592 | 592 | |
| 593 | | UINT8 color = ~(state->colorram[ma & 0x1ff]) & 0x07; |
| 593 | UINT8 color = ~(state->colorram[offset & 0x1ff]) & 0x07; |
| 594 | 594 | |
| 595 | 595 | int rdata = BIT(color, 2); |
| 596 | 596 | int gdata = BIT(color, 0); |
| r5252 | r5253 | |
| 604 | 604 | tmc2000_mode_r, |
| 605 | 605 | tmc2000_ef_r, |
| 606 | 606 | NULL, |
| 607 | | tmc2000_q_w, |
| 608 | | NULL, |
| 609 | | tmc2000_dma_w |
| 607 | DEVCB_LINE(tmc2000_q_w), |
| 608 | DEVCB_NULL, |
| 609 | DEVCB_HANDLER(tmc2000_dma_w) |
| 610 | 610 | }; |
| 611 | 611 | |
| 612 | 612 | // OSCOM Nano |
| r5252 | r5253 | |
| 688 | 688 | return flags; |
| 689 | 689 | } |
| 690 | 690 | |
| 691 | | static CDP1802_Q_WRITE( oscnano_q_w ) |
| 691 | static WRITE_LINE_DEVICE_HANDLER( oscnano_q_w ) |
| 692 | 692 | { |
| 693 | | oscnano_state *state = device->machine->driver_data; |
| 693 | oscnano_state *driver_state = device->machine->driver_data; |
| 694 | 694 | |
| 695 | 695 | /* CDP1864 audio output enable */ |
| 696 | | cdp1864_aoe_w(state->cdp1864, level); |
| 696 | cdp1864_aoe_w(driver_state->cdp1864, state); |
| 697 | 697 | |
| 698 | 698 | /* set Q led status */ |
| 699 | | set_led_status(1, level); |
| 699 | set_led_status(1, state); |
| 700 | 700 | |
| 701 | 701 | /* tape output */ |
| 702 | | cassette_output(state->cassette, level ? 1.0 : -1.0); |
| 702 | cassette_output(driver_state->cassette, state ? 1.0 : -1.0); |
| 703 | 703 | } |
| 704 | 704 | |
| 705 | | static CDP1802_DMA_WRITE( oscnano_dma_w ) |
| 705 | static WRITE8_DEVICE_HANDLER( oscnano_dma_w ) |
| 706 | 706 | { |
| 707 | 707 | oscnano_state *state = device->machine->driver_data; |
| 708 | 708 | |
| r5252 | r5253 | |
| 714 | 714 | oscnano_mode_r, |
| 715 | 715 | oscnano_ef_r, |
| 716 | 716 | NULL, |
| 717 | | oscnano_q_w, |
| 718 | | NULL, |
| 719 | | oscnano_dma_w |
| 717 | DEVCB_LINE(oscnano_q_w), |
| 718 | DEVCB_NULL, |
| 719 | DEVCB_HANDLER(oscnano_dma_w) |
| 720 | 720 | }; |
| 721 | 721 | |
| 722 | 722 | /* Machine Initialization */ |
src/mess/drivers/comx35.c
| r5252 | r5253 | |
| 236 | 236 | if (!state->cdp1871_efxa) flags -= EF3; |
| 237 | 237 | |
| 238 | 238 | // cassette input, expansion device flag |
| 239 | | if ((cassette_input(state->cassette) < +0.0) || !state->cdp1802_ef4) flags -= EF4; |
| 239 | if ((state->cassette && (cassette_input(state->cassette) < +0.0)) || !state->cdp1802_ef4) flags -= EF4; |
| 240 | 240 | |
| 241 | 241 | return flags; |
| 242 | 242 | } |
| r5252 | r5253 | |
| 280 | 280 | } |
| 281 | 281 | } |
| 282 | 282 | |
| 283 | | static CDP1802_Q_WRITE( comx35_q_w ) |
| 283 | static WRITE_LINE_DEVICE_HANDLER( comx35_q_w ) |
| 284 | 284 | { |
| 285 | | comx35_state *state = device->machine->driver_data; |
| 285 | comx35_state *driver_state = device->machine->driver_data; |
| 286 | 286 | |
| 287 | | state->cdp1802_q = level; |
| 287 | driver_state->cdp1802_q = state; |
| 288 | 288 | |
| 289 | | if (state->iden && level) |
| 289 | if (driver_state->iden && state) |
| 290 | 290 | { |
| 291 | 291 | // enable interrupts |
| 292 | | state->iden = 0; |
| 292 | driver_state->iden = 0; |
| 293 | 293 | } |
| 294 | 294 | |
| 295 | 295 | // cassette output |
| 296 | | cassette_output(state->cassette, level ? +1.0 : -1.0); |
| 296 | if (driver_state->cassette) cassette_output(driver_state->cassette, state ? +1.0 : -1.0); |
| 297 | 297 | } |
| 298 | 298 | |
| 299 | 299 | static CDP1802_INTERFACE( comx35_cdp1802_config ) |
| r5252 | r5253 | |
| 301 | 301 | comx35_mode_r, |
| 302 | 302 | comx35_ef_r, |
| 303 | 303 | comx35_sc_w, |
| 304 | | comx35_q_w, |
| 305 | | NULL, |
| 306 | | NULL |
| 304 | DEVCB_LINE(comx35_q_w), |
| 305 | DEVCB_NULL, |
| 306 | DEVCB_NULL |
| 307 | 307 | }; |
| 308 | 308 | |
| 309 | 309 | /* CDP1871 Interface */ |
src/mess/drivers/tmc2000e.c
| r5252 | r5253 | |
| 198 | 198 | return flags; |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | | static CDP1802_Q_WRITE( tmc2000e_q_w ) |
| 201 | static WRITE_LINE_DEVICE_HANDLER( tmc2000e_q_w ) |
| 202 | 202 | { |
| 203 | | tmc2000e_state *state = device->machine->driver_data; |
| 203 | tmc2000e_state *driver_state = device->machine->driver_data; |
| 204 | 204 | |
| 205 | 205 | // turn CDP1864 sound generator on/off |
| 206 | 206 | |
| 207 | | cdp1864_aoe_w(state->cdp1864, level); |
| 207 | cdp1864_aoe_w(driver_state->cdp1864, state); |
| 208 | 208 | |
| 209 | 209 | // set Q led status |
| 210 | 210 | |
| 211 | | set_led_status(1, level); |
| 211 | set_led_status(1, state); |
| 212 | 212 | |
| 213 | 213 | // tape out |
| 214 | 214 | |
| 215 | | cassette_output(state->cassette, level ? -1.0 : +1.0); |
| 215 | cassette_output(driver_state->cassette, state ? -1.0 : +1.0); |
| 216 | 216 | |
| 217 | 217 | // floppy control (FDC-6) |
| 218 | 218 | } |
| 219 | 219 | |
| 220 | | static CDP1802_DMA_WRITE( tmc2000e_dma_w ) |
| 220 | static WRITE8_DEVICE_HANDLER( tmc2000e_dma_w ) |
| 221 | 221 | { |
| 222 | 222 | tmc2000e_state *state = device->machine->driver_data; |
| 223 | 223 | |
| 224 | | UINT8 color = (state->colorram[ma & 0x3ff]) & 0x07; // 0x04 = R, 0x02 = B, 0x01 = G |
| 224 | UINT8 color = (state->colorram[offset & 0x3ff]) & 0x07; // 0x04 = R, 0x02 = B, 0x01 = G |
| 225 | 225 | |
| 226 | 226 | int rdata = BIT(color, 2); |
| 227 | 227 | int gdata = BIT(color, 0); |
| r5252 | r5253 | |
| 235 | 235 | tmc2000e_mode_r, |
| 236 | 236 | tmc2000e_ef_r, |
| 237 | 237 | NULL, |
| 238 | | tmc2000e_q_w, |
| 239 | | NULL, |
| 240 | | tmc2000e_dma_w |
| 238 | DEVCB_LINE(tmc2000e_q_w), |
| 239 | DEVCB_NULL, |
| 240 | DEVCB_HANDLER(tmc2000e_dma_w) |
| 241 | 241 | }; |
| 242 | 242 | |
| 243 | 243 | /* Machine Initialization */ |