trunk/src/mame/drivers/taitogn.c
| r22846 | r22847 | |
| 337 | 337 | m_znsec0(*this,"maincpu:sio0:znsec0"), |
| 338 | 338 | m_znsec1(*this,"maincpu:sio0:znsec1"), |
| 339 | 339 | m_zndip(*this,"maincpu:sio0:zndip"), |
| 340 | m_card(*this,"card"), |
| 340 | 341 | m_maincpu(*this, "maincpu"), |
| 341 | 342 | m_mn10200(*this, "mn10200") { |
| 342 | 343 | } |
| r22846 | r22847 | |
| 344 | 345 | required_device<znsec_device> m_znsec0; |
| 345 | 346 | required_device<znsec_device> m_znsec1; |
| 346 | 347 | required_device<zndip_device> m_zndip; |
| 348 | required_device<ide_controller_device> m_card; |
| 347 | 349 | |
| 348 | 350 | intel_te28f160_device *m_biosflash; |
| 349 | 351 | intel_e28f400_device *m_pgmflash; |
| r22846 | r22847 | |
| 354 | 356 | |
| 355 | 357 | unsigned char m_rf5c296_reg; |
| 356 | 358 | |
| 357 | | UINT32 m_control; |
| 358 | | UINT32 m_control2; |
| 359 | | UINT32 m_control3; |
| 359 | UINT8 m_control; |
| 360 | UINT16 m_control2; |
| 361 | UINT8 m_control3; |
| 360 | 362 | int m_v; |
| 361 | 363 | |
| 362 | | UINT32 m_n_znsecsel; |
| 364 | UINT8 m_n_znsecsel; |
| 363 | 365 | |
| 364 | | UINT32 m_coin_info; |
| 366 | UINT8 m_coin_info; |
| 365 | 367 | UINT32 m_mux_data; |
| 366 | | DECLARE_WRITE32_MEMBER(rf5c296_io_w); |
| 367 | | DECLARE_READ32_MEMBER(rf5c296_io_r); |
| 368 | | DECLARE_READ32_MEMBER(rf5c296_mem_r); |
| 369 | | DECLARE_WRITE32_MEMBER(rf5c296_mem_w); |
| 370 | | DECLARE_READ32_MEMBER(flash_subbios_r); |
| 371 | | DECLARE_WRITE32_MEMBER(flash_subbios_w); |
| 372 | | DECLARE_READ32_MEMBER(flash_mn102_r); |
| 373 | | DECLARE_WRITE32_MEMBER(flash_mn102_w); |
| 374 | | DECLARE_READ32_MEMBER(flash_s1_r); |
| 375 | | DECLARE_WRITE32_MEMBER(flash_s1_w); |
| 376 | | DECLARE_READ32_MEMBER(flash_s2_r); |
| 377 | | DECLARE_WRITE32_MEMBER(flash_s2_w); |
| 378 | | DECLARE_READ32_MEMBER(flash_s3_r); |
| 379 | | DECLARE_WRITE32_MEMBER(flash_s3_w); |
| 380 | | DECLARE_READ32_MEMBER(control_r); |
| 381 | | DECLARE_WRITE32_MEMBER(control_w); |
| 382 | | DECLARE_WRITE32_MEMBER(control2_w); |
| 383 | | DECLARE_READ32_MEMBER(control3_r); |
| 384 | | DECLARE_WRITE32_MEMBER(control3_w); |
| 385 | | DECLARE_READ32_MEMBER(gn_1fb70000_r); |
| 386 | | DECLARE_WRITE32_MEMBER(gn_1fb70000_w); |
| 387 | | DECLARE_READ32_MEMBER(hack1_r); |
| 388 | | DECLARE_READ32_MEMBER(znsecsel_r); |
| 389 | | DECLARE_WRITE32_MEMBER(znsecsel_w); |
| 390 | | DECLARE_READ32_MEMBER(boardconfig_r); |
| 391 | | DECLARE_WRITE32_MEMBER(coin_w); |
| 392 | | DECLARE_READ32_MEMBER(coin_r); |
| 393 | | DECLARE_READ32_MEMBER(gnet_mahjong_panel_r); |
| 368 | DECLARE_WRITE16_MEMBER(rf5c296_io_w); |
| 369 | DECLARE_READ16_MEMBER(rf5c296_io_r); |
| 370 | DECLARE_READ16_MEMBER(rf5c296_mem_r); |
| 371 | DECLARE_WRITE16_MEMBER(rf5c296_mem_w); |
| 372 | DECLARE_READ8_MEMBER(control_r); |
| 373 | DECLARE_WRITE8_MEMBER(control_w); |
| 374 | DECLARE_WRITE16_MEMBER(control2_w); |
| 375 | DECLARE_READ8_MEMBER(control3_r); |
| 376 | DECLARE_WRITE8_MEMBER(control3_w); |
| 377 | DECLARE_READ16_MEMBER(gn_1fb70000_r); |
| 378 | DECLARE_WRITE16_MEMBER(gn_1fb70000_w); |
| 379 | DECLARE_READ16_MEMBER(hack1_r); |
| 380 | DECLARE_READ8_MEMBER(znsecsel_r); |
| 381 | DECLARE_WRITE8_MEMBER(znsecsel_w); |
| 382 | DECLARE_READ8_MEMBER(boardconfig_r); |
| 383 | DECLARE_WRITE8_MEMBER(coin_w); |
| 384 | DECLARE_READ8_MEMBER(coin_r); |
| 385 | DECLARE_READ8_MEMBER(gnet_mahjong_panel_r); |
| 394 | 386 | DECLARE_DRIVER_INIT(coh3002t_mp); |
| 395 | 387 | DECLARE_DRIVER_INIT(coh3002t); |
| 396 | 388 | DECLARE_MACHINE_RESET(coh3002t); |
| 397 | 389 | void rf5c296_reg_w(ATTR_UNUSED UINT8 reg, UINT8 data); |
| 398 | 390 | UINT8 rf5c296_reg_r(ATTR_UNUSED UINT8 reg); |
| 399 | | UINT32 gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_mask); |
| 400 | | void gen_flash_w(intelfsh16_device *device, offs_t offset, UINT32 data, UINT32 mem_mask); |
| 401 | 391 | void install_handlers(int mode); |
| 402 | 392 | required_device<cpu_device> m_maincpu; |
| 403 | 393 | required_device<cpu_device> m_mn10200; |
| r22846 | r22847 | |
| 416 | 406 | // Check for card reset |
| 417 | 407 | if (!(data & 0x40)) |
| 418 | 408 | { |
| 419 | | ide_controller_device *card = (ide_controller_device *) machine().device(":card"); |
| 420 | | |
| 421 | | card->reset(); |
| 409 | m_card->reset(); |
| 422 | 410 | m_locked = 0x1ff; |
| 423 | | card->ide_set_gnet_readlock(1); |
| 411 | m_card->ide_set_gnet_readlock(1); |
| 424 | 412 | } |
| 425 | 413 | break; |
| 426 | 414 | |
| r22846 | r22847 | |
| 435 | 423 | return 0x00; |
| 436 | 424 | } |
| 437 | 425 | |
| 438 | | WRITE32_MEMBER(taitogn_state::rf5c296_io_w) |
| 426 | WRITE16_MEMBER(taitogn_state::rf5c296_io_w) |
| 439 | 427 | { |
| 440 | | if(offset < 2) { |
| 441 | | ide_controller32_pcmcia_w(machine().device(":card"), space, offset, data, mem_mask); |
| 428 | if(offset < 4) { |
| 429 | ide_controller16_pcmcia_w(m_card, space, offset, data, mem_mask); |
| 442 | 430 | return; |
| 443 | 431 | } |
| 444 | 432 | |
| 445 | | if(offset == 0x3e0/4) { |
| 433 | if(offset == 0x3e0/2) |
| 434 | { |
| 446 | 435 | if(ACCESSING_BITS_0_7) |
| 447 | 436 | m_rf5c296_reg = data; |
| 448 | 437 | if(ACCESSING_BITS_8_15) |
| r22846 | r22847 | |
| 450 | 439 | } |
| 451 | 440 | } |
| 452 | 441 | |
| 453 | | READ32_MEMBER(taitogn_state::rf5c296_io_r) |
| 442 | READ16_MEMBER(taitogn_state::rf5c296_io_r) |
| 454 | 443 | { |
| 455 | | if(offset < 2) |
| 456 | | return ide_controller32_pcmcia_r(machine().device(":card"), space, offset, mem_mask); |
| 444 | if(offset < 4) |
| 445 | return ide_controller16_pcmcia_r(m_card, space, offset, mem_mask); |
| 457 | 446 | |
| 458 | | offset *= 4; |
| 447 | offset *= 2; |
| 459 | 448 | |
| 460 | | if(offset == 0x3e0/4) { |
| 461 | | UINT32 res = 0xffff0000; |
| 449 | if(offset == 0x3e0/2) |
| 450 | { |
| 451 | UINT32 res = 0x0000; |
| 462 | 452 | if(ACCESSING_BITS_0_7) |
| 463 | 453 | res |= m_rf5c296_reg; |
| 464 | 454 | if(ACCESSING_BITS_8_15) |
| r22846 | r22847 | |
| 466 | 456 | return res; |
| 467 | 457 | } |
| 468 | 458 | |
| 469 | | return 0xffffffff; |
| 459 | return 0xffff; |
| 470 | 460 | } |
| 471 | 461 | |
| 472 | 462 | // Hardcoded to reach the pcmcia CIS |
| 473 | 463 | |
| 474 | | READ32_MEMBER(taitogn_state::rf5c296_mem_r) |
| 464 | READ16_MEMBER(taitogn_state::rf5c296_mem_r) |
| 475 | 465 | { |
| 476 | | if(offset < 0x80) |
| 477 | | return (m_cis[offset*2+1] << 16) | m_cis[offset*2]; |
| 466 | if(offset < 0x100) |
| 467 | return m_cis[offset]; |
| 478 | 468 | |
| 479 | 469 | switch(offset) { |
| 480 | | case 0x080: return 0x00800041; |
| 481 | | case 0x081: return 0x0000002e; |
| 482 | | case 0x100: return m_locked ? 0x00010000 : 0; |
| 470 | case 0x100: return 0x0041; |
| 471 | case 0x101: return 0x0080; |
| 472 | case 0x102: return 0x002e; |
| 473 | case 0x201: return m_locked ? 0x0001 : 0; |
| 483 | 474 | default: |
| 484 | 475 | return 0; |
| 485 | 476 | } |
| 486 | 477 | } |
| 487 | 478 | |
| 488 | | WRITE32_MEMBER(taitogn_state::rf5c296_mem_w) |
| 479 | WRITE16_MEMBER(taitogn_state::rf5c296_mem_w) |
| 489 | 480 | { |
| 490 | | if(offset >= 0x140 && offset <= 0x144) { |
| 481 | if(offset >= 0x280 && offset <= 0x288) { |
| 491 | 482 | dynamic_buffer key(get_disk_handle(machine(), ":drive_0")->hunk_bytes()); |
| 492 | 483 | |
| 493 | | int pos = (offset - 0x140)*2; |
| 494 | | UINT8 v, k; |
| 495 | | if(ACCESSING_BITS_16_23) { |
| 496 | | v = data >> 16; |
| 497 | | pos++; |
| 498 | | } else |
| 499 | | v = data; |
| 484 | int pos = offset - 0x280; |
| 485 | UINT8 v = data, k; |
| 500 | 486 | get_disk_handle(machine(), ":drive_0")->read_metadata(HARD_DISK_KEY_METADATA_TAG, 0, key); |
| 501 | 487 | k = pos < key.count() ? key[pos] : 0; |
| 502 | 488 | if(v == k) |
| r22846 | r22847 | |
| 505 | 491 | m_locked |= 1 << pos; |
| 506 | 492 | if (!m_locked) |
| 507 | 493 | { |
| 508 | | ide_controller_device *card = (ide_controller_device *) machine().device(":card"); |
| 509 | | card->ide_set_gnet_readlock(0); |
| 494 | m_card->ide_set_gnet_readlock(0); |
| 510 | 495 | } |
| 511 | 496 | } |
| 512 | 497 | } |
| 513 | 498 | |
| 514 | | |
| 515 | | // Flash handling |
| 516 | | |
| 517 | | UINT32 taitogn_state::gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_mask) |
| 518 | | { |
| 519 | | UINT32 res = 0; |
| 520 | | offset *= 2; |
| 521 | | if(ACCESSING_BITS_0_15) |
| 522 | | res |= device->read(offset); |
| 523 | | if(ACCESSING_BITS_16_31) |
| 524 | | res |= device->read(offset+1) << 16; |
| 525 | | return res; |
| 526 | | } |
| 527 | | |
| 528 | | void taitogn_state::gen_flash_w(intelfsh16_device *device, offs_t offset, UINT32 data, UINT32 mem_mask) |
| 529 | | { |
| 530 | | offset *= 2; |
| 531 | | if(ACCESSING_BITS_0_15) |
| 532 | | device->write(offset, data); |
| 533 | | if(ACCESSING_BITS_16_31) |
| 534 | | device->write(offset+1, data >> 16); |
| 535 | | } |
| 536 | | |
| 537 | | |
| 538 | | READ32_MEMBER(taitogn_state::flash_subbios_r) |
| 539 | | { |
| 540 | | return gen_flash_r(m_biosflash, offset, mem_mask); |
| 541 | | } |
| 542 | | |
| 543 | | WRITE32_MEMBER(taitogn_state::flash_subbios_w) |
| 544 | | { |
| 545 | | gen_flash_w(m_biosflash, offset, data, mem_mask); |
| 546 | | } |
| 547 | | |
| 548 | | READ32_MEMBER(taitogn_state::flash_mn102_r) |
| 549 | | { |
| 550 | | return gen_flash_r(m_pgmflash, offset, mem_mask); |
| 551 | | } |
| 552 | | |
| 553 | | WRITE32_MEMBER(taitogn_state::flash_mn102_w) |
| 554 | | { |
| 555 | | gen_flash_w(m_pgmflash, offset, data, mem_mask); |
| 556 | | } |
| 557 | | |
| 558 | | READ32_MEMBER(taitogn_state::flash_s1_r) |
| 559 | | { |
| 560 | | return gen_flash_r(m_sndflash[0], offset, mem_mask); |
| 561 | | } |
| 562 | | |
| 563 | | WRITE32_MEMBER(taitogn_state::flash_s1_w) |
| 564 | | { |
| 565 | | gen_flash_w(m_sndflash[0], offset, data, mem_mask); |
| 566 | | } |
| 567 | | |
| 568 | | READ32_MEMBER(taitogn_state::flash_s2_r) |
| 569 | | { |
| 570 | | return gen_flash_r(m_sndflash[1], offset, mem_mask); |
| 571 | | } |
| 572 | | |
| 573 | | WRITE32_MEMBER(taitogn_state::flash_s2_w) |
| 574 | | { |
| 575 | | gen_flash_w(m_sndflash[1], offset, data, mem_mask); |
| 576 | | } |
| 577 | | |
| 578 | | READ32_MEMBER(taitogn_state::flash_s3_r) |
| 579 | | { |
| 580 | | return gen_flash_r(m_sndflash[2], offset, mem_mask); |
| 581 | | } |
| 582 | | |
| 583 | | WRITE32_MEMBER(taitogn_state::flash_s3_w) |
| 584 | | { |
| 585 | | gen_flash_w(m_sndflash[2], offset, data, mem_mask); |
| 586 | | } |
| 587 | | |
| 588 | 499 | void taitogn_state::install_handlers(int mode) |
| 589 | 500 | { |
| 590 | 501 | address_space &a = m_maincpu->space(AS_PROGRAM); |
| 591 | 502 | if(mode == 0) { |
| 592 | 503 | // Mode 0 has access to the subbios, the mn102 flash and the rf5c296 mem zone |
| 593 | | a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_subbios_r),this), write32_delegate(FUNC(taitogn_state::flash_subbios_w),this)); |
| 594 | | a.install_readwrite_handler(0x1f200000, 0x1f2fffff, read32_delegate(FUNC(taitogn_state::rf5c296_mem_r),this), write32_delegate(FUNC(taitogn_state::rf5c296_mem_w),this)); |
| 595 | | a.install_readwrite_handler(0x1f300000, 0x1f37ffff, read32_delegate(FUNC(taitogn_state::flash_mn102_r),this), write32_delegate(FUNC(taitogn_state::flash_mn102_w),this)); |
| 504 | a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read16_delegate(FUNC(intelfsh16_device::read),m_biosflash), write16_delegate(FUNC(intel_te28f160_device::write),m_biosflash), 0xffffffff); |
| 505 | a.install_readwrite_handler(0x1f200000, 0x1f2fffff, read16_delegate(FUNC(taitogn_state::rf5c296_mem_r),this), write16_delegate(FUNC(taitogn_state::rf5c296_mem_w),this), 0xffffffff); |
| 506 | a.install_readwrite_handler(0x1f300000, 0x1f37ffff, read16_delegate(FUNC(intelfsh16_device::read),m_pgmflash), write16_delegate(FUNC(intelfsh16_device::write),m_pgmflash), 0xffffffff); |
| 596 | 507 | a.nop_readwrite(0x1f380000, 0x1f5fffff); |
| 597 | 508 | |
| 598 | 509 | } else { |
| 599 | 510 | // Mode 1 has access to the 3 samples flashes |
| 600 | | a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_s1_r),this), write32_delegate(FUNC(taitogn_state::flash_s1_w),this)); |
| 601 | | a.install_readwrite_handler(0x1f200000, 0x1f3fffff, read32_delegate(FUNC(taitogn_state::flash_s2_r),this), write32_delegate(FUNC(taitogn_state::flash_s2_w),this)); |
| 602 | | a.install_readwrite_handler(0x1f400000, 0x1f5fffff, read32_delegate(FUNC(taitogn_state::flash_s3_r),this), write32_delegate(FUNC(taitogn_state::flash_s3_w),this)); |
| 511 | a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read16_delegate(FUNC(intelfsh16_device::read),m_sndflash[0]), write16_delegate(FUNC(intelfsh16_device::write),m_sndflash[0]), 0xffffffff); |
| 512 | a.install_readwrite_handler(0x1f200000, 0x1f3fffff, read16_delegate(FUNC(intelfsh16_device::read),m_sndflash[1]), write16_delegate(FUNC(intelfsh16_device::write),m_sndflash[1]), 0xffffffff); |
| 513 | a.install_readwrite_handler(0x1f400000, 0x1f5fffff, read16_delegate(FUNC(intelfsh16_device::read),m_sndflash[2]), write16_delegate(FUNC(intelfsh16_device::write),m_sndflash[2]), 0xffffffff); |
| 603 | 514 | } |
| 604 | 515 | } |
| 605 | 516 | |
| 606 | 517 | // Misc. controls |
| 607 | 518 | |
| 608 | | READ32_MEMBER(taitogn_state::control_r) |
| 519 | READ8_MEMBER(taitogn_state::control_r) |
| 609 | 520 | { |
| 610 | 521 | // fprintf(stderr, "gn_r %08x @ %08x (%s)\n", 0x1fb00000+4*offset, mem_mask, machine().describe_context()); |
| 611 | 522 | return m_control; |
| 612 | 523 | } |
| 613 | 524 | |
| 614 | | WRITE32_MEMBER(taitogn_state::control_w) |
| 525 | WRITE8_MEMBER(taitogn_state::control_w) |
| 615 | 526 | { |
| 616 | 527 | // 20 = watchdog |
| 617 | 528 | // 04 = select bank |
| r22846 | r22847 | |
| 643 | 554 | install_handlers(m_control & 4 ? 1 : 0); |
| 644 | 555 | } |
| 645 | 556 | |
| 646 | | WRITE32_MEMBER(taitogn_state::control2_w) |
| 557 | WRITE16_MEMBER(taitogn_state::control2_w) |
| 647 | 558 | { |
| 648 | 559 | COMBINE_DATA(&m_control2); |
| 649 | 560 | } |
| 650 | 561 | |
| 651 | | READ32_MEMBER(taitogn_state::control3_r) |
| 562 | READ8_MEMBER(taitogn_state::control3_r) |
| 652 | 563 | { |
| 653 | 564 | return m_control3; |
| 654 | 565 | } |
| 655 | 566 | |
| 656 | | WRITE32_MEMBER(taitogn_state::control3_w) |
| 567 | WRITE8_MEMBER(taitogn_state::control3_w) |
| 657 | 568 | { |
| 658 | 569 | COMBINE_DATA(&m_control3); |
| 659 | 570 | } |
| 660 | 571 | |
| 661 | | READ32_MEMBER(taitogn_state::gn_1fb70000_r) |
| 572 | READ16_MEMBER(taitogn_state::gn_1fb70000_r) |
| 662 | 573 | { |
| 663 | 574 | // (1328) 1348 tests mask 0002, 8 times. |
| 664 | 575 | // Called by 1434, exit at 143c |
| r22846 | r22847 | |
| 670 | 581 | return 2; |
| 671 | 582 | } |
| 672 | 583 | |
| 673 | | WRITE32_MEMBER(taitogn_state::gn_1fb70000_w) |
| 584 | WRITE16_MEMBER(taitogn_state::gn_1fb70000_w) |
| 674 | 585 | { |
| 675 | 586 | // Writes 0 or 1 all the time, it *may* have somthing to do with |
| 676 | 587 | // i/o port width, but then maybe not |
| 677 | 588 | } |
| 678 | 589 | |
| 679 | | READ32_MEMBER(taitogn_state::hack1_r) |
| 590 | READ16_MEMBER(taitogn_state::hack1_r) |
| 680 | 591 | { |
| 681 | | m_v = m_v ^ 8; |
| 682 | | // Probably something to do with sound |
| 683 | | return m_v; |
| 592 | switch(offset) |
| 593 | { |
| 594 | case 0: |
| 595 | m_v = m_v ^ 8; |
| 596 | // Probably something to do with sound |
| 597 | return m_v; |
| 598 | } |
| 599 | |
| 600 | return 0; |
| 684 | 601 | } |
| 685 | 602 | |
| 686 | 603 | |
| r22846 | r22847 | |
| 690 | 607 | static const UINT8 tt10[ 8 ] = { 0x80, 0x20, 0x38, 0x08, 0xf1, 0x03, 0xfe, 0xfc }; |
| 691 | 608 | static const UINT8 tt16[ 8 ] = { 0xc0, 0x04, 0xf9, 0xe1, 0x60, 0x70, 0xf2, 0x02 }; |
| 692 | 609 | |
| 693 | | READ32_MEMBER(taitogn_state::znsecsel_r) |
| 610 | READ8_MEMBER(taitogn_state::znsecsel_r) |
| 694 | 611 | { |
| 695 | 612 | return m_n_znsecsel; |
| 696 | 613 | } |
| 697 | 614 | |
| 698 | | WRITE32_MEMBER(taitogn_state::znsecsel_w) |
| 615 | WRITE8_MEMBER(taitogn_state::znsecsel_w) |
| 699 | 616 | { |
| 700 | 617 | COMBINE_DATA( &m_n_znsecsel ); |
| 701 | 618 | |
| r22846 | r22847 | |
| 704 | 621 | m_zndip->select( ( m_n_znsecsel & 0x8c ) != 0x8c ); |
| 705 | 622 | } |
| 706 | 623 | |
| 707 | | READ32_MEMBER(taitogn_state::boardconfig_r) |
| 624 | READ8_MEMBER(taitogn_state::boardconfig_r) |
| 708 | 625 | { |
| 709 | 626 | /* |
| 710 | 627 | ------00 mem=4M |
| r22846 | r22847 | |
| 729 | 646 | } |
| 730 | 647 | |
| 731 | 648 | |
| 732 | | WRITE32_MEMBER(taitogn_state::coin_w) |
| 649 | WRITE8_MEMBER(taitogn_state::coin_w) |
| 733 | 650 | { |
| 734 | 651 | /* 0x01=counter |
| 735 | 652 | 0x02=coin lock 1 |
| r22846 | r22847 | |
| 737 | 654 | 0x20=coin lock 2 |
| 738 | 655 | 0x80=?? |
| 739 | 656 | */ |
| 740 | | COMBINE_DATA (&m_coin_info); |
| 657 | m_coin_info = data; |
| 741 | 658 | } |
| 742 | 659 | |
| 743 | | READ32_MEMBER(taitogn_state::coin_r) |
| 660 | READ8_MEMBER(taitogn_state::coin_r) |
| 744 | 661 | { |
| 745 | 662 | return m_coin_info; |
| 746 | 663 | } |
| 747 | 664 | |
| 748 | 665 | /* mahjong panel handler (for Usagi & Mahjong Oh) */ |
| 749 | | READ32_MEMBER(taitogn_state::gnet_mahjong_panel_r) |
| 666 | READ8_MEMBER(taitogn_state::gnet_mahjong_panel_r) |
| 750 | 667 | { |
| 751 | 668 | m_mux_data = m_coin_info; |
| 752 | 669 | m_mux_data &= 0xcc; |
| r22846 | r22847 | |
| 785 | 702 | DRIVER_INIT_MEMBER(taitogn_state,coh3002t_mp) |
| 786 | 703 | { |
| 787 | 704 | DRIVER_INIT_CALL(coh3002t); |
| 788 | | m_maincpu->space(AS_PROGRAM).install_read_handler(0x1fa10100, 0x1fa10103, read32_delegate(FUNC(taitogn_state::gnet_mahjong_panel_r),this)); |
| 705 | m_maincpu->space(AS_PROGRAM).install_read_handler(0x1fa10100, 0x1fa10103, read8_delegate(FUNC(taitogn_state::gnet_mahjong_panel_r),this), 0x000000ff); |
| 789 | 706 | } |
| 790 | 707 | |
| 791 | 708 | MACHINE_RESET_MEMBER(taitogn_state,coh3002t) |
| r22846 | r22847 | |
| 794 | 711 | install_handlers(0); |
| 795 | 712 | m_control = 0; |
| 796 | 713 | |
| 797 | | ide_controller_device *card = (ide_controller_device *) machine().device(":card"); |
| 798 | | card->reset(); |
| 799 | | card->ide_set_gnet_readlock(1); |
| 714 | m_card->reset(); |
| 715 | m_card->ide_set_gnet_readlock(1); |
| 800 | 716 | |
| 801 | 717 | // halt sound CPU since it has no valid program at start |
| 802 | 718 | m_mn10200->set_input_line(INPUT_LINE_RESET,ASSERT_LINE); /* MCU */ |
| 803 | 719 | } |
| 804 | 720 | |
| 805 | 721 | static ADDRESS_MAP_START( taitogn_map, AS_PROGRAM, 32, taitogn_state ) |
| 806 | | AM_RANGE(0x1f000000, 0x1f1fffff) AM_READWRITE(flash_s1_r, flash_s1_w) |
| 807 | | AM_RANGE(0x1f200000, 0x1f3fffff) AM_READWRITE(flash_s2_r, flash_s2_w) |
| 808 | | AM_RANGE(0x1f400000, 0x1f5fffff) AM_READWRITE(flash_s3_r, flash_s3_w) |
| 722 | // AM_RANGE(0x1f000000, 0x1f1fffff) AM_DEVREADWRITE16("sndflash0", intelfsh16_device, read, write, 0xffffffff) |
| 723 | // AM_RANGE(0x1f200000, 0x1f3fffff) AM_DEVREADWRITE16("sndflash1", intelfsh16_device, read, write, 0xffffffff) |
| 724 | // AM_RANGE(0x1f400000, 0x1f5fffff) AM_DEVREADWRITE16("sndflash2", intelfsh16_device, read, write, 0xffffffff) |
| 809 | 725 | AM_RANGE(0x1fa00000, 0x1fa00003) AM_READ_PORT("P1") |
| 810 | 726 | AM_RANGE(0x1fa00100, 0x1fa00103) AM_READ_PORT("P2") |
| 811 | 727 | AM_RANGE(0x1fa00200, 0x1fa00203) AM_READ_PORT("SERVICE") |
| 812 | 728 | AM_RANGE(0x1fa00300, 0x1fa00303) AM_READ_PORT("SYSTEM") |
| 813 | 729 | AM_RANGE(0x1fa10000, 0x1fa10003) AM_READ_PORT("P3") |
| 814 | 730 | AM_RANGE(0x1fa10100, 0x1fa10103) AM_READ_PORT("P4") |
| 815 | | AM_RANGE(0x1fa10200, 0x1fa10203) AM_READ(boardconfig_r) |
| 816 | | AM_RANGE(0x1fa10300, 0x1fa10303) AM_READWRITE(znsecsel_r, znsecsel_w) |
| 817 | | AM_RANGE(0x1fa20000, 0x1fa20003) AM_READWRITE(coin_r, coin_w) |
| 818 | | AM_RANGE(0x1fa30000, 0x1fa30003) AM_READWRITE(control3_r, control3_w) |
| 731 | AM_RANGE(0x1fa10200, 0x1fa10203) AM_READ8(boardconfig_r, 0x000000ff) |
| 732 | AM_RANGE(0x1fa10300, 0x1fa10303) AM_READWRITE8(znsecsel_r, znsecsel_w, 0x000000ff) |
| 733 | AM_RANGE(0x1fa20000, 0x1fa20003) AM_READWRITE8(coin_r, coin_w, 0x000000ff) |
| 734 | AM_RANGE(0x1fa30000, 0x1fa30003) AM_READWRITE8(control3_r, control3_w, 0x000000ff) |
| 819 | 735 | AM_RANGE(0x1fa51c00, 0x1fa51dff) AM_READNOP // systematic read at spu_address + 250000, result dropped, maybe other accesses |
| 820 | | AM_RANGE(0x1fa60000, 0x1fa60003) AM_READ(hack1_r) |
| 736 | AM_RANGE(0x1fa60000, 0x1fa60003) AM_READ16(hack1_r, 0xffffffff) |
| 821 | 737 | AM_RANGE(0x1faf0000, 0x1faf07ff) AM_DEVREADWRITE8("at28c16", at28c16_device, read, write, 0xffffffff) /* eeprom */ |
| 822 | | AM_RANGE(0x1fb00000, 0x1fb0ffff) AM_READWRITE(rf5c296_io_r, rf5c296_io_w) |
| 823 | | AM_RANGE(0x1fb40000, 0x1fb40003) AM_READWRITE(control_r, control_w) |
| 824 | | AM_RANGE(0x1fb60000, 0x1fb60003) AM_WRITE(control2_w) |
| 825 | | AM_RANGE(0x1fb70000, 0x1fb70003) AM_READWRITE(gn_1fb70000_r, gn_1fb70000_w) |
| 738 | AM_RANGE(0x1fb00000, 0x1fb0ffff) AM_READWRITE16(rf5c296_io_r, rf5c296_io_w, 0xffffffff) |
| 739 | AM_RANGE(0x1fb40000, 0x1fb40003) AM_READWRITE8(control_r, control_w, 0x000000ff) |
| 740 | AM_RANGE(0x1fb60000, 0x1fb60003) AM_WRITE16(control2_w, 0x0000ffff) |
| 741 | AM_RANGE(0x1fb70000, 0x1fb70003) AM_READWRITE16(gn_1fb70000_r, gn_1fb70000_w, 0x0000ffff) |
| 826 | 742 | AM_RANGE(0x1fbe0000, 0x1fbe01ff) AM_RAM // 256 bytes com zone with the mn102, low bytes of words only, with additional comm at 1fb80000 |
| 827 | 743 | ADDRESS_MAP_END |
| 828 | 744 | |